fog-openstack 0.1.19 → 0.1.20

data/lib/fog/compute/openstack/requests/list_os_interfaces.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class OpenStack
+      class Real
+        def list_os_interfaces(server_id)
+          request(
+            :expects => [200, 203],
+            :method  => 'GET',
+            :path    => "servers/#{server_id}/os-interface"
+          )
+        end
+      end
+
+      class Mock
+        def list_os_interfaces(server_id)
+          Excon::Response.new(
+            :body   => {'interfaceAttachments' => data[:os_interfaces]},
+            :status => 200
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/dns/openstack/v2/requests/create_zone.rb

@@ -9,7 +9,7 @@ module Fog
               'email' => email
             }
 
-            vanilla_options = [:ttl, :description, :type, :masters]
+            vanilla_options = [:ttl, :description, :type, :masters, :attributes]
 
             vanilla_options.select { |o| options[o] }.each do |key|
               data[key] = options[key]

data/lib/fog/event/openstack.rb

@@ -0,0 +1,120 @@
+module Fog
+  module Event
+    class OpenStack < Fog::Service
+      SUPPORTED_VERSIONS = /v2/
+
+      requires :openstack_auth_url
+      recognizes :openstack_auth_token, :openstack_management_url,
+                 :persistent, :openstack_service_type, :openstack_service_name,
+                 :openstack_tenant, :openstack_tenant_id,
+                 :openstack_api_key, :openstack_username, :openstack_identity_endpoint,
+                 :current_user, :current_tenant, :openstack_region,
+                 :openstack_endpoint_type, :openstack_cache_ttl,
+                 :openstack_project_name, :openstack_project_id,
+                 :openstack_project_domain, :openstack_user_domain, :openstack_domain_name,
+                 :openstack_project_domain_id, :openstack_user_domain_id, :openstack_domain_id,
+                 :openstack_identity_prefix
+
+      model_path 'fog/event/openstack/models'
+
+      model       :event
+      collection  :events
+
+      request_path 'fog/event/openstack/requests'
+
+      request :get_event
+      request :list_events
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :users   => {},
+              :tenants => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options = {})
+          @openstack_username = options[:openstack_username]
+          @openstack_tenant   = options[:openstack_tenant]
+          @openstack_auth_uri = URI.parse(options[:openstack_auth_url])
+
+          @auth_token = Fog::Mock.random_base64(64)
+          @auth_token_expiration = (Time.now.utc + 86400).iso8601
+
+          management_url = URI.parse(options[:openstack_auth_url])
+          management_url.port = 8779
+          management_url.path = '/v2'
+          @openstack_management_url = management_url.to_s
+
+          @data ||= {:users => {}}
+          unless @data[:users].find { |u| u['name'] == options[:openstack_username] }
+            id = Fog::Mock.random_numbers(6).to_s
+            @data[:users][id] = {
+              'id'       => id,
+              'name'     => options[:openstack_username],
+              'email'    => "#{options[:openstack_username]}@mock.com",
+              'tenantId' => Fog::Mock.random_numbers(6).to_s,
+              'enabled'  => true
+            }
+          end
+        end
+
+        def data
+          self.class.data[@openstack_username]
+        end
+
+        def reset_data
+          self.class.data.delete(@openstack_username)
+        end
+
+        def credentials
+          {:provider                 => 'openstack',
+           :openstack_auth_url       => @openstack_auth_uri.to_s,
+           :openstack_auth_token     => @auth_token,
+           :openstack_management_url => @openstack_management_url}
+        end
+      end
+
+      class Real
+        include Fog::OpenStack::Core
+
+        def self.not_found_class
+          Fog::Event::OpenStack::NotFound
+        end
+
+        def initialize(options = {})
+          initialize_identity options
+
+          @openstack_service_type           = options[:openstack_service_type] || ['event']
+          @openstack_service_name           = options[:openstack_service_name]
+          @openstack_endpoint_type          = options[:openstack_endpoint_type] || 'publicURL'
+
+          @connection_options               = options[:connection_options] || {}
+
+          authenticate
+          set_api_path
+
+          @persistent = options[:persistent] || false
+          @connection = Fog::Core::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def set_api_path
+          unless @path.match(SUPPORTED_VERSIONS)
+            @path = "/" + Fog::OpenStack.get_supported_version(
+              SUPPORTED_VERSIONS,
+              @openstack_management_uri,
+              @auth_token,
+              @connection_options
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/event/openstack/models/event.rb

@@ -0,0 +1,16 @@
+require 'fog/openstack/models/model'
+
+module Fog
+  module Event
+    class OpenStack
+      class Event < Fog::OpenStack::Model
+        identity :message_id
+
+        attribute :event_type
+        attribute :generated
+        attribute :raw
+        attribute :traits
+      end
+    end
+  end
+end

data/lib/fog/event/openstack/models/events.rb

@@ -0,0 +1,23 @@
+require 'fog/openstack/models/collection'
+require 'fog/event/openstack/models/event'
+
+module Fog
+  module Event
+    class OpenStack
+      class Events < Fog::OpenStack::Collection
+        model Fog::Event::OpenStack::Event
+
+        def all(q = [])
+          load_response(service.list_events(q))
+        end
+
+        def find_by_id(message_id)
+          event = service.get_event(message_id).body
+          new(event)
+        rescue Fog::Event::OpenStack::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/event/openstack/requests/get_event.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Event
+    class OpenStack
+      class Real
+        def get_event(message_id)
+          request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => "events/#{message_id}"
+          )
+        end
+      end
+
+      class Mock
+        def get_event(_message_id)
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'event_type' => 'compute.instance.create',
+            'message_id' => 'd646b40dea6347dfb8caee2da1484c56',
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/event/openstack/requests/list_events.rb

