fog-huaweicloud 0.0.1 → 0.0.2

data/lib/fog/shared_file_system/huaweicloud.rb

@@ -0,0 +1,389 @@
+module Fog
+  module SharedFileSystem
+    class HuaweiCloud < Fog::Service
+      SUPPORTED_VERSIONS = /v2(\.0)*/
+      SUPPORTED_MICROVERSION = '2.15'.freeze
+
+      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,
+                 :huaweicloud_identity_prefix, :huaweicloud_shared_file_system_microversion
+
+      model_path 'fog/shared_file_system/huaweicloud/models'
+      model       :network
+      collection  :networks
+      model       :share
+      collection  :shares
+      model       :snapshot
+      collection  :snapshots
+      model       :share_access_rule
+      collection  :share_access_rules
+      model       :share_export_location
+      collection  :share_export_locations
+      model       :availability_zone
+      collection  :availability_zones
+
+      request_path 'fog/shared_file_system/huaweicloud/requests'
+      # share networks
+      request :list_share_networks
+      request :list_share_networks_detail
+      request :get_share_network
+      request :create_share_network
+      request :update_share_network
+      request :delete_share_network
+      request :share_network_action
+      request :add_security_service_to_share_network
+      request :remove_security_service_from_share_network
+
+      # shares
+      request :list_shares
+      request :list_shares_detail
+      request :get_share
+      request :create_share
+      request :update_share
+      request :delete_share
+      request :share_action
+      request :grant_share_access
+      request :revoke_share_access
+      request :list_share_access_rules
+      request :list_share_export_locations
+      request :extend_share
+      request :shrink_share
+
+      # snapshots
+      request :list_snapshots
+      request :list_snapshots_detail
+      request :get_snapshot
+      request :create_snapshot
+      request :update_snapshot
+      request :delete_snapshot
+
+      # security services
+      request :list_security_services
+      request :list_security_services_detail
+      request :get_security_service
+      request :create_security_service
+      request :update_security_service
+      request :delete_security_service
+
+      # quota + limits
+      request :get_limits
+      request :get_quota
+      request :update_quota
+
+      # availability zones
+      request :list_availability_zones
+
+      # rubocop:disable LineLength, Metrics/MethodLength, Metrics/ClassLength, Metrics/AbcSize
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :shares                   => [
+                {
+                  "id"    => "d94a8548-2079-4be0-b21c-0a887acd31ca",
+                  "links" => [
+                    {
+                      "href" => "http://172.18.198.54:8786/v1/16e1ab15c35a457e9c2b2aa189f544e1/shares/d94a8548-2079-4be0-b21c-0a887acd31ca",
+                      "rel"  => "self"
+                    },
+                    {
+                      "href" => "http://172.18.198.54:8786/16e1ab15c35a457e9c2b2aa189f544e1/shares/d94a8548-2079-4be0-b21c-0a887acd31ca",
+                      "rel"  => "bookmark"
+                    }
+                  ],
+                  "name"  => "My_share"
+                },
+                {
+                  "id"    => "406ea93b-32e9-4907-a117-148b3945749f",
+                  "links" => [
+                    {
+                      "href" => "http://172.18.198.54:8786/v1/16e1ab15c35a457e9c2b2aa189f544e1/shares/406ea93b-32e9-4907-a117-148b3945749f",
+                      "rel"  => "self"
+                    },
+                    {
+                      "href" => "http://172.18.198.54:8786/16e1ab15c35a457e9c2b2aa189f544e1/shares/406ea93b-32e9-4907-a117-148b3945749f",
+                      "rel"  => "bookmark"
+                    }
+                  ],
+                  "name"  => "Share1"
+                }
+              ],
+              :shares_detail            => [
+                {
+                  "links"                       => [
+                    {
+                      "href" => "http://172.18.198.54:8786/v2/16e1ab15c35a457e9c2b2aa189f544e1/shares/f45cc5b2-d1bb-4a3e-ba5b-5c4125613adc",
+                      "rel"  => "self"
+                    },
+                    {
+                      "href" => "http://172.18.198.54:8786/16e1ab15c35a457e9c2b2aa189f544e1/shares/f45cc5b2-d1bb-4a3e-ba5b-5c4125613adc",
+                      "rel"  => "bookmark"
+                    }
+                  ],
+                  "availability_zone"           => "nova",
+                  "share_network_id"            => "f9b2e754-ac01-4466-86e1-5c569424754e",
+                  "export_locations"            => [],
+                  "share_server_id"             => "87d8943a-f5da-47a4-b2f2-ddfa6794aa82",
+                  "snapshot_id"                 => '',
+                  "id"                          => "f45cc5b2-d1bb-4a3e-ba5b-5c4125613adc",
+                  "size"                        => 1,
+                  "share_type"                  => "25747776-08e5-494f-ab40-a64b9d20d8f7",
+                  "share_type_name"             => "default",
+                  "export_location"             => '',
+                  "consistency_group_id"        => "9397c191-8427-4661-a2e8-b23820dc01d4",
+                  "project_id"                  => "16e1ab15c35a457e9c2b2aa189f544e1",
+                  "metadata"                    => {},
+                  "status"                      => "available",
+                  "access_rules_status"         => "active",
+                  "description"                 => "There is a share description.",
+                  "host"                        => "manila2@generic1#GENERIC1",
+                  "task_state"                  => '',
+                  "is_public"                   => 'true',
+                  "snapshot_support"            => 'true',
+                  "name"                        => "my_share4",
+                  "has_replicas"                => 'false',
+                  "replication_type"            => '',
+                  "created_at"                  => "2015-09-16T18:19:50.000000",
+                  "share_proto"                 => "NFS",
+                  "volume_type"                 => "default",
+                  "source_cgsnapshot_member_id" => ''
+                }
+              ],
+              :share_networks           => [
+                {
+                  "id"   => "32763294-e3d4-456a-998d-60047677c2fb",
+                  "name" => "net_my1"
+                },
+                {
+                  "id"   => "713df749-aac0-4a54-af52-10f6c991e80c",
+                  "name" => "net_my"
+                }
+              ],
+              :share_networks_detail    => [
+                {
+                  "name"              => "net_my1",
+                  "segmentation_id"   => '',
+                  "created_at"        => "2015-09-04T14:57:13.000000",
+                  "neutron_subnet_id" => "53482b62-2c84-4a53-b6ab-30d9d9800d06",
+                  "updated_at"        => '',
+                  "id"                => "32763294-e3d4-456a-998d-60047677c2fb",
+                  "neutron_net_id"    => "998b42ee-2cee-4d36-8b95-67b5ca1f2109",
+                  "ip_version"        => '',
+                  "nova_net_id"       => '',
+                  "cidr"              => '',
+                  "project_id"        => "16e1ab15c35a457e9c2b2aa189f544e1",
+                  "network_type"      => '',
+                  "description"       => "descr"
+                }
+              ],
+              :snapshots                => [
+                {
+                  "id"    => "086a1aa6-c425-4ecd-9612-391a3b1b9375",
+                  "links" => [
+                    {
+                      "href" => "http://172.18.198.54:8786/v1/16e1ab15c35a457e9c2b2aa189f544e1/snapshots/086a1aa6-c425-4ecd-9612-391a3b1b9375",
+                      "rel"  => "self"
+                    },
+                    {
+                      "href" => "http://172.18.198.54:8786/16e1ab15c35a457e9c2b2aa189f544e1/snapshots/086a1aa6-c425-4ecd-9612-391a3b1b9375",
+                      "rel"  => "bookmark"
+                    }
+                  ],
+                  "name"  => "snapshot_My_share"
+                }
+              ],
+              :security_services_detail => [
+                {
+                  "status"      => "new",
+                  "domain"      => "",
+                  "project_id"  => "16e1ab15c35a457e9c2b2aa189f544e1",
+                  "name"        => "SecServ1",
+                  "created_at"  => "2015-09-07T12:19:10.000000",
+                  "updated_at"  => "",
+                  "server"      => "",
+                  "dns_ip"      => "10.0.0.0/24",
+                  "user"        => "demo",
+                  "password"    => "supersecret",
+                  "type"        => "kerberos",
+                  "id"          => "3c829734-0679-4c17-9637-801da48c0d5f",
+                  "description" => "Creating my first Security Service"
+                }
+              ],
+              :security_services        => [
+                {
+                  "status" => "new",
+                  "type"   => "ldap",
+                  "id"     => "5a1d3a12-34a7-4087-8983-50e9ed03509a",
+                  "name"   => "SecServ2"
+                }
+              ],
+              :availability_zones => [
+                  {
+                      "name"        => "nova",
+                      "created_at"  => "2015-09-18T09:50:55.000000",
+                      "updated_at"  => nil,
+                      "id"          => "388c983d-258e-4a0e-b1ba-10da37d766db"
+                  }
+              ],
+              :snapshots_detail      => [
+                {
+                  "status"      => "available",
+                  "share_id"    => "d94a8548-2079-4be0-b21c-0a887acd31ca",
+                  "name"        => "snapshot_My_share",
+                  "links"       => [
+                    {
+                      "href" => "http://172.18.198.54:8786/v1/16e1ab15c35a457e9c2b2aa189f544e1/snapshots/086a1aa6-c425-4ecd-9612-391a3b1b9375",
+                      "rel"  => "self"
+                    },
+                    {
+                      "href" => "http://172.18.198.54:8786/16e1ab15c35a457e9c2b2aa189f544e1/snapshots/086a1aa6-c425-4ecd-9612-391a3b1b9375",
+                      "rel"  => "bookmark"
+                    }
+                  ],
+                  "created_at"  => "2015-09-07T11:55:09.000000",
+                  "description" => "Here is a snapshot of share My_share",
+                  "share_proto" => "NFS",
+                  "share_size"  => 1,
+                  "id"          => "086a1aa6-c425-4ecd-9612-391a3b1b9375",
+                  "size"        => 1
+                }
+              ],
+              :export_locations         => [
+                {
+                  "path"              => "10.254.0.3:/shares/share-e1c2d35e-fe67-4028-ad7a-45f668732b1d",
+                  "share_instance_id" => "e1c2d35e-fe67-4028-ad7a-45f668732b1d",
+                  "is_admin_only"     => false,
+                  "id"                => "b6bd76ce-12a2-42a9-a30a-8a43b503867d",
+                  "preferred"         => false
+                },
+                {
+                  "path"              => "10.0.0.3:/shares/share-e1c2d35e-fe67-4028-ad7a-45f668732b1d",
+                  "share_instance_id" => "e1c2d35e-fe67-4028-ad7a-45f668732b1d",
+                  "is_admin_only"     => true,
+                  "id"                => "6921e862-88bc-49a5-a2df-efeed9acd583",
+                  "preferred"         => false
+                }
+              ],
+              :access_rules             => [
+                {
+                  "share_id"     => "406ea93b-32e9-4907-a117-148b3945749f",
+                  "created_at"   => "2015-09-07T09:14:48.000000",
+                  "updated_at"   => '',
+                  "access_type"  => "ip",
+                  "access_to"    => "0.0.0.0/0",
+                  "access_level" => "rw",
+                  "access_key"   => '',
+                  "id"           => "a25b2df3-90bd-4add-afa6-5f0dbbd50452"
+                }
+              ],
+              :quota                    => {
+                "gigabytes"          => 1000,
+                "shares"             => 50,
+                "snapshot_gigabytes" => 1000,
+                "snapshots"          => 50,
+                "share_networks"     => 10,
+                "id"                 => "16e1ab15c35a457e9c2b2aa189f544e1"
+              }
+            }
+          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 = 8786
+          management_url.path = '/v2'
+          @huaweicloud_management_url = management_url.to_s
+
+          @data ||= {:users => {}}
+          unless @data[:users].detect { |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
+      # rubocop:enable LineLength, Metrics/MethodLength, Metrics/ClassLength, Metrics/AbcSize
+
+      class Real
+        include Fog::HuaweiCloud::Core
+
+        def self.not_found_class
+          Fog::SharedFileSystem::HuaweiCloud::NotFound
+        end
+
+        def initialize(options = {})
+          @supported_versions     = SUPPORTED_VERSIONS
+          @supported_microversion = SUPPORTED_MICROVERSION
+          @fixed_microversion     = options[:huaweicloud_shared_file_system_microversion]
+          @microversion_key       = 'X-Openstack-Manila-Api-Version'.freeze
+
+          initialize_identity options
+
+          @huaweicloud_service_type  = options[:huaweicloud_service_type] || ['sharev2']
+          @huaweicloud_service_name  = options[:huaweicloud_service_name]
+          @connection_options      = options[:connection_options] || {}
+
+          authenticate
+          set_api_path
+          set_microversion
+
+          @persistent = options[:persistent] || false
+          @connection = Fog::Core::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def set_api_path
+          unless @path.match(@supported_versions)
+            @path = Fog::HuaweiCloud.get_supported_version_path(@supported_versions,
+                                                              @huaweicloud_management_uri,
+                                                              @auth_token,
+                                                              @connection_options)
+          end
+        end
+
+        def action_prefix
+          microversion_newer_than?('2.6') ? '' : 'os-'
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/huaweicloud/models/directories.rb

@@ -0,0 +1,36 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/storage/huaweicloud/models/directory'
+
+module Fog
+  module Storage
+    class HuaweiCloud
+      class Directories < Fog::HuaweiCloud::Collection
+        model Fog::Storage::HuaweiCloud::Directory
+
+        def all(options = {})
+          data = service.get_containers(options)
+          load_response(data)
+        end
+
+        def get(key, options = {})
+          data = service.get_container(key, options)
+          directory = new(:key => key)
+          for key, value in data.headers
+            if ['X-Container-Bytes-Used', 'X-Container-Object-Count'].include?(key)
+              directory.merge_attributes(key => value)
+            end
+          end
+          directory.files.merge_attributes(options)
+          directory.files.instance_variable_set(:@loaded, true)
+
+          data.body.each do |file|
+            directory.files << directory.files.new(file)
+          end
+          directory
+        rescue Fog::Storage::HuaweiCloud::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/huaweicloud/models/directory.rb

@@ -0,0 +1,50 @@
+require 'fog/huaweicloud/models/model'
+require 'fog/storage/huaweicloud/models/files'
+
+module Fog
+  module Storage
+    class HuaweiCloud
+      class Directory < Fog::HuaweiCloud::Model
+        identity  :key, :aliases => 'name'
+
+        attribute :bytes, :aliases => 'X-Container-Bytes-Used'
+        attribute :count, :aliases => 'X-Container-Object-Count'
+
+        attr_writer :public
+
+        def destroy
+          requires :key
+          service.delete_container(key)
+          true
+        rescue Excon::Errors::NotFound
+          false
+        end
+
+        def files
+          @files ||= begin
+            Fog::Storage::HuaweiCloud::Files.new(
+              :directory => self,
+              :service   => service
+            )
+          end
+        end
+
+        def public_url
+          requires :key
+
+          @public_url ||= begin
+            service.public_url(key)
+          rescue Fog::Storage::HuaweiCloud::NotFound => err
+            nil
+          end
+        end
+
+        def save
+          requires :key
+          service.put_container(key, :public => @public)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/huaweicloud/models/file.rb

@@ -0,0 +1,195 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module Storage
+    class HuaweiCloud
+      class File < Fog::HuaweiCloud::Model
+        identity  :key,             :aliases => 'name'
+
+        attribute :access_control_allow_origin, :aliases => ['Access-Control-Allow-Origin']
+        attribute :cache_control,   :aliases => ['Cache-Control']
+        attribute :content_length,  :aliases => ['bytes', 'Content-Length'], :type => :integer
+        attribute :content_type,    :aliases => ['content_type', 'Content-Type']
+        attribute :content_disposition, :aliases => ['content_disposition', 'Content-Disposition']
+        attribute :etag,            :aliases => ['hash', 'Etag']
+        attribute :last_modified,   :aliases => ['last_modified', 'Last-Modified'], :type => :time
+        attribute :metadata
+        attribute :origin,          :aliases => ['Origin']
+        # @!attribute [rw] delete_at
+        # A Unix Epoch Timestamp, in integer form, representing the time when this object will be automatically deleted.
+        # @return [Integer] the unix epoch timestamp of when this object will be automatically deleted
+        # @see http://docs.openstack.org/developer/swift/overview_expiring_objects.html
+        attribute :delete_at, :aliases => ['X-Delete-At']
+
+        # @!attribute [rw] delete_after
+        # A number of seconds representing how long from now this object will be automatically deleted.
+        # @return [Integer] the number of seconds until this object will be automatically deleted
+        # @see http://docs.openstack.org/developer/swift/overview_expiring_objects.html
+        attribute :delete_after, :aliases => ['X-Delete-After']
+
+        # @!attribute [rw] content_encoding
+        # When you create an object or update its metadata, you can optionally set the Content-Encoding metadata.
+        # This metadata enables you to indicate that the object content is compressed without losing the identity of the
+        # underlying media type (Content-Type) of the file, such as a video.
+        # @see http://docs.openstack.org/developer/swift/api/use_content-encoding_metadata.html#use-content-encoding-metadata
+        attribute :content_encoding, :aliases => 'Content-Encoding'
+
+        def initialize(new_attributes = {})
+          super
+          @dirty = if last_modified then false else true end
+        end
+
+        def body
+          attributes[:body] ||= if last_modified
+                                  collection.get(identity).try(:body) || ''
+                                else
+                                  ''
+                                end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+          @dirty = true
+        end
+
+        attr_reader :directory
+
+        def copy(target_directory_key, target_file_key, options = {})
+          requires :directory, :key
+          options['Content-Type'] ||= content_type if content_type
+          options['Access-Control-Allow-Origin'] ||= access_control_allow_origin if access_control_allow_origin
+          options['Origin'] ||= origin if origin
+          options['Content-Encoding'] ||= content_encoding if content_encoding
+          service.copy_object(directory.key, key, target_directory_key, target_file_key, options)
+          target_directory = service.directories.new(:key => target_directory_key)
+          target_directory.files.get(target_file_key)
+        end
+
+        def destroy
+          requires :directory, :key
+          service.delete_object(directory.key, key)
+          @dirty = true
+          true
+        end
+
+        def metadata
+          attributes[:metadata] ||= headers_to_metadata
+        end
+
+        def owner=(new_owner)
+          if new_owner
+            attributes[:owner] = {
+              :display_name => new_owner['DisplayName'],
+              :id           => new_owner['ID']
+            }
+          end
+        end
+
+        def public=(new_public)
+          new_public
+        end
+
+        # Get a url for file.
+        #
+        #     required attributes: key
+        #
+        # @param expires [String] number of seconds (since 1970-01-01 00:00) before url expires
+        # @param options [Hash]
+        # @return [String] url
+        #
+        def url(expires, options = {})
+          requires :directory, :key
+          service.create_temp_url(directory.key, key, expires, "GET", options)
+        end
+
+        def public_url
+          requires :key
+          collection.get_url(key)
+        end
+
+        def save(options = {})
+          requires :directory, :key
+          options['Cache-Control'] = cache_control if cache_control
+          options['Content-Type'] = content_type if content_type
+          options['Content-Disposition'] = content_disposition if content_disposition
+          options['Access-Control-Allow-Origin'] = access_control_allow_origin if access_control_allow_origin
+          options['Origin'] = origin if origin
+          options['X-Delete-At'] = delete_at if delete_at
+          options['X-Delete-After'] = delete_after if delete_after
+          options['Content-Encoding'] = content_encoding if content_encoding
+          options.merge!(metadata_to_headers)
+
+          if not @dirty
+            data = service.post_object(directory.key, key, options)
+          else
+            requires :body
+            data = service.put_object(directory.key, key, body, options)
+            self.content_length = Fog::Storage.get_body_size(body)
+            self.content_type ||= Fog::Storage.get_content_type(body)
+          end
+          update_attributes_from(data)
+          refresh_metadata
+
+          true
+        end
+
+        private
+
+        attr_writer :directory
+
+        def refresh_metadata
+          metadata.reject! { |_k, v| v.nil? }
+        end
+
+        def headers_to_metadata
+          key_map = key_mapping
+          Hash[metadata_attributes.map { |k, v| [key_map[k], v] }]
+        end
+
+        def key_mapping
+          key_map = metadata_attributes
+          key_map.each_pair { |k, _v| key_map[k] = header_to_key(k) }
+        end
+
+        def header_to_key(opt)
+          opt.gsub(metadata_prefix, '').split('-').map { |k| k[0, 1].downcase + k[1..-1] }.join('_').to_sym
+        end
+
+        def metadata_to_headers
+          header_map = header_mapping
+          Hash[metadata.map { |k, v| [header_map[k], v] }]
+        end
+
+        def header_mapping
+          header_map = metadata.dup
+          header_map.each_pair { |k, _v| header_map[k] = key_to_header(k) }
+        end
+
+        def key_to_header(key)
+          metadata_prefix + key.to_s.split(/[-_]/).map(&:capitalize).join('-')
+        end
+
+        def metadata_attributes
+          if last_modified
+            headers = service.head_object(directory.key, key).headers
+            headers.reject! { |k, _v| !metadata_attribute?(k) }
+          else
+            {}
+          end
+        end
+
+        def metadata_attribute?(key)
+          key.to_s =~ /^#{metadata_prefix}/
+        end
+
+        def metadata_prefix
+          "X-Object-Meta-"
+        end
+
+        def update_attributes_from(data)
+          merge_attributes(data.headers.reject { |key, _value| ['Content-Length', 'Content-Type'].include?(key) })
+        end
+      end
+    end
+  end
+end