fog-huaweicloud 0.0.1 → 0.0.2

data/lib/fog/baremetal/huaweicloud/requests/list_ports.rb

@@ -0,0 +1,42 @@
+module Fog
+  module Baremetal
+    class HuaweiCloud
+      class Real
+        def list_ports(options = {})
+          request(
+            :expects => [200, 204],
+            :method  => 'GET',
+            :path    => 'ports',
+            :query   => options
+          )
+        end
+      end
+
+      class Mock
+        def list_ports(_options = {})
+          response = Excon::Response.new
+          response.status = [200, 204][rand(2)]
+          response.body = {
+            "ports" => [
+              {
+                "address" => "fe:54:00:77:07:d9",
+                "links"   => [
+                  {
+                    "href" => "http://localhost:6385/v1/ports/27e3153e-d5bf-4b7e-b517-fb518e17f34c",
+                    "rel"  => "self"
+                  },
+                  {
+                    "href" => "http://localhost:6385/ports/27e3153e-d5bf-4b7e-b517-fb518e17f34c",
+                    "rel"  => "bookmark"
+                  }
+                ],
+                "uuid"    => Fog::UUID.uuid
+              }
+            ]
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/baremetal/huaweicloud/requests/list_ports_detailed.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Baremetal
+    class HuaweiCloud
+      class Real
+        def list_ports_detailed(options = {})
+          request(
+            :expects => [200, 204],
+            :method  => 'GET',
+            :path    => 'ports/detail',
+            :query   => options
+          )
+        end
+      end
+
+      class Mock
+        def list_ports_detailed(_options = {})
+          response = Excon::Response.new
+          response.status = [200, 204][rand(2)]
+          response.body = {"ports" => data[:ports]}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/baremetal/huaweicloud/requests/patch_chassis.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Baremetal
+    class HuaweiCloud
+      class Real
+        # Patch a chassis
+        #
+        # parameter example:
+        # [{:op=> 'replace', :path => "/extra/placement", :value => "somewhere"}]
+        #
+        # === Patch parameter, list of jsonpatch ===
+        # op    =  Operations: 'add', 'replace' or 'remove'
+        # path  =  Attributes to add/replace or remove (only PATH is necessary on remove),
+        #          e.g. /extra/placement
+        # value = Value to set
+        def patch_chassis(chassis_uuid, patch)
+          request(
+            :body    => Fog::JSON.encode(patch),
+            :expects => 200,
+            :method  => 'PATCH',
+            :path    => "chassis/#{chassis_uuid}"
+          )
+        end
+      end
+
+      class Mock
+        def patch_chassis(_chassis_uuid, _patch)
+          response = Excon::Response.new
+          response.status = 200
+          response.headers = {
+            "X-Compute-Request-Id" => "req-fdc6f99e-55a2-4ab1-8904-0892753828cf",
+            "Content-Type"         => "application/json",
+            "Content-Length"       => "356",
+            "Date"                 => Date.new
+          }
+          response.body = data[:chassis_collection].first
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/baremetal/huaweicloud/requests/patch_node.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Baremetal
+    class HuaweiCloud
+      class Real
+        # Patch a node
+        #
+        # parameter example:
+        # [{:op=> 'replace', :path => "/driver", :value => "pxe_ssh"}]
+        #
+        # === Patch parameter, list of jsonpatch ===
+        # op    =  Operations: 'add', 'replace' or 'remove'
+        # path  =  Attributes to add/replace or remove (only PATH is necessary on remove),
+        #          e.g. /driver_info/ipmi_address
+        # value = Value to set
+        def patch_node(node_uuid, patch)
+          request(
+            :body    => Fog::JSON.encode(patch),
+            :expects => 200,
+            :method  => 'PATCH',
+            :path    => "nodes/#{node_uuid}"
+          )
+        end
+      end
+
+      class Mock
+        def patch_node(_node_uuid, _patch)
+          response = Excon::Response.new
+          response.status = 200
+          response.headers = {
+            "X-Compute-Request-Id" => "req-fdc6f99e-55a2-4ab1-8904-0892753828cf",
+            "Content-Type"         => "application/json",
+            "Content-Length"       => "356",
+            "Date"                 => Date.new
+          }
+          response.body = data[:nodes].first
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/baremetal/huaweicloud/requests/patch_port.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Baremetal
+    class HuaweiCloud
+      class Real
+        # Patch a port
+        #
+        # parameter example:
+        # [{:op=> 'replace', :path => "/driver_info/ipmi_address", :value => "192.0.2.1"}]
+        #
+        # === Patch parameter, list of jsonpatch ===
+        # op    =  Operations: 'add', 'replace' or 'remove'
+        # path  =  Attributes to add/replace or remove (only PATH is necessary on remove),
+        #          e.g. /driver_info/ipmi_address
+        # value = Value to set
+        def patch_port(port_uuid, patch)
+          request(
+            :body    => Fog::JSON.encode(patch),
+            :expects => 200,
+            :method  => 'PATCH',
+            :path    => "ports/#{port_uuid}"
+          )
+        end
+      end
+
+      class Mock
+        def patch_port(_port_uuid, _patch)
+          response = Excon::Response.new
+          response.status = 200
+          response.headers = {
+            "X-Compute-Request-Id" => "req-fdc6f99e-55a2-4ab1-8904-0892753828cf",
+            "Content-Type"         => "application/json",
+            "Content-Length"       => "356",
+            "Date"                 => Date.new
+          }
+          response.body = data[:ports].first
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/baremetal/huaweicloud/requests/set_node_maintenance.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Baremetal
+    class HuaweiCloud
+      class Real
+        def set_node_maintenance(node_uuid, parameters = nil)
+          request(
+            :expects => [200, 202, 204],
+            :method  => 'PUT',
+            :path    => "nodes/#{node_uuid}/maintenance",
+            :query   => parameters
+          )
+        end
+      end
+
+      class Mock
+        def set_node_maintenance(_node_uuid, _parameters = nil)
+          response = Excon::Response.new
+          response.status = 202
+          response.headers = {
+            "X-Compute-Request-Id" => "req-fdc6f99e-55a2-4ab1-8904-0892753828cf",
+            "Content-Type"         => "application/json",
+            "Content-Length"       => "356",
+            "Date"                 => Date.new
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/baremetal/huaweicloud/requests/set_node_power_state.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Baremetal
+    class HuaweiCloud
+      class Real
+        def set_node_power_state(node_id, power_state)
+          data = {
+            'target' => power_state
+          }
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 202,
+            :method  => 'PUT',
+            :path    => "nodes/#{node_id}/states/power"
+          )
+        end
+      end
+
+      class Mock
+        def set_node_power_state(_node_id, _power_state)
+          response = Excon::Response.new
+          response.status = 202
+          response.headers = {
+            "X-Compute-Request-Id" => "req-fdc6f99e-55a2-4ab1-8904-0892753828cf",
+            "Content-Type"         => "application/json",
+            "Content-Length"       => "356",
+            "Date"                 => Date.new
+          }
+          response.body = data[:nodes].first
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/baremetal/huaweicloud/requests/set_node_provision_state.rb

@@ -0,0 +1,38 @@
+module Fog
+  module Baremetal
+    class HuaweiCloud
+      class Real
+        def set_node_provision_state(node_id, provision_state)
+          data = {
+            'target' => provision_state
+          }
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 202,
+            :method  => 'PUT',
+            :path    => "nodes/#{node_id}/states/provision",
+            :headers => {
+              :'X-HuaweiCloud-Ironic-API-Version' => 'latest'
+            }
+          )
+        end
+      end
+
+      class Mock
+        def set_node_provision_state(_node_id, _provision_state)
+          response = Excon::Response.new
+          response.status = 202
+          response.headers = {
+            "X-Compute-Request-Id" => "req-fdc6f99e-55a2-4ab1-8904-0892753828cf",
+            "Content-Type"         => "application/json",
+            "Content-Length"       => "356",
+            "Date"                 => Date.new
+          }
+          response.body = data[:nodes].first
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/baremetal/huaweicloud/requests/unset_node_maintenance.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Baremetal
+    class HuaweiCloud
+      class Real
+        def unset_node_maintenance(node_uuid, parameters = nil)
+          request(
+            :expects => [200, 202, 204],
+            :method  => 'DELETE',
+            :path    => "nodes/#{node_uuid}/maintenance",
+            :query   => parameters
+          )
+        end
+      end
+
+      class Mock
+        def unset_node_maintenance(_node_uuid, _parameters = nil)
+          response = Excon::Response.new
+          response.status = 202
+          response.headers = {
+            "X-Compute-Request-Id" => "req-fdc6f99e-55a2-4ab1-8904-0892753828cf",
+            "Content-Type"         => "application/json",
+            "Content-Length"       => "356",
+            "Date"                 => Date.new
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/baremetal/huaweicloud.rb

@@ -0,0 +1,284 @@
+
+
+module Fog
+  module Baremetal
+    class HuaweiCloud < Fog::Service
+      SUPPORTED_VERSIONS = /(.)*/
+
+      requires :huaweicloud_auth_url
+      recognizes :huaweicloud_auth_token, :huaweicloud_management_url,
+                 :persistent, :huaweicloud_service_type, :huaweicloud_service_name,
+                 :huaweicloud_tenant, :huaweicloud_tenant_id,
+                 :huaweicloud_api_key, :huaweicloud_username, :huaweicloud_identity_endpoint,
+                 :current_user, :current_tenant, :huaweicloud_region,
+                 :huaweicloud_endpoint_type, :huaweicloud_cache_ttl,
+                 :huaweicloud_project_name, :huaweicloud_project_id,
+                 :huaweicloud_project_domain, :huaweicloud_user_domain, :huaweicloud_domain_name,
+                 :huaweicloud_project_domain_id, :huaweicloud_user_domain_id, :huaweicloud_domain_id
+
+      ## MODELS
+      #
+      model_path 'fog/baremetal/huaweicloud/models'
+      model       :chassis
+      collection  :chassis_collection
+      model       :driver
+      collection  :drivers
+      model       :node
+      collection  :nodes
+      model       :port
+      collection  :ports
+
+      ## REQUESTS
+      #
+      request_path 'fog/baremetal/huaweicloud/requests'
+
+      # Node requests
+      request :create_node
+      request :delete_node
+      request :get_node
+      request :list_nodes
+      request :list_nodes_detailed
+      request :patch_node
+      request :set_node_power_state
+      request :set_node_provision_state
+      request :set_node_maintenance
+      request :unset_node_maintenance
+
+      # Chassis requests
+      request :create_chassis
+      request :delete_chassis
+      request :get_chassis
+      request :list_chassis
+      request :list_chassis_detailed
+      request :patch_chassis
+
+      # Driver requests
+      request :get_driver
+      request :get_driver_properties
+      request :list_drivers
+
+      # Port requests
+      request :create_port
+      request :delete_port
+      request :get_port
+      request :list_ports
+      request :list_ports_detailed
+      request :patch_port
+
+      ## TODO not implemented API requests:
+      ## Chassis
+      # request :list_chassis_nodes
+      # request :list_chassis_nodes_details
+
+      ## Node requests
+      # request :validate_node
+      # request :get_boot_device
+      # request :set_boot_device
+      # request :list_supported_boot_devices
+      # request :list_node_states
+      # request :get_console_info
+      # request :change_console_state
+      # request :get_vendor_passthru_methods
+
+      ## Driver requests
+      # request :get_vendor_passthru_methods
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            chassis_uuid = Fog::UUID.uuid
+            instance_uuid = Fog::UUID.uuid
+            node_uuid = Fog::UUID.uuid
+
+            hash[key] = {
+              :chassis_collection => [
+                {
+                  "created_at"  => "2000-01-01T12:00:00",
+                  "description" => "Sample chassis",
+                  "extra"       => {},
+                  "links"       => [
+                    {
+                      "href" => "http://localhost:6385/v1/chassis/eaaca217-e7d8-47b4-bb41-3f99f20eed89",
+                      "rel"  => "self"
+                    },
+                    {
+                      "href" => "http://localhost:6385/chassis/eaaca217-e7d8-47b4-bb41-3f99f20eed89",
+                      "rel"  => "bookmark"
+                    }
+                  ],
+                  "nodes"       => [
+                    {
+                      "href" => "http://localhost:6385/v1/chassis/eaaca217-e7d8-47b4-bb41-3f99f20eed89/nodes",
+                      "rel"  => "self"
+                    },
+                    {
+                      "href" => "http://localhost:6385/chassis/eaaca217-e7d8-47b4-bb41-3f99f20eed89/nodes",
+                      "rel"  => "bookmark"
+                    }
+                  ],
+                  "updated_at"  => "2000-01-01T12:00:00",
+                  "uuid"        => chassis_uuid
+                }
+              ],
+              :drivers            => [
+                {
+                  "hosts" => [
+                    "fake-host"
+                  ],
+                  "name"  => "sample-driver"
+                }
+              ],
+              :nodes              => [{
+                "chassis_uuid"           => chassis_uuid,
+                "console_enabled"        => false,
+                "created_at"             => "2000-01-01T12:00:00",
+                "driver"                 => "sample-driver",
+                "driver_info"            => {},
+                "extra"                  => {},
+                "instance_info"          => {},
+                "instance_uuid"          => instance_uuid,
+                "last_error"             => nil,
+                "links"                  => [
+                  {
+                    "href" => "http://localhost:6385/v1/nodes/1be26c0b-03f2-4d2e-ae87-c02d7f33c123",
+                    "rel"  => "self"
+                  },
+                  {
+                    "href" => "http://localhost:6385/nodes/1be26c0b-03f2-4d2e-ae87-c02d7f33c123",
+                    "rel"  => "bookmark"
+                  }
+                ],
+                "maintenance"            => false,
+                "maintenance_reason"     => nil,
+                "ports"                  => [
+                  {
+                    "href" => "http://localhost:6385/v1/nodes/1be26c0b-03f2-4d2e-ae87-c02d7f33c123/ports",
+                    "rel"  => "self"
+                  },
+                  {
+                    "href" => "http://localhost:6385/nodes/1be26c0b-03f2-4d2e-ae87-c02d7f33c123/ports",
+                    "rel"  => "bookmark"
+                  }
+                ],
+                "power_state"            => "power on",
+                "properties"             => {
+                  "cpus"      => "1",
+                  "local_gb"  => "10",
+                  "memory_mb" => "1024"
+                },
+                "provision_state"        => "active",
+                "provision_updated_at"   => "2000-01-01T12:00:00",
+                "reservation"            => nil,
+                "target_power_state"     => nil,
+                "target_provision_state" => nil,
+                "updated_at"             => "2000-01-01T12:00:00",
+                "uuid"                   => node_uuid
+              }],
+              :ports              => [{
+                "address"    => "fe:54:00:77:07:d9",
+                "created_at" => "2014-12-23T19:35:30.734116",
+                "extra"      => {
+                  "foo" => "bar"
+                },
+                "links"      => [
+                  {
+                    "href" => "http://localhost:6385/v1/ports/27e3153e-d5bf-4b7e-b517-fb518e17f34c",
+                    "rel"  => "self"
+                  },
+                  {
+                    "href" => "http://localhost:6385/ports/27e3153e-d5bf-4b7e-b517-fb518e17f34c",
+                    "rel"  => "bookmark"
+                  }
+                ],
+                "node_uuid"  => "7ae81bb3-dec3-4289-8d6c-da80bd8001ae",
+                "updated_at" => "2014-12-23T19:35:30.734119",
+                "uuid"       => "27e3153e-d5bf-4b7e-b517-fb518e17f34c"
+              }]
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options = {})
+          @huaweicloud_username = options[:huaweicloud_username]
+          @huaweicloud_tenant   = options[:huaweicloud_tenant]
+          @huaweicloud_auth_uri = URI.parse(options[:huaweicloud_auth_url])
+
+          @auth_token = Fog::Mock.random_base64(64)
+          @auth_token_expiration = (Time.now.utc + 86400).iso8601
+
+          management_url = URI.parse(options[:huaweicloud_auth_url])
+          management_url.port = 9292
+          management_url.path = '/v1'
+          @huaweicloud_management_url = management_url.to_s
+
+          @data ||= {:users => {}}
+          unless @data[:users].find { |u| u['name'] == options[:huaweicloud_username] }
+            id = Fog::Mock.random_numbers(6).to_s
+            @data[:users][id] = {
+              'id'       => id,
+              'name'     => options[:huaweicloud_username],
+              'email'    => "#{options[:huaweicloud_username]}@mock.com",
+              'tenantId' => Fog::Mock.random_numbers(6).to_s,
+              'enabled'  => true
+            }
+          end
+        end
+
+        def data
+          self.class.data[@huaweicloud_username]
+        end
+
+        def reset_data
+          self.class.data.delete(@huaweicloud_username)
+        end
+
+        def credentials
+          {:provider                 => 'huaweicloud',
+           :huaweicloud_auth_url       => @huaweicloud_auth_uri.to_s,
+           :huaweicloud_auth_token     => @auth_token,
+           :huaweicloud_region         => @huaweicloud_region,
+           :huaweicloud_management_url => @huaweicloud_management_url}
+        end
+      end
+
+      class Real
+        include Fog::HuaweiCloud::Core
+
+        # NOTE: uncommenting this should be treated as api-change!
+        # def self.not_found_class
+        #   Fog::Baremetal::HuaweiCloud::NotFound
+        # end
+
+        def initialize(options = {})
+          initialize_identity options
+
+          @huaweicloud_service_type  = options[:huaweicloud_service_type] || ['baremetal']
+          @huaweicloud_service_name  = options[:huaweicloud_service_name]
+
+          @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
+
+        private
+
+        def set_api_path
+          unless @path.match(SUPPORTED_VERSIONS)
+            @path = "/" + Fog::HuaweiCloud.get_supported_version(SUPPORTED_VERSIONS,
+                                                               @huaweicloud_management_uri,
+                                                               @auth_token,
+                                                               @connection_options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/address.rb

@@ -0,0 +1,67 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Address < Fog::HuaweiCloud::Model
+        identity  :id
+
+        attribute :ip
+        attribute :pool
+        attribute :fixed_ip
+        attribute :instance_id
+
+        def initialize(attributes = {})
+          # assign server first to prevent race condition with persisted?
+          self.server = attributes.delete(:server)
+          super
+        end
+
+        def destroy
+          requires :id
+          service.release_address(id)
+          true
+        end
+
+        def server=(new_server)
+          if new_server
+            associate(new_server)
+          else
+            disassociate
+          end
+        end
+
+        def save
+          raise Fog::Errors::Error, 'Resaving an existing object may create a duplicate' if persisted?
+          data = service.allocate_address(pool).body['floating_ip']
+          new_attributes = data.reject { |key, _value| !['id', 'instance_id', 'ip', 'fixed_ip'].include?(key) }
+          merge_attributes(new_attributes)
+          if @server
+            self.server = @server
+          end
+          true
+        end
+
+        private
+
+        def associate(new_server)
+          if persisted?
+            @server = nil
+            self.instance_id = new_server.id
+            service.associate_address(instance_id, ip)
+          else
+            @server = new_server
+          end
+        end
+
+        def disassociate
+          @server = nil
+          if persisted?
+            service.disassociate_address(instance_id, ip)
+          end
+          self.instance_id = nil
+        end
+      end
+    end
+  end
+end