fog 1.6.0 → 1.7.0

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

@@ -0,0 +1,52 @@
+require 'fog/core/model'
+
+module Fog
+  module Network
+    class OpenStack
+      class Port < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :network_id
+        attribute :fixed_ips
+        attribute :mac_address
+        attribute :status
+        attribute :admin_state_up
+        attribute :device_owner
+        attribute :device_id
+        attribute :tenant_id
+
+        def initialize(attributes)
+          @connection = attributes[:connection]
+          super
+        end
+
+        def save
+          requires :network_id
+          identity ? update : create
+        end
+
+        def create
+          requires :network_id
+          merge_attributes(connection.create_port(self.network_id,
+                                                  self.attributes).body['port'])
+          self
+        end
+
+        def update
+          requires :id, :network_id
+          merge_attributes(connection.update_port(self.id,
+                                                  self.attributes).body['port'])
+          self
+        end
+
+        def destroy
+          requires :id
+          connection.delete_port(self.id)
+          true
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'fog/core/collection'
+require 'fog/openstack/models/network/port'
+
+module Fog
+  module Network
+    class OpenStack
+      class Ports < Fog::Collection
+
+        attribute :filters
+
+        model Fog::Network::OpenStack::Port
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          load(connection.list_ports(filters).body['ports'])
+        end
+
+        def get(port_id)
+          if port = connection.get_port(port_id).body['port']
+            new(port)
+          end
+        rescue Fog::Network::OpenStack::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'fog/core/model'
+
+module Fog
+  module Network
+    class OpenStack
+      class Subnet < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :network_id
+        attribute :cidr
+        attribute :ip_version
+        attribute :gateway_ip
+        attribute :allocation_pools
+        attribute :dns_nameservers
+        attribute :host_routes
+        attribute :enable_dhcp
+        attribute :tenant_id
+
+        def initialize(attributes)
+          @connection = attributes[:connection]
+          super
+        end
+
+        def save
+          requires :network_id, :cidr, :ip_version
+          identity ? update : create
+        end
+
+        def create
+          requires :network_id, :cidr, :ip_version
+          merge_attributes(connection.create_subnet(self.network_id,
+                                                    self.cidr,
+                                                    self.ip_version,
+                                                    self.attributes).body['subnet'])
+          self
+        end
+
+        def update
+          requires :id, :network_id, :cidr, :ip_version
+          merge_attributes(connection.update_subnet(self.id,
+                                                    self.attributes).body['subnet'])
+          self
+        end
+
+        def destroy
+          requires :id
+          connection.delete_subnet(self.id)
+          true
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'fog/core/collection'
+require 'fog/openstack/models/network/subnet'
+
+module Fog
+  module Network
+    class OpenStack
+      class Subnets < Fog::Collection
+
+        attribute :filters
+
+        model Fog::Network::OpenStack::Subnet
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          load(connection.list_subnets(filters).body['subnets'])
+        end
+
+        def get(subnet_id)
+          if subnet = connection.get_subnet(subnet_id).body['subnet']
+            new(subnet)
+          end
+        rescue Fog::Network::OpenStack::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/openstack/network.rb

