fog 1.17.0 → 1.18.0

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

@@ -0,0 +1,92 @@
+module Fog
+  module HP
+    class Network
+
+      class Real
+        # Create a new port
+        #
+        # ==== Parameters
+        # * 'network_id'<~String>: - UUId of the network
+        # * options<~Hash>:
+        #   * 'name'<~String>: - Name of the port
+        #   * 'tenant_id'<~String>: - TenantId that owns the port
+        #   * 'admin_state_up'<~Boolean> - The administrative state of the port, true or false
+        #   * 'mac_address'<~String>: - MAC address of the port
+        #   * 'fixed_ips'<~Array>:
+        #     * 'subnet_id'<~String>: - UUId of the subnet
+        #     * 'ip_address'<~String>: - IP address
+        #   * 'device_id'<~String>: - Id of the device
+        #   * 'device_owner'<~String>: - Device owner of the port i.e. "network:dhcp"
+        #   * 'security_groups'<~Array>: - Security Groups
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * port<~Array>:
+        #       * 'id'<~String>: - UUId for the port
+        #       * 'name'<~String>: - Name of the port
+        #       * 'network_id'<~String>: - UUId of the network
+        #       * 'tenant_id'<~String>: - TenantId that owns the port
+        #       * 'status'<~String>: - Status of the port i.e. ACTIVE
+        #       * 'admin_state_up'<~Boolean>: - The administrative state of the port, true or false
+        #       * 'binding:vif_type'<~String>: - "other"
+        #       * 'device_owner'<~String>: - Device owner of the port i.e. "network:dhcp"
+        #       * 'mac_address'<~String>: - MAC address of the port
+        #       * 'fixed_ips'<~Array>:
+        #         * 'subnet_id'<~String>: - UUId of the subnet
+        #         * 'ip_address'<~String>: - IP address
+        #       * 'security_groups'<~Array>: - Security Groups
+        #       * 'device_id'<~String>: - Id of the device
+        def create_port(network_id, options = {})
+          data = {
+            'port' => {
+              'network_id' => network_id
+            }
+          }
+
+          l_options = [:name, :mac_address, :fixed_ips, :security_groups,
+                       :device_id, :device_owner, :admin_state_up, :tenant_id]
+          l_options.select{|o| options[o]}.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
+          if list_networks.body['networks'].detect {|_| _['id'] == network_id}
+            response.status = 201
+            data = {
+              'id'             => Fog::HP::Mock.uuid.to_s,
+              'name'           => options[:name] || "",
+              'network_id'     => network_id,
+              'fixed_ips'      => options[:fixed_ips] || [{'subnet_id' => "#{Fog::HP::Mock.uuid.to_s}", 'ip_address' => "#{Fog::HP::Mock.ip_address.to_s}"}],
+              'mac_address'    => options[:mac_address] || Fog::HP::Mock.mac_address.to_s,
+              'status'         => 'ACTIVE',
+              'admin_state_up' => options[:admin_state_up] || true,
+              'binding:vif_type'  => 'other',
+              'device_owner'   => options[:device_owner] || "",
+              'device_id'      => options[:device_id] || "",
+              'security_groups'  => ["#{Fog::HP::Mock.uuid.to_s}"],
+              'tenant_id'      => options[:tenant_id] || Fog::Mock.random_numbers(14).to_s
+            }
+            self.data[:ports][data['id']] = data
+            response.body = { 'port' => data }
+            response
+          else
+            raise Fog::HP::Network::NotFound
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Fog
+  module HP
+    class Network
+
+      class Real
+        # Create a new router
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'name'<~String> - Name of the router
+        #   * 'admin_state_up'<~Boolean> - The administrative state of the router, true or false
+        #   * 'tenant_id'<~String> - TenantId different than the current user, that should own the network. Only allowed if user has 'admin' role.
+        #   * 'external_gateway_info'<~Hash>: - External gateway info.
+        #     * 'network_id'<~String>: - UUId of the external network
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * router<~Array>:
+        #       * 'id'<~String>: - UUId for the router
+        #       * 'name'<~String>: - Name of the router
+        #       * 'tenant_id'<~String>: - TenantId that owns the router
+        #       * 'status'<~String>: - Status of the router i.e. ACTIVE
+        #       * 'admin_state_up'<~Boolean>: - true or false
+        #       * 'external_gateway_info'<~Hash>: - External gateway info.
+        #         * 'network_id'<~String>: - UUId of the external network
+        def create_router(options = {})
+          data = { 'router' => {} }
+
+          l_options = [:name, :admin_state_up, :tenant_id, :external_gateway_info]
+          l_options.select{|o| options[o]}.each do |key|
+            data['router'][key] = options[key]
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => 201,
+            :method   => 'POST',
+            :path     => 'routers'
+          )
+        end
+      end
+
+      class Mock
+        def create_router(options = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'                    => Fog::HP::Mock.uuid.to_s,
+            'name'                  => options[:name] || "",
+            'status'                => 'ACTIVE',
+            'external_gateway_info' => options[:external_gateway_info] || nil,
+            'admin_state_up'        => options[:admin_state_up] || true,
+            'tenant_id'             => options[:tenant_id] || Fog::Mock.random_numbers(14).to_s
+          }
+          self.data[:routers][data['id']] = data
+          response.body = { 'router' => data }
+          response
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/hp/requests/network/create_security_group.rb