@@ -0,0 +1,42 @@
+module Fog
+  module Event
+    class OpenStack
+      class Real
+        def list_events(options = [])
+          data = {
+            'q' => []
+          }
+
+          options.each do |opt|
+            filter = {}
+
+            ['field', 'op', 'value'].each do |key|
+              filter[key] = opt[key] if opt[key]
+            end
+
+            data['q'] << filter unless filter.empty?
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 200,
+            :method  => 'GET',
+            :path    => 'events'
+          )
+        end
+      end
+
+      class Mock
+        def list_events(_options = {})
+          response = Excon::Response.new
+          response.status = 200
+          response.body = [{
+            'event_type' => 'compute.instance.create',
+            'message_id' => 'd646b40dea6347dfb8caee2da1484c56',
+          }]
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/identity/openstack/v3/models/domains.rb

@@ -9,13 +9,19 @@ module Fog
           model Fog::Identity::OpenStack::V3::Domain
 
           def all(options = {})
-            cache = Fog::Identity::OpenStack::V3::Domain.cache
-            cached_domain, expires = cache[{:token => service.auth_token, :options => options}]
-            return cached_domain if cached_domain && expires > Time.now
-            domain_to_cache = load_response(service.list_domains(options), 'domains')
+            if service.openstack_cache_ttl > 0
+              cached_domain, expires = Fog::Identity::OpenStack::V3::Domain.cache[{:token   => service.auth_token,
+                                                                                   :options => options}]
+              return cached_domain if cached_domain && expires > Time.now
+            end
 
-            cache[{:token => service.auth_token, :options => options}] = domain_to_cache, Time.now + 30 # 30-second TTL
-            Fog::Identity::OpenStack::V3::Domain.cache = cache
+            domain_to_cache = load_response(service.list_domains(options), 'domains')
+            if service.openstack_cache_ttl > 0
+              cache = Fog::Identity::OpenStack::V3::Domain.cache
+              cache[{:token => service.auth_token, :options => options}] = [domain_to_cache,
+                                                                            Time.now + service.openstack_cache_ttl]
+              Fog::Identity::OpenStack::V3::Domain.cache = cache
+            end
             domain_to_cache
           end
 
@@ -28,15 +34,21 @@ module Fog
           end
 
           def find_by_id(id)
-            cache = Fog::Identity::OpenStack::V3::Domain.cache
-            cached_domain, expires = cache[{:token => service.auth_token, :id => id}]
-            return cached_domain if cached_domain && expires > Time.now
+            if service.openstack_cache_ttl > 0
+              cached_domain, expires = Fog::Identity::OpenStack::V3::Domain.cache[{:token => service.auth_token,
+                                                                                   :id    => id}]
+              return cached_domain if cached_domain && expires > Time.now
+            end
             domain_hash = service.get_domain(id).body['domain']
             domain_to_cache = Fog::Identity::OpenStack::V3::Domain.new(
               domain_hash.merge(:service => service)
             )