@@ -0,0 +1,234 @@
+require 'fog/openstack'
+
+module Fog
+  module Network
+    class OpenStack < Fog::Service
+
+      requires :openstack_auth_url
+      recognizes :openstack_auth_token, :openstack_management_url, :persistent,
+                 :openstack_service_name, :openstack_tenant,
+                 :openstack_api_key, :openstack_username,
+                 :current_user, :current_tenant
+
+      ## MODELS
+      #
+      model_path 'fog/openstack/models/network'
+      model       :network
+      collection  :networks
+      model       :port
+      collection  :ports
+      model       :subnet
+      collection  :subnets
+
+      ## REQUESTS
+      #
+      request_path 'fog/openstack/requests/network'
+
+      # Network CRUD
+      request :list_networks
+      request :create_network
+      request :delete_network
+      request :get_network
+      request :update_network
+
+      # Port CRUD
+      request :list_ports
+      request :create_port
+      request :delete_port
+      request :get_port
+      request :update_port
+
+      # Subnet CRUD
+      request :list_subnets
+      request :create_subnet
+      request :delete_subnet
+      request :get_subnet
+      request :update_subnet
+
+      # Tenant
+      request :set_tenant
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :networks => {},
+              :ports => {},
+              :subnets => {},
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @openstack_username = options[:openstack_username]
+          @openstack_tenant   = options[:openstack_tenant]
+        end
+
+        def data
+          self.class.data["#{@openstack_username}-#{@openstack_tenant}"]
+        end
+
+        def reset_data
+          self.class.data.delete("#{@openstack_username}-#{@openstack_tenant}")
+        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
+        attr_reader :current_user
+        attr_reader :current_tenant
+
+        def initialize(options={})
+          require 'multi_json'
+
+          @openstack_auth_token = options[:openstack_auth_token]
+
+          unless @openstack_auth_token
+            missing_credentials = Array.new
+            @openstack_api_key  = options[:openstack_api_key]
+            @openstack_username = options[:openstack_username]
+
+            missing_credentials << :openstack_api_key  unless @openstack_api_key
+            missing_credentials << :openstack_username unless @openstack_username
+            raise ArgumentError, "Missing required arguments: #{missing_credentials.join(', ')}" unless missing_credentials.empty?
+          end
+
+          @openstack_tenant               = options[:openstack_tenant]
+          @openstack_auth_uri             = URI.parse(options[:openstack_auth_url])
+          @openstack_management_url       = options[:openstack_management_url]
+          @openstack_must_reauthenticate  = false
+          @openstack_service_name         = options[:openstack_service_name] || ['network']
+
+          @connection_options = options[:connection_options] || {}
+
+          @current_user = options[:current_user]
+          @current_tenant = options[:current_tenant]
+
+          authenticate
+
+          @persistent = options[:persistent] || false
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def credentials
+          { :provider                 => 'openstack',
+            :openstack_auth_url       => @openstack_auth_uri.to_s,
+            :openstack_auth_token     => @auth_token,
+            :openstack_management_url => @openstack_management_url,
+            :current_user             => @current_user,
+            :current_tenant           => @current_tenant }
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          begin
+            response = @connection.request(params.merge({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'Accept' => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{@path}/#{params[:path]}"#,
+              # Causes errors for some requests like tenants?limit=1
+              # :query    => ('ignore_awful_caching' << Time.now.to_i.to_s)
+            }))
+          rescue Excon::Errors::Unauthorized => error
+            if error.response.body != 'Bad username or password' # token expiration
+              @openstack_must_reauthenticate = true
+              authenticate
+              retry
+            else # bad credentials
+              raise error
+            end
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Network::OpenStack::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          unless response.body.empty?
+            response.body = MultiJson.decode(response.body)
+          end
+          response
+        end
+
+        private
+
+        def authenticate
+          if @openstack_must_reauthenticate || @openstack_auth_token.nil?
+            options = {
+              :openstack_tenant   => @openstack_tenant,
+              :openstack_api_key  => @openstack_api_key,
+              :openstack_username => @openstack_username,
+              :openstack_auth_uri => @openstack_auth_uri,
+              :openstack_auth_token => @openstack_auth_token,
+              :openstack_service_name => @openstack_service_name,
+              :openstack_endpoint_type => 'adminURL'
+            }
+
+            credentials = Fog::OpenStack.authenticate_v2(options, @connection_options)
+
+            @current_user = credentials[:user]
+            @current_tenant = credentials[:tenant]
+
+            @openstack_must_reauthenticate = false
+            @auth_token = credentials[:token]
+            @openstack_management_url = credentials[:server_management_url]
+            uri = URI.parse(@openstack_management_url)
+          else
+            @auth_token = @openstack_auth_token
+            uri = URI.parse(@openstack_management_url)
+          end
+
+          @host   = uri.host
+          @path   = uri.path
+          @path.sub!(/\/$/, '')
+          unless @path.match(/^\/v(\d)+(\.)?(\d)*$/)
+            @path = "/" + retrieve_current_version(uri)
+          end
+          @port   = uri.port
+          @scheme = uri.scheme
+          true
+        end
+
+        def retrieve_current_version(uri)
+          response = Fog::Connection.new(
+            "#{uri.scheme}://#{uri.host}:#{uri.port}", false, @connection_options).request({
+              :expects => [200, 204],
+              :headers => {'Content-Type' => 'application/json',
+                           'Accept' => 'application/json',
+                           'X-Auth-Token' => @auth_token},
+              :host    => uri.host,
+              :method  => 'GET'
+          })
+
+          body = Fog::JSON.decode(response.body)
+          version = nil
+          unless body['versions'].empty?
+            current_version = body['versions'].detect { |x| x["status"] == "CURRENT" }
+            version = current_version["id"]
+          end
+          raise Errors::NotFound.new('No API versions found') if version.nil?
+          version
+        end
+
+      end
+    end
+  end
+end

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

@@ -21,6 +21,16 @@ module Fog
       end
 
       class Mock
+        def attach_volume(volume_id, server_id, device)
+          response = Excon::Response.new
+          response.status = 200
+          response.body ={ "volumeAttachment" => {
+                             "id"       => volume_id,
+                             "volumeId" => volume_id
+                            }
+                         }
+          response
+        end
       end
 
     end

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

@@ -23,21 +23,25 @@ module Fog
 
       class Mock
         def create_security_group(name, description)
+          tenant_id = Fog::Identity.new(:provider => 'OpenStack').current_tenant['id']
+          security_group_id = Fog::Mock.random_numbers(2).to_i
+          self.data[:security_groups][security_group_id] = {
+            'tenant_id' => tenant_id,
+            'rules'     => [],
+            'id'        => security_group_id,
+            'name'      => name,
+            'description' => description
+          }
+
           response = Excon::Response.new
           response.status = 200
           response.headers = {
-            "X-Compute-Request-Id" => "req-c373a42c-2825-4e60-8d34-99416ea850be",
-            "Content-Type" => "application/json",
-            "Content-Length" => "139",
-            "Date" => Date.new}
+            'X-Compute-Request-Id' => "req-#{Fog::Mock.random_hex(32)}",
+            'Content-Type'   => 'application/json',
+            'Content-Length' => Fog::Mock.random_numbers(3).to_s,
+            'Date'           => Date.new}
           response.body = {
-            "security_group" => [{
-              "rules" => [],
-              "tenant_id" => "d5183375ab0343f3a0b4b05f547aefc2",
-              "id" => 999,
-              "name" => name,
-              "description" => description
-            }]
+            'security_group' => self.data[:security_groups].values
           }
           response
         end