@@ -0,0 +1,100 @@
+module Fog
+  module HP
+    class Network
+      class Real
+
+        # Create a new security group
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'name'<~String> - Name of the security group
+        #   * 'description'<~String> - Description of the security group
+        #   * 'tenant_id'<~String> - TenantId different than the current user, that should own the security group. Only allowed if user has 'admin' role.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #   * 'security_groups'<~Array>:
+        #     * 'id'<~String> - UUId of the security group
+        #     * 'name'<~String> - Name of the security group
+        #     * 'description'<~String> - Description of the security group
+        #     * 'tenant_id'<~String> - Tenant id that owns the security group
+        #     * 'security_group_rules'<~Array>: - Array of security group rules
+        #       * 'id'<~String> - UUId of the security group rule
+        #       * 'direction'<~String> - Direction of traffic, must be in ['ingress', 'egress']
+        #       * 'port_range_min'<~Integer> - Start port for rule i.e. 22 (or -1 for ICMP wildcard)
+        #       * 'port_range_max'<~Integer> - End port for rule i.e. 22 (or -1 for ICMP wildcard)
+        #       * 'protocol'<~String> - IP protocol for rule, must be in ['tcp', 'udp', 'icmp']
+        #       * 'ethertype'<~String> - Type of ethernet support, must be in ['IPv4', 'IPv6']
+        #       * 'security_group_id'<~String> - UUId of the parent security group
+        #       * 'remote_group_id'<~String> - UUId of the remote security group
+        #       * 'remote_ip_prefix'<~String> - IP cidr range address i.e. '0.0.0.0/0'
+        #       * 'tenant_id'<~String> - Tenant id that owns the security group rule
+        def create_security_group(options = {})
+          data = { 'security_group' => {} }
+
+          l_options = [:name, :description, :tenant_id]
+          l_options.select{|o| options[o]}.each do |key|
+            data['security_group'][key] = options[key]
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => 201,
+            :method   => 'POST',
+            :path     => 'security-groups'
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_security_group(options = {})
+          # Spaces are NOT removed from name and description, as in case of compute sec groups
+          tenant_id = Fog::Mock.random_numbers(14).to_s
+          sec_group_id = Fog::HP::Mock.uuid.to_s
+
+          response = Excon::Response.new
+          response.status = 201
+          # by default every security group will come setup with an egress rule to "allow all out"
+          data = {
+            'security_group_rules'  => [
+                { "remote_group_id" => nil,
+                  "direction" => "egress",
+                  "remote_ip_prefix" => nil,
+                  "protocol" => nil,
+                  "ethertype" => "IPv4",
+                  "tenant_id" => tenant_id,
+                  "port_range_max" => nil,
+                  "port_range_min" => nil,
+                  "id" => Fog::HP::Mock.uuid.to_s,
+                  "security_group_id" => sec_group_id
+                },
+                { "remote_group_id" => nil,
+                  "direction" => "egress",
+                  "remote_ip_prefix" => nil,
+                  "protocol" => nil,
+                  "ethertype" => "IPv6",
+                  "tenant_id" => tenant_id,
+                  "port_range_max" => nil,
+                  "port_range_min" => nil,
+                  "id" => Fog::HP::Mock.uuid.to_s,
+                  "security_group_id" => sec_group_id
+                }
+            ],
+            'id'           => sec_group_id,
+            'tenant_id'    => tenant_id,
+            'name'         => options[:name] || "",
+            'description'  => options[:description] || ""
+          }
+          self.data[:security_groups][data['id']] = data
+          response.body = { 'security_group' => data }
+          response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/requests/network/create_security_group_rule.rb

