fog-huaweicloud 0.0.1 → 0.0.2

data/lib/fog/compute/huaweicloud/requests/create_flavor.rb

@@ -0,0 +1,85 @@
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Real
+        # PARAMETERS #
+        # name        = Name of flavor
+        # ram         = Memory in MB
+        # vcpus       = Number of VCPUs
+        # disk        = Size of local disk in GB
+        # swap        = Swap space in MB
+        # rxtx_factor = RX/TX factor
+        def create_flavor(attributes)
+          # Get last flavor id
+          flavor_ids = []
+          flavors = list_flavors_detail.body['flavors'] + list_flavors_detail(:is_public => false).body['flavors']
+          flavors.each do |flavor|
+            flavor_ids << flavor['id'].to_i
+          end
+
+          # Set flavor id
+          attributes[:flavor_id] = attributes[:flavor_id] || (!flavor_ids.empty? ? flavor_ids.sort.last + 1 : 1)
+
+          data = {
+            'flavor' => {
+              'name'                       => attributes[:name],
+              'ram'                        => attributes[:ram],
+              'vcpus'                      => attributes[:vcpus],
+              'disk'                       => attributes[:disk],
+              'id'                         => attributes[:flavor_id],
+              'swap'                       => attributes[:swap],
+              'OS-FLV-EXT-DATA:ephemeral'  => attributes[:ephemeral],
+              'os-flavor-access:is_public' => attributes[:is_public],
+              'rxtx_factor'                => attributes[:rxtx_factor]
+            }
+          }
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 200,
+            :method  => 'POST',
+            :path    => 'flavors'
+          )
+        end
+      end
+
+      class Mock
+        def create_flavor(attributes)
+          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 = {
+            "flavor" => {
+              "vcpus"                      => attributes[:vcpus],
+              "disk"                       => attributes[:disk],
+              "name"                       => attributes[:name],
+              "links"                      => [
+                {
+                  "href" => "http://192.168.27.100:8774/v1.1/6733e93c5f5c4eb1bcabc6902ba208d6/flavors/11",
+                  "rel"  => "self"
+                },
+                {
+                  "href" => "http://192.168.27.100:8774/6733e93c5f5c4eb1bcabc6902ba208d6/flavors/11",
+                  "rel"  => "bookmark"
+                }
+              ],
+              "rxtx_factor"                => attributes[:rxtx_factor] || 1.0,
+              "OS-FLV-EXT-DATA:ephemeral"  => attributes[:ephemeral] || 0,
+              "os-flavor-access:is_public" => attributes[:is_public] || false,
+              "OS-FLV-DISABLED:disabled"   => attributes[:disabled] || false,
+              "ram"                        => attributes[:ram],
+              "id"                         => "11",
+              "swap"                       => attributes[:swap] || ""
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/requests/create_flavor_metadata.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Real
+        def create_flavor_metadata(flavor_ref, metadata)
+          data = {
+            'extra_specs' => metadata
+          }
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 200,
+            :method  => 'POST',
+            :path    => "flavors/#{flavor_ref}/os-extra_specs"
+          )
+        end
+      end
+
+      class Mock
+        def create_flavor_metadata(_flavor_ref, _metadata)
+          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 = {"extra_specs" => {
+            "cpu_arch" => "x86_64"
+          }}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/requests/create_image.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Real
+        def create_image(server_id, name, metadata = {})
+          body = {'createImage' => {
+            'name'     => name,
+            'metadata' => metadata
+          }}
+          data = server_action(server_id, body)
+          image_id = data.headers["Location"].scan(%r{.*/(.*)}).flatten[0]
+          get_image_details(image_id)
+        end
+      end
+
+      class Mock
+        def create_image(server_id, name, metadata = {})
+          response = Excon::Response.new
+          response.status = 202
+
+          img_id = Fog::Mock.random_numbers(6).to_s
+
+          data = {
+            'id'       => img_id,
+            'server'   => {"id" => "3", "links" => [{"href" => "http://nova1:8774/admin/servers/#{server_id}", "rel" => "bookmark"}]},
+            'links'    => [{"href" => "http://nova1:8774/v1.1/admin/images/#{img_id}", "rel" => "self"}, {"href" => "http://nova1:8774/admin/images/#{img_id}", "rel" => "bookmark"}],
+            'metadata' => metadata || {},
+            'name'     => name || "server_#{rand(999)}",
+            'progress' => 0,
+            'status'   => 'SAVING',
+            'minDisk'  => 0,
+            'minRam'   => 0,
+            'updated'  => "",
+            'created'  => ""
+          }
+          self.data[:last_modified][:images][data['id']] = Time.now
+          self.data[:images][data['id']] = data
+          response.body = {'image' => data}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/requests/create_key_pair.rb

@@ -0,0 +1,48 @@
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Real
+        def create_key_pair(key_name, public_key = nil, user_id = nil)
+          data = {
+            'keypair' => {
+              'name' => key_name
+            }
+          }
+
+          data['keypair']['public_key'] = public_key unless public_key.nil?
+          data['keypair']['user_id'] = user_id unless user_id.nil?
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => [200, 201],
+            :method  => 'POST',
+            :path    => 'os-keypairs'
+          )
+        end
+      end
+
+      class Mock
+        def create_key_pair(key_name, _public_key = nil)
+          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"       => "1289",
+            "Date"                 => Date.new
+          }
+          response.body = {
+            "keypair" => {
+              "public_key"  => "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDCdAZLjljntJbLVVkNHjWFSoKen2nZbk39ZfqhZJOMdeFdz02GWBS45rcuboeGg/gozKRwsLu4N6NLPlYtbK/NapJIvgO/djBp+FQG1QZNtLPsx7j4hVJac3yISGms+Xtu4cEv6j5sFDzAgTQbWez0Z1+9qOq9ngdaoW+YClfQ== vagrant@nova\n",
+              "private_key" => "-----BEGIN RSA PRIVATE KEY-----\nMIICXgIBAAKBgQDCdAZLjljn1tJbLVVkNHjWFSoKen2nZbk39ZfqhZJOMdeFdz02\nGWBS45rcuHboeGg/gozKRwsLu4N6NLPlYtbK/NapJIvgO/djBp+FQG1QZNtLPsx7\nj4hVJac3yISGms+Xtu4cEv6j5sFDzAgTQbWez0Z1+9qOq9ngdaoW+YClfQIDAQAB\nAoGBALBoT9m1vuQ82EONQf2RONqHAsfUzi/SMhEZRgOlv9AemXZkcWyl4uPvxmtd\nEcreiTystAtCHjw7lhCExXthipevUjtIAAt+b3pMn6Oyjad3IRvde6atMdjrje43\n/nftYtuXYyJTsvwEvLYqSioLQ0Nn/XDKhOpcM5tejDHOH35lAkEA+H4r7y9X521u\nIABVAezBWaT/wvdMjx5cwfyYEQjnI1bxfRIqkgoY5gDDBdVbT75UTsHHbHLORQcw\nRjRvS2zgewJBAMhT6eyMonJvHHvC5RcchcY+dWkscIKoOzeyUKMb+7tERQa9/UN2\njYb+jdM0VyL0ruLFwYtl2m34gfmhcXgIvGcCQGzKMEnjHEUBr7jq7EyPbobkqeSd\niDMQQ+PZxmmO0EK0ib0L+v881HG926PuKK/cz+Q7Cif8iznFT+ksg50t6YkCQQC9\nwfcAskqieSuS9A9LcCIrojhXctf0e+T0Ij2N89DlF4sHEuqXf/IZ4IB5gsfTfdE3\nUDnAkK9yogaEbu/r0uKbAkEAy5kl71bIqvKTKsY2mES9ziVxfftl/9UIi5LI+QHb\nmC/c6cTrGVCM71fi2GMxGgBeEea4+7xwoWTL4CxA00kmTg==\n-----END RSA PRIVATE KEY-----\n",
+              "user_id"     => "admin",
+              "name"        => key_name,
+              "fingerprint" => "97:86:f4:15:68:0c:7b:a7:e5:8f:f0:bd:1f:27:65:ad"
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/requests/create_os_interface.rb

@@ -0,0 +1,42 @@
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Real
+        # === Parameters
+        # * server_id <~String>
+        # * options <~Hash>
+        def create_os_interface(server_id, options={})
+          body = {
+            'interfaceAttachment' => {}
+          }
+
+          if options[:port_id]
+            body['interfaceAttachment']['port_id'] = options[:port_id]
+          elsif options[:subnet_id]
+            body['interfaceAttachment']['subnet_id'] = options[:subnet_id]
+          end
+
+          if options[:ip_address]
+            body['interfaceAttachment']['fixed_ips'] = {ip_address: options[:ip_address]}
+          end
+
+          request(
+            :body    => Fog::JSON.encode(body),
+            :expects => [200, 201, 202, 204],
+            :method  => 'POST',
+            :path    => "servers/#{server_id}/os-interface"
+          )
+        end
+      end
+
+      class Mock
+        def create_os_interface(server_id, options={})
+          Excon::Response.new(
+            :body   => {'interfaceAttachment' => data[:os_interfaces].first},
+            :status => 200
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Real
+        def create_security_group(name, description)
+          data = {
+            'security_group' => {
+              'name'        => name,
+              'description' => description
+            }
+          }
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 200,
+            :method  => 'POST',
+            :path    => 'os-security-groups'
+          )
+        end
+      end
+
+      class Mock
+        def create_security_group(name, description)
+          Fog::Identity::HuaweiCloud.new(:huaweicloud_auth_url => credentials[:huaweicloud_auth_url])
+          tenant_id = Fog::Identity::HuaweiCloud::V2::Mock.data[current_tenant][:tenants].keys.first
+          security_group_id = Fog::Mock.random_numbers(2).to_i + 1
+          data[:security_groups][security_group_id.to_s] = {
+            '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-#{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' => data[:security_groups][security_group_id.to_s]
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/requests/create_security_group_rule.rb

@@ -0,0 +1,57 @@
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Real
+        def create_security_group_rule(parent_group_id, ip_protocol, from_port, to_port, cidr, group_id = nil)
+          data = {
+            'security_group_rule' => {
+              'parent_group_id' => parent_group_id,
+              'ip_protocol'     => ip_protocol,
+              'from_port'       => from_port,
+              'to_port'         => to_port,
+              'cidr'            => cidr,
+              'group_id'        => group_id
+            }
+          }
+
+          request(
+            :expects => 200,
+            :method  => 'POST',
+            :body    => Fog::JSON.encode(data),
+            :path    => 'os-security-group-rules'
+          )
+        end
+      end
+
+      class Mock
+        def create_security_group_rule(parent_group_id, ip_protocol, from_port, to_port, cidr, group_id = nil)
+          parent_group_id = parent_group_id.to_i
+          response = Excon::Response.new
+          response.status = 200
+          response.headers = {
+            '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
+          }
+          rule = {
+            'id'              => Fog::Mock.random_numbers(2).to_i,
+            'from_port'       => from_port,
+            'group'           => group_id || {},
+            'ip_protocol'     => ip_protocol,
+            'to_port'         => to_port,
+            'parent_group_id' => parent_group_id,
+            'ip_range'        => {
+              'cidr' => cidr
+            }
+          }
+          data[:security_groups][parent_group_id.to_s]['rules'].push(rule)
+          response.body = {
+            'security_group_rule' => rule
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/requests/create_server.rb

@@ -0,0 +1,187 @@
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Real
+        def create_server(name, image_ref, flavor_ref, options = {})
+          data = {
+            'server' => {
+              'flavorRef' => flavor_ref,
+              'name'      => name
+            }
+          }
+          data['server']['imageRef'] = image_ref if image_ref
+
+          vanilla_options = ['metadata', 'accessIPv4', 'accessIPv6',
+                             'availability_zone', 'user_data', 'key_name',
+                             'adminPass', 'config_drive', 'min_count', 'max_count',
+                             'return_reservation_id']
+          vanilla_options.select { |o| options[o] }.each do |key|
+            data['server'][key] = options[key]
+          end
+
+          if options['security_groups']
+            # security names requires a hash with a name prefix
+            data['server']['security_groups'] =
+              Array(options['security_groups']).map do |sg|
+                name = if sg.kind_of?(Fog::Compute::HuaweiCloud::SecurityGroup)
+                         sg.name
+                       else
+                         sg
+                       end
+                {:name => name}
+              end
+          end
+
+          if options['personality']
+            data['server']['personality'] = []
+            options['personality'].each do |file|
+              data['server']['personality'] << {
+                'contents' => Base64.encode64(file['contents'] || file[:contents]),
+                'path'     => file['path'] || file[:path]
+              }
+            end
+          end
+
+          if options['nics']
+            data['server']['networks'] =
+              Array(options['nics']).map do |nic|
+                neti = {}
+                neti['uuid'] = (nic['subnet_id'] || nic[:subnet_id]) unless (nic['subnet_id'] || nic[:subnet_id]).nil?
+                neti['fixed_ip'] = (nic['v4_fixed_ip'] || nic[:v4_fixed_ip]) unless (nic['v4_fixed_ip'] || nic[:v4_fixed_ip]).nil?
+                neti['port'] = (nic['port_id'] || nic[:port_id]) unless (nic['port_id'] || nic[:port_id]).nil?
+                neti
+              end
+          end
+
+          if options['os:scheduler_hints']
+            data['os:scheduler_hints'] = options['os:scheduler_hints']
+          end
+
+          if (block_device_mapping = options['block_device_mapping_v2'])
+            data['server']['block_device_mapping_v2'] = [block_device_mapping].flatten.collect do |mapping|
+              entered_block_device_mapping = {}
+              [:boot_index, :delete_on_termination, :destination_type, :device_name, :device_type, :disk_bus,
+               :guest_format, :source_type, :uuid, :volume_size].each do |index|
+                entered_block_device_mapping[index.to_s] = mapping[index] if mapping.key?(index)
+              end
+              entered_block_device_mapping
+            end
+          elsif (block_device_mapping = options['block_device_mapping'])
+            data['server']['block_device_mapping'] = [block_device_mapping].flatten.collect do |mapping|
+              {
+                'delete_on_termination' => mapping[:delete_on_termination],
+                'device_name'           => mapping[:device_name],
+                'volume_id'             => mapping[:volume_id],
+                'volume_size'           => mapping[:volume_size],
+              }
+            end
+          end
+
+          path = options['block_device_mapping'] ? 'os-volumes_boot' : 'servers'
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => [200, 202],
+            :method  => 'POST',
+            :path    => path
+          )
+        end
+      end
+
+      class Mock
+        def create_server(name, image_ref, flavor_ref, options = {})
+          response = Excon::Response.new
+          response.status = 202
+
+          server_id = Fog::Mock.random_numbers(6).to_s
+          identity = Fog::Identity::HuaweiCloud.new :huaweicloud_auth_url => credentials[:huaweicloud_auth_url]
+          user = identity.users.find do |u|
+            u.name == @huaweicloud_username
+          end
+
+          user_id = if user
+                      user.id
+                    else
+                      response = identity.create_user(@huaweicloud_username,
+                                                      'password',
+                                                      "#{@huaweicloud_username}@example.com")
+                      response.body["user"]["id"]
+                    end
+
+          mock_data = {
+            'addresses'    => {"Private" => [{"addr" => Fog::Mock.random_ip}]},
+            'flavor'       => {"id" => flavor_ref, "links" => [{"href" => "http://nova1:8774/admin/flavors/1", "rel" => "bookmark"}]},
+            'id'           => server_id,
+            'image'        => {"id" => image_ref, "links" => [{"href" => "http://nova1:8774/admin/images/#{image_ref}", "rel" => "bookmark"}]},
+            'links'        => [{"href" => "http://nova1:8774/v1.1/admin/servers/5", "rel" => "self"}, {"href" => "http://nova1:8774/admin/servers/5", "rel" => "bookmark"}],
+            'hostId'       => "123456789ABCDEF01234567890ABCDEF",
+            'metadata'     => options['metadata'] || {},
+            'name'         => name || "server_#{rand(999)}",
+            'accessIPv4'   => options['accessIPv4'] || "",
+            'accessIPv6'   => options['accessIPv6'] || "",
+            'progress'     => 0,
+            'status'       => 'BUILD',
+            'created'      => '2012-09-27T00:04:18Z',
+            'updated'      => '2012-09-27T00:04:27Z',
+            'user_id'      => user_id,
+            'config_drive' => options['config_drive'] || '',
+          }
+
+          nics = options['nics']
+
+          if nics
+            nics.each do |_nic|
+              mock_data["addresses"].merge!(
+                "Public" => [{'addr' => Fog::Mock.random_ip}]
+              )
+            end
+          end
+
+          response_data = if options['return_reservation_id'] == 'True'
+                            {'reservation_id' => "r-#{Fog::Mock.random_numbers(6)}"}
+                          else
+                            {
+                              'adminPass' => 'password',
+                              'id'        => server_id,
+                              'links'     => mock_data['links'],
+                            }
+                          end
+
+          if block_devices = options["block_device_mapping_v2"]
+            block_devices.each { |bd| volumes.get(bd[:uuid]).attach(server_id, bd[:device_name]) }
+          elsif block_device = options["block_device_mapping"]
+            volumes.get(block_device[:volume_id]).attach(server_id, block_device[:device_name])
+          end
+
+          data[:last_modified][:servers][server_id] = Time.now
+          data[:servers][server_id] = mock_data
+          security_groups = options['security_groups']
+          if security_groups
+            groups = Array(security_groups).map do |sg|
+              if sg.kind_of?(Fog::Compute::HuaweiCloud::SecurityGroup)
+                sg.name
+              else
+                sg
+              end
+            end
+
+            data[:server_security_group_map][server_id] = groups
+            response_data['security_groups'] = groups
+          end
+
+          if options['os:scheduler_hints'] && options['os:scheduler_hints']['group']
+            group = data[:server_groups][options['os:scheduler_hints']['group']]
+            group[:members] << server_id if group
+          end
+
+          response.body = if options['return_reservation_id'] == 'True'
+                            response_data
+                          else
+                            {'server' => response_data}
+                          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/requests/create_server_group.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Real
+        def create_server_group(name, policy)
+          Fog::Compute::HuaweiCloud::ServerGroup.validate_server_group_policy policy
+
+          body = {'server_group' => {
+            'name'     => name,
+            'policies' => [policy]
+          }}
+          request(
+            :body    => Fog::JSON.encode(body),
+            :expects => 200,
+            :method  => 'POST',
+            :path    => 'os-server-groups'
+          )
+        end
+      end
+
+      class Mock
+        def create_server_group(name, policy)
+          Fog::Compute::HuaweiCloud::ServerGroup.validate_server_group_policy policy
+          id = SecureRandom.uuid
+          data[:server_groups][id] = {:name => name, :policies => [policy], :members => []}
+          get_server_group id
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/requests/create_snapshot.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Real
+        def create_snapshot(volume_id, name, description, force = false)
+          data = {
+            'snapshot' => {
+              'volume_id'           => volume_id,
+              'display_name'        => name,
+              'display_description' => description,
+              'force'               => force
+            }
+          }
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => [200, 202],
+            :method  => 'POST',
+            :path    => "os-snapshots"
+          )
+        end
+      end
+
+      class Mock
+        def create_snapshot(volume_id, name, description, _force = false)
+          volume_response = get_volume_details(volume_id)
+          volume = volume_response.data[:body]['volume']
+          if volume.nil?
+            raise Fog::Compute::HuaweiCloud::NotFound
+          else
+            response = Excon::Response.new
+            data = {
+              "status"      => "availble",
+              "name"        => name,
+              "created_at"  => Time.now,
+              "description" => description,
+              "volume_id"   => volume_id,
+              "id"          => Fog::Mock.random_numbers(2),
+              "size"        => volume['size']
+            }
+
+            self.data[:snapshots][data['id']] = data
+            response.body = {"snapshot" => data}
+            response.status = 202
+            response
+          end
+        end
+      end
+    end
+  end
+end