-            cache[{:token => service.auth_token, :id => id}] = domain_to_cache, Time.now + 30 # 30-second TTL
-            Fog::Identity::OpenStack::V3::Domain.cache = cache
+
+            if service.openstack_cache_ttl > 0
+              cache = Fog::Identity::OpenStack::V3::Domain.cache
+              cache[{:token => service.auth_token, :id => id}] = [domain_to_cache, Time.now + service.openstack_cache_ttl]
+              Fog::Identity::OpenStack::V3::Domain.cache = cache
+            end
             domain_to_cache
           end
 

data/lib/fog/key_manager/openstack.rb

@@ -89,7 +89,7 @@ module Fog
             end
           end
 
-          if version.blank?
+          if !version  || version.empty?
             raise Fog::OpenStack::Errors::ServiceUnavailable.new(
                     "OpenStack service only supports API versions #{supported_versions.inspect}")
           end

data/lib/fog/metering/openstack.rb

@@ -22,6 +22,7 @@ module Fog
       model       :resource
       collection  :resources
 
+      # Events extracted from Ceilometer (metering service) to Panko (event service) since Ocata release
       model       :event
       collection  :events
 

data/lib/fog/network/openstack.rb

@@ -28,6 +28,8 @@ module Fog
       collection  :ports
       model       :subnet
       collection  :subnets
+      model       :subnet_pool
+      collection  :subnet_pools
       model       :floating_ip
       collection  :floating_ips
       model       :router
@@ -84,6 +86,13 @@ module Fog
       request :get_subnet
       request :update_subnet
 
+      # Subnet Pools CRUD
+      request :list_subnet_pools
+      request :create_subnet_pool
+      request :delete_subnet_pool
+      request :get_subnet_pool
+      request :update_subnet_pool
+
       # FloatingIp CRUD
       request :list_floating_ips
       request :create_floating_ip
@@ -296,6 +305,7 @@ module Fog
                   'tenant_id'        => tenant_id,
                 }
               },
+              :subnet_pools           => {},
               :floating_ips           => {},
               :routers                => {},
               :lb_pools               => {},

data/lib/fog/network/openstack/models/subnet_pool.rb

@@ -0,0 +1,47 @@
+require 'fog/openstack/models/model'
+
+module Fog
+  module Network
+    class OpenStack
+      class SubnetPool < Fog::OpenStack::Model
+        identity :id
+
+        attribute :name
+        attribute :prefixes
+        attribute :description
+        attribute :address_scope_id
+        attribute :shared
+        attribute :ip_version
+        attribute :min_prefixlen
+        attribute :max_prefixlen
+        attribute :default_prefixlen
+        attribute :is_default
+        attribute :default_quota
+        attribute :created_at
+        attribute :updated_at
+        attribute :tenant_id
+
+        def create
+          requires :name, :prefixes
+          merge_attributes(service.create_subnet_pool(name,
+                                                      prefixes,
+                                                      attributes).body['subnetpool'])
+          self
+        end
+
+        def update
+          requires :id
+          merge_attributes(service.update_subnet_pool(id,
+                                                      attributes).body['subnetpool'])
+          self
+        end
+
+        def destroy
+          requires :id
+          service.delete_subnet_pool(id)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/network/openstack/models/subnet_pools.rb

@@ -0,0 +1,33 @@
+require 'fog/openstack/models/collection'
+require 'fog/network/openstack/models/subnet_pool'
+
+module Fog
+  module Network
+    class OpenStack
+      class SubnetPools < Fog::OpenStack::Collection
+        attribute :filters
+
+        model Fog::Network::OpenStack::SubnetPool
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters_arg = filters)
+          filters = filters_arg
+          load_response(service.list_subnet_pools(filters), 'subnetpools')
+        end
+
+        def get(subnet_pool_id)
+          subnet_pool = service.get_subnet_pool(subnet_pool_id).body['subnetpool']
+          if subnet_pool
+            new(subnet_pool)
+          end
+        rescue Fog::Network::OpenStack::NotFound
+          nil
+        end
+      end
+    end
+  end
+end