@@ -0,0 +1,83 @@
+module Fog
+  module HP
+    class Network
+      class Real
+
+        # Create a new security group rule
+        #
+        # ==== Parameters
+        # * 'security_group_id'<~String> - UUId of the parent security group
+        # * 'direction'<~String> - Direction of traffic, must be in ['ingress', 'egress']
+        # * options<~Hash>:
+        #   * 'port_range_min'<~Integer> - Start port for rule i.e. 22 (or -1 for ICMP wildcard)
+        #   * 'port_range_max'<~Integer> - End port for rule i.e. 22 (or -1 for ICMP wildcard)
+        #   * 'protocol'<~String> - IP protocol for rule, must be in ['tcp', 'udp', 'icmp']
+        #   * 'ethertype'<~String> - Type of ethernet support, must be in ['IPv4', 'IPv6']
+        #   * 'remote_group_id'<~String> - UUId of the remote security group
+        #   * 'remote_ip_prefix'<~String> - IP cidr range address i.e. '0.0.0.0/0'
+        #   * 'tenant_id'<~String> - TenantId different than the current user, that should own the security group. Only allowed if user has 'admin' role.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #   * 'security_group_rule'<~Hash>:
+        #     * 'id'<~String> - UUId of the security group rule
+        #     * 'direction'<~String> - Direction of traffic, must be in ['ingress', 'egress']
+        #     * 'port_range_min'<~String> - Start port for rule i.e. 22 (or -1 for ICMP wildcard)
+        #     * 'port_range_max'<~String> - End port for rule i.e. 22 (or -1 for ICMP wildcard)
+        #     * 'protocol'<~String> - IP protocol for rule, must be in ['tcp', 'udp', 'icmp']
+        #     * 'ethertype'<~String> - Type of ethernet support, must be in ['IPv4', 'IPv6']
+        #     * 'security_group_id'<~String> - UUId of the parent security group
+        #     * 'remote_group_id'<~String> - UUId of the source security group
+        #     * 'remote_ip_prefix'<~String> - IP cidr range address i.e. '0.0.0.0/0'
+        #     * 'tenant_id'<~String> - Tenant id that owns the security group rule
+        def create_security_group_rule(security_group_id, direction, options = {})
+          data = { 'security_group_rule' => {
+              'security_group_id' => security_group_id,
+              'direction'         => direction
+            }
+          }
+
+          l_options = [:port_range_min, :port_range_max, :protocol, :ethertype,
+                       :remote_group_id, :remote_ip_prefix, :tenant_id]
+          l_options.select{|o| options[o]}.each do |key|
+            data['security_group_rule'][key] = options[key]
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => 201,
+            :method   => 'POST',
+            :path     => 'security-group-rules'
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_security_group_rule(security_group_id, direction, options = {})
+          response = Excon::Response.new
+          data = {
+            "id" => Fog::HP::Mock.uuid.to_s,
+            "remote_group_id"   => options[:remote_group_id],
+            "direction"         => direction,
+            "remote_ip_prefix"  => options[:remote_ip_prefix],
+            "protocol"          => options[:protocol],
+            "ethertype"         => options[:ethertype] || "IPv4",
+            "tenant_id"         => options[:tenant_id] || Fog::Mock.random_numbers(14).to_s,
+            "port_range_max"    => options[:port_range_max],
+            "port_range_min"    => options[:port_range_min],
+            "security_group_id" => security_group_id
+          }
+          self.data[:security_group_rules][data['id']] = data
+          response.status = 201
+          response.body = { 'security_group_rule' => data }
+          response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/requests/network/create_subnet.rb

