fog-openstack 0.1.0

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

@@ -0,0 +1,45 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def create_floating_ip(floating_network_id, options = {})
+          data = {
+            'floatingip' => {
+              'floating_network_id' => floating_network_id
+            }
+          }
+
+          vanilla_options = [:port_id, :tenant_id, :fixed_ip_address ]
+          vanilla_options.reject{ |o| options[o].nil? }.each do |key|
+            data['floatingip'][key] = options[key]
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => [201],
+            :method   => 'POST',
+            :path     => 'floatingips'
+          )
+        end
+      end
+
+      class Mock
+        def create_floating_ip(floating_network_id, options = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'                  => floating_network_id,
+            'floating_network_id' => floating_network_id,
+            'port_id'             => options[:port_id],
+            'tenant_id'           => options[:tenant_id],
+            'fixed_ip_address'    => options[:fixed_ip_address],
+            'router_id'           => nil,
+          }
+          self.data[:floating_ips][data['id']] = data
+          response.body = { 'floatingip' => data }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def create_lb_health_monitor(type, delay, timeout, max_retries, options = {})
+          data = {
+            'health_monitor' => {
+              'type'        => type,
+              'delay'       => delay,
+              'timeout'     => timeout,
+              'max_retries' => max_retries
+            }
+          }
+
+          vanilla_options = [:http_method, :url_path, :expected_codes, :admin_state_up, :tenant_id]
+          vanilla_options.reject{ |o| options[o].nil? }.each do |key|
+            data['health_monitor'][key] = options[key]
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => [201],
+            :method  => 'POST',
+            :path    => 'lb/health_monitors'
+          )
+        end
+      end
+
+      class Mock
+        def create_lb_health_monitor(type, delay, timeout, max_retries, options = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'             => Fog::Mock.random_numbers(6).to_s,
+            'type'           => type,
+            'delay'          => delay,
+            'timeout'        => timeout,
+            'max_retries'    => max_retries,
+            'http_method'    => options[:http_method],
+            'url_path'       => options[:url_path],
+            'expected_codes' => options[:expected_codes],
+            'status'         => 'ACTIVE',
+            'admin_state_up' => options[:admin_state_up],
+            'tenant_id'      => options[:tenant_id],
+          }
+
+          self.data[:lb_health_monitors][data['id']] = data
+          response.body = { 'health_monitor' => data }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def create_lb_member(pool_id, address, protocol_port, weight, options = {})
+          data = {
+            'member' => {
+              'pool_id'       => pool_id,
+              'address'       => address,
+              'protocol_port' => protocol_port,
+              'weight'        => weight
+            }
+          }
+
+          vanilla_options = [:admin_state_up, :tenant_id]
+          vanilla_options.reject{ |o| options[o].nil? }.each do |key|
+            data['member'][key] = options[key]
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => [201],
+            :method  => 'POST',
+            :path    => 'lb/members'
+          )
+        end
+      end
+
+      class Mock
+        def create_lb_member(pool_id, address, protocol_port, weight, options = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'              => Fog::Mock.random_numbers(6).to_s,
+            'pool_id'         => pool_id,
+            'address'         => address,
+            'protocol_port'   => protocol_port,
+            'weight'          => weight,
+            'status'          => 'ACTIVE',
+            'admin_state_up'  => options[:admin_state_up],
+            'tenant_id'       => options[:tenant_id],
+          }
+
+          self.data[:lb_members][data['id']] = data
+          response.body = { 'member' => data }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def create_lb_pool(subnet_id, protocol, lb_method, options = {})
+          data = {
+            'pool' => {
+              'subnet_id' => subnet_id,
+              'protocol'  => protocol,
+              'lb_method' => lb_method
+            }
+          }
+
+          vanilla_options = [:name, :description, :admin_state_up, :tenant_id]
+          vanilla_options.reject{ |o| options[o].nil? }.each do |key|
+            data['pool'][key] = options[key]
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => [201],
+            :method  => 'POST',
+            :path    => 'lb/pools'
+          )
+        end
+      end
+
+      class Mock
+        def create_lb_pool(subnet_id, protocol, lb_method, options = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'                 => Fog::Mock.random_numbers(6).to_s,
+            'subnet_id'          => subnet_id,
+            'protocol'           => protocol,
+            'lb_method'          => lb_method,
+            'name'               => options[:name],
+            'description'        => options[:description],
+            'health_monitors'    => [],
+            'members'            => [],
+            'status'             => 'ACTIVE',
+            'admin_state_up'     => options[:admin_state_up],
+            'vip_id'             => nil,
+            'tenant_id'          => options[:tenant_id],
+            'active_connections' => nil,
+            'bytes_in'           => nil,
+            'bytes_out'          => nil,
+            'total_connections'  => nil
+          }
+
+          self.data[:lb_pools][data['id']] = data
+          response.body = { 'pool' => data }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def create_lb_vip(subnet_id, pool_id, protocol, protocol_port, options = {})
+          data = {
+            'vip' => {
+              'subnet_id'     => subnet_id,
+              'pool_id'       => pool_id,
+              'protocol'      => protocol,
+              'protocol_port' => protocol_port
+            }
+          }
+
+          vanilla_options = [:name, :description, :address, :session_persistence, :connection_limit,
+                             :admin_state_up, :tenant_id]
+          vanilla_options.reject{ |o| options[o].nil? }.each do |key|
+            data['vip'][key] = options[key]
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => [201],
+            :method  => 'POST',
+            :path    => 'lb/vips'
+          )
+        end
+      end
+
+      class Mock
+        def create_lb_vip(subnet_id,  pool_id, protocol, protocol_port, options = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'                  => Fog::Mock.random_numbers(6).to_s,
+            'subnet_id'           => subnet_id,
+            'pool_id'             => pool_id,
+            'protocol'            => protocol,
+            'protocol_port'       => protocol_port,
+            'name'                => options[:name],
+            'description'         => options[:description],
+            'address'             => options[:address],
+            'port_id'             => Fog::Mock.random_numbers(6).to_s,
+            'session_persistence' => options[:session_persistence],
+            'connection_limit'    => options[:connection_limit],
+            'status'              => 'ACTIVE',
+            'admin_state_up'      => options[:admin_state_up],
+            'tenant_id'           => options[:tenant_id],
+          }
+
+          self.data[:lb_vips][data['id']] = data
+          response.body = { 'vip' => data }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def create_network(options = {})
+          data = { 'network' => {} }
+
+          vanilla_options = [
+            :name,
+            :shared,
+            :admin_state_up,
+            :tenant_id
+          ]
+
+          vanilla_options.reject{ |o| options[o].nil? }.each do |key|
+            data['network'][key] = options[key]
+          end
+
+          # Advanced Features through API Extensions
+          #
+          # Not strictly required but commonly found in OpenStack
+          # installs with Quantum networking.
+          #
+          # @see http://docs.openstack.org/trunk/openstack-network/admin/content/provider_attributes.html
+          provider_options = [
+            :router_external,
+            :provider_network_type,
+            :provider_segmentation_id,
+            :provider_physical_network
+          ]
+
+          # Map Fog::Network::OpenStack::Network
+          # model attributes to OpenStack provider attributes
+          aliases = {
+            :provider_network_type     => 'provider:network_type',
+            # Not applicable to the "local" or "gre" network types
+            :provider_physical_network => 'provider:physical_network',
+            :provider_segmentation_id  => 'provider:segmentation_id',
+            :router_external           => 'router:external'
+          }
+
+          provider_options.reject{ |o| options[o].nil? }.each do |key|
+            aliased_key = aliases[key] || key
+            data['network'][aliased_key] = options[key]
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => [201],
+            :method   => 'POST',
+            :path     => 'networks'
+          )
+        end
+      end
+
+      class Mock
+        def create_network(options = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'             => Fog::Mock.random_numbers(6).to_s,
+            'name'           => options[:name],
+            'shared'         => options[:shared],
+            'subnets'        => [],
+            'status'         => 'ACTIVE',
+            'admin_state_up' => options[:admin_state_up],
+            'tenant_id'      => options[:tenant_id],
+          }
+
+          # Add provider specific attributes when found
+          #
+          provider_options = [
+            :router_external,
+            :provider_network_type,
+            :provider_segmentation_id,
+            :provider_physical_network
+          ]
+          aliases = {
+            :provider_network_type     => 'provider:network_type',
+            # Not applicable to the "local" or "gre" network types
+            :provider_physical_network => 'provider:physical_network',
+            :provider_segmentation_id  => 'provider:segmentation_id',
+            :router_external           => 'router:external'
+          }
+          provider_options.reject{ |o| options[o].nil? }.each do |key|
+            aliased_key = aliases[key] || key
+            data[aliased_key] = options[key]
+          end
+
+          self.data[:networks][data['id']] = data
+          response.body = { 'network' => data }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def create_port(network_id, options = {})
+          data = {
+            'port' => {
+              'network_id' => network_id,
+            }
+          }
+
+          vanilla_options = [:name, :fixed_ips, :mac_address, :admin_state_up,
+                             :device_owner, :device_id, :tenant_id, :security_groups,
+                             :allowed_address_pairs]
+          vanilla_options.reject{ |o| options[o].nil? }.each do |key|
+            data['port'][key] = options[key]
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => [201],
+            :method   => 'POST',
+            :path     => 'ports'
+          )
+        end
+      end
+
+      class Mock
+        def create_port(network_id, options = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'                    => Fog::Mock.random_numbers(6).to_s,
+            'name'                  => options[:name],
+            'network_id'            => network_id,
+            'fixed_ips'             => options[:fixed_ips],
+            'mac_address'           => options[:mac_address],
+            'status'                => 'ACTIVE',
+            'admin_state_up'        => options[:admin_state_up],
+            'device_owner'          => options[:device_owner],
+            'device_id'             => options[:device_id],
+            'tenant_id'             => options[:tenant_id],
+            'security_groups'       => options[:security_groups],
+            'allowed_address_pairs' => options[:allowed_address_pairs],
+          }
+          self.data[:ports][data['id']] = data
+          response.body = { 'port' => data }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def create_router(name, options = {})
+          data = {
+            'router' => {
+              'name' => name,
+            }
+          }
+
+          vanilla_options = [
+            :admin_state_up,
+            :tenant_id,
+            :network_id,
+            :status,
+            :subnet_id
+          ]
+          vanilla_options.reject{ |o| options[o].nil? }.each do |key|
+            data['router'][key] = options[key]
+          end
+
+          # remove this in a future
+          egi = options[:external_gateway_info]
+          if egi
+            if egi.is_a?(Fog::Network::OpenStack::Network)
+              Fog::Logger.deprecation "Passing a model objects into options[:external_gateway_info] is deprecated. \
+              Please pass  external external gateway as follows options[:external_gateway_info] = { :network_id => NETWORK_ID }]"
+              data['router'][:external_gateway_info] = { :network_id => egi.id }
+            elsif egi.is_a?(Hash) && egi[:network_id]
+              data['router'][:external_gateway_info] = egi
+            else
+              raise ArgumentError.new('Invalid external_gateway_info attribute')
+            end
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => [201],
+            :method   => 'POST',
+            :path     => 'routers'
+          )
+        end
+      end
+
+      class Mock
+        def create_router(name, options = {})
+          response = Excon::Response.new
+          response.status = 201
+
+          # remove this in a future
+          egi = options[:external_gateway_info]
+          if egi && egi.is_a?(Fog::Network::OpenStack::Network)
+            Fog::Logger.deprecation "Passing a model objects into options[:external_gateway_info] is deprecated. \
+            Please pass  external external gateway as follows options[:external_gateway_info] = { :network_id => NETWORK_ID }]"
+            egi = { :network_id => egi.id }
+          end
+
+          data = {
+            'router' => {
+              :id     => Fog::Mock.random_numbers(6).to_s,
+              :status => options[:status] || 'ACTIVE',
+              :external_gateway_info => egi,
+              :name => name,
+              :admin_state_up => options[:admin_state_up],
+              :tenant_id => '6b96ff0cb17a4b859e1e575d221683d3'
+            }
+          }
+          self.data[:routers][data['router'][:id]] = data['router']
+          response.body = data
+          response
+        end
+      end
+    end
+  end
+end