fog-huaweicloud 0.0.1 → 0.0.2

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

@@ -0,0 +1,76 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      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.kind_of?(Fog::Network::HuaweiCloud::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.kind_of?(Hash) && egi[:network_id]
+              data['router'][:external_gateway_info] = egi
+            else
+              raise ArgumentError, '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.kind_of?(Fog::Network::HuaweiCloud::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

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

@@ -0,0 +1,92 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      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" => {}}
+          desired_options   = [:name, :description, :tenant_id]
+          selected_options  = desired_options.select { |o| options[o] }
+          selected_options.each { |key| data["security_group"][key] = options[key] }
+
+          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::UUID.uuid
+
+          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::UUID.uuid,
+               "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::UUID.uuid,
+               "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/network/huaweicloud/requests/create_security_group_rule.rb

@@ -0,0 +1,79 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      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}}
+          desired_options = [
+            :port_range_min,
+            :port_range_max,
+            :protocol,
+            :ethertype,
+            :remote_group_id,
+            :remote_ip_prefix,
+            :tenant_id
+          ]
+          selected_options = desired_options.select { |o| options[o] }
+          selected_options.each { |key| data["security_group_rule"][key] = options[key] }
+
+          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::UUID.uuid,
+            "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/network/huaweicloud/requests/create_subnet.rb

@@ -0,0 +1,54 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      class Real
+        def create_subnet(network_id, cidr, ip_version, options = {})
+          data = {
+            'subnet' => {
+              'network_id' => network_id,
+              'cidr'       => cidr,
+              'ip_version' => ip_version
+            }
+          }
+
+          vanilla_options = [:name, :gateway_ip, :allocation_pools,
+                             :dns_nameservers, :host_routes, :enable_dhcp,
+                             :tenant_id, :vpc_id]
+          vanilla_options.select { |o| options.key?(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 = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'               => Fog::Mock.random_numbers(6).to_s,
+            'name'             => options[:name],
+            'network_id'       => network_id,
+            'cidr'             => cidr,
+            'ip_version'       => ip_version,
+            'gateway_ip'       => options[:gateway_ip],
+            'allocation_pools' => options[:allocation_pools],
+            'dns_nameservers'  => options[:dns_nameservers],
+            'host_routes'      => options[:host_routes],
+            'enable_dhcp'      => options[:enable_dhcp],
+            'tenant_id'        => options[:tenant_id]
+          }
+          self.data[:subnets][data['id']] = data
+          response.body = {'subnet' => data}
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      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/huaweicloud/requests/create_vpc.rb

@@ -0,0 +1,40 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      class Real
+        def create_vpc(name, cidr)
+          if @huaweicloud_version == "v1"
+            data = {
+                'vpc' => {
+                    'name' => name,
+                    'cidr' => cidr
+                }
+            }
+
+            # vanilla_options = [:name, :gateway_ip, :allocation_pools,
+            #                    :dns_nameservers, :host_routes, :enable_dhcp,
+            #                    :tenant_id, :vpc_id]
+            # vanilla_options.select { |o| options.key?(o) }.each do |key|
+            #   data['vpc'][key] = options[key]
+            # end
+
+            request(
+                :body    => Fog::JSON.encode(data),
+                :expects => [200],
+                :method  => 'POST',
+                :path    => 'vpcs'
+            )
+          else
+            raise Fog::HuaweiCloud::Errors::InterfaceNotImplemented.new('Method :create_subnet is not implemented')
+          end
+        end
+      end
+
+      class Mock
+        def create_vpc(name, cidr)
+          raise Fog::HuaweiCloud::Errors::InterfaceNotImplemented.new('Method :create_vpc is not implemented')
+        end
+      end
+    end
+  end
+end

data/lib/fog/network/huaweicloud/requests/create_vpn_service.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      class Real
+        def create_vpn_service(subnet_id, router_id, options = {})
+          data = {
+            'vpnservice' => {
+              'subnet_id' => subnet_id,
+              'router_id' => router_id
+            }
+          }
+
+          vanilla_options = [:name, :description, :admin_state_up, :tenant_id]
+          vanilla_options.reject { |o| options[o].nil? }.each do |key|
+            data['vpnservice'][key] = options[key]
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => [201],
+            :method  => 'POST',
+            :path    => 'vpn/vpnservices'
+          )
+        end
+      end
+
+      class Mock
+        def create_vpn_service(subnet_id, router_id, options = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'             => Fog::Mock.random_numbers(6).to_s,
+            'subnet_id'      => subnet_id,
+            'router_id'      => router_id,
+            'name'           => options[:name],
+            'description'    => options[:description],
+            'status'         => 'ACTIVE',
+            'admin_state_up' => options[:admin_state_up],
+            'tenant_id'      => options[:tenant_id],
+            'external_v4_ip' => '1.2.3.4',
+            'external_v6_ip' => '::1'
+          }
+
+          self.data[:vpn_services][data['id']] = data
+          response.body = {'vpnservice' => data}
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      class Real
+        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'].map { |r| r['id'] }.include? floating_ip_id
+            data[:floating_ips].delete(floating_ip_id)
+            response.status = 204
+            response
+          else
+            raise Fog::Network::HuaweiCloud::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/network/huaweicloud/requests/delete_ike_policy.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      class Real
+        def delete_ike_policy(ike_policy_id)
+          request(
+            :expects => 204,
+            :method  => 'DELETE',
+            :path    => "vpn/ikepolicies/#{ike_policy_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_ike_policy(ike_policy_id)
+          response = Excon::Response.new
+          if list_ike_policies.body['ikepolicies'].collect { |r| r['id'] }.include? ike_policy_id
+            data[:ike_policies].delete(ike_policy_id)
+            response.status = 204
+            response
+          else
+            raise Fog::Network::HuaweiCloud::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/network/huaweicloud/requests/delete_ipsec_policy.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      class Real
+        def delete_ipsec_policy(ipsec_policy_id)
+          request(
+            :expects => 204,
+            :method  => 'DELETE',
+            :path    => "vpn/ipsecpolicies/#{ipsec_policy_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_ipsec_policy(ipsec_policy_id)
+          response = Excon::Response.new
+          if list_ipsec_policies.body['ipsecpolicies'].collect { |r| r['id'] }.include? ipsec_policy_id
+            data[:ipsec_policies].delete(ipsec_policy_id)
+            response.status = 204
+            response
+          else
+            raise Fog::Network::HuaweiCloud::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/network/huaweicloud/requests/delete_ipsec_site_connection.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Network
+    class HuaweiCloud
+      class Real
+        def delete_ipsec_site_connection(ipsec_site_connection_id)
+          request(
+            :expects => 204,
+            :method  => 'DELETE',
+            :path    => "vpn/ipsec-site-connections/#{ipsec_site_connection_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_ipsec_site_connection(ipsec_site_connection_id)
+          response = Excon::Response.new
+          ip_site_connections = list_ipsec_site_connections.body['ipsec_site_connections']
+          if ip_site_connections.collect { |r| r['id'] }.include? ipsec_site_connection_id
+            data[:ipsec_site_connections].delete(ipsec_site_connection_id)
+            response.status = 204
+            response
+          else
+            raise Fog::Network::HuaweiCloud::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/network/huaweicloud/requests/delete_lb_health_monitor.rb

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

data/lib/fog/network/huaweicloud/requests/delete_lb_member.rb

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

data/lib/fog/network/huaweicloud/requests/delete_lb_pool.rb

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