@@ -0,0 +1,97 @@
+module Fog
+  module HP
+    class Network
+
+      class Real
+        # Create a new subnet
+        #
+        # ==== Parameters
+        # * 'network_id'<~String>: - UUId of the network
+        # * 'cidr'<~String>: - Cidr
+        # * 'ip_version'<~Integer>: - IP version, values 4 or 6
+        # * options<~Hash>:
+        #   * 'name'<~String>: - Name of the subnet
+        #   * 'tenant_id'<~String>: - TenantId that owns the subnet
+        #   * 'dns_nameservers'<~Array>: - Array of DNS Nameservers
+        #   * 'allocation_pools'<~Array>:
+        #     * 'start'<~String>: - Start IP address
+        #     * 'end'<~String>: - End IP address
+        #   * 'host_routes'<~Array>: - Array of host routes
+        #   * 'gateway_ip'<~String>: - Gateway IP address
+        #   * 'enable_dhcp'<~Boolean>: - true or false, defaults to true
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * subnet<~Array>:
+        #       * 'id'<~String>: - UUId for the subnet
+        #       * 'name'<~String>: - Name of the subnet
+        #       * 'network_id'<~String>: - UUId of the network
+        #       * 'tenant_id'<~String>: - TenantId that owns the subnet
+        #       * 'dns_nameservers'<~Array>: - Array of DNS Nameservers
+        #       * 'allocation_pools'<~Array>:
+        #         * 'start'<~String>: - Start IP address
+        #         * 'end'<~String>: - End IP address
+        #       * 'host_routes'<~Array>: - Array of host routes
+        #       * 'gateway_ip'<~String>: - Gateway IP address
+        #       * 'ip_version'<~Integer>: - IP version, values 4 or 6
+        #       * 'cidr'<~String>: - Cidr
+        #       * 'enable_dhcp'<~Boolean>: - true or false, defaults to true
+        def create_subnet(network_id, cidr, ip_version, options = {})
+          data = {
+            'subnet' => {
+              'network_id' => network_id,
+              'cidr'       => cidr,
+              'ip_version' => ip_version
+            }
+          }
+
+          l_options = [:name, :gateway_ip, :allocation_pools,
+                       :dns_nameservers, :host_routes, :enable_dhcp,
+                       :tenant_id]
+          l_options.select{|o| options[o]}.each do |key|
+            data['subnet'][key] = options[key]
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => 201,
+            :method   => 'POST',
+            :path     => 'subnets'
+          )
+        end
+      end
+
+      class Mock
+        def create_subnet(network_id, cidr, ip_version, options = {})
+          if list_networks.body['networks'].detect {|_| _['id'] == network_id}
+            response = Excon::Response.new
+            response.status = 201
+            data = {
+              'id'               => Fog::HP::Mock.uuid.to_s,
+              'name'             => options[:name] || "",
+              'network_id'       => network_id,
+              'cidr'             => cidr,
+              'ip_version'       => ip_version,
+              'gateway_ip'       => options[:gateway_ip] || Fog::HP::Mock.ip_address.to_s,
+              'allocation_pools' => options[:allocation_pools] || [{"start" => "#{Fog::HP::Mock.ip_address.to_s}", "end" => "#{Fog::HP::Mock.ip_address.to_s}"}],
+              'dns_nameservers'  => options[:dns_nameservers] || [],
+              'host_routes'      => options[:host_routes] || [],
+              'enable_dhcp'      => options[:enable_dhcp] || true,
+              'tenant_id'        => options[:tenant_id] || Fog::Mock.random_numbers(14).to_s
+            }
+            self.data[:subnets][data['id']] = data
+            # add this subnet to the network
+            self.data[:networks][network_id]['subnets'] << data['id']
+
+            response.body = { 'subnet' => data }
+            response
+          else
+            raise Fog::HP::Network::NotFound
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/hp/requests/network/delete_floating_ip.rb

@@ -0,0 +1,34 @@
+module Fog
+  module HP
+    class Network
+
+      class Real
+        # Delete an existing floating ip
+        #
+        # ==== Parameters
+        #   * 'floating_ip_id'<~String>: - UUId of the floating IP address to delete
+        def delete_floating_ip(floating_ip_id)
+          request(
+            :expects  => 204,
+            :method   => 'DELETE',
+            :path     => "floatingips/#{floating_ip_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_floating_ip(floating_ip_id)
+          response = Excon::Response.new
+          if list_floating_ips.body['floatingips'].detect {|_| _['id'] == floating_ip_id}
+            self.data[:floating_ips].delete(floating_ip_id)
+            response.status = 204
+            response
+          else
+            raise Fog::HP::Network::NotFound
+          end
+        end
+      end
+
+    end
+  end
+end