fog-huaweicloud 0.0.1 → 0.0.2

data/lib/fog/orchestration/util/recursive_hot_file_loader.rb

@@ -0,0 +1,220 @@
+require 'set'
+require 'yaml'
+require 'open-uri'
+require 'objspace'
+require 'fog/core'
+
+module Fog
+  module Orchestration
+    module Util
+      #
+      # Resolve get_file resources found in a HOT template populating
+      #  a files Hash conforming to Heat Specs
+      #  https://developer.openstack.org/api-ref/orchestration/v1/index.html?expanded=create-stack-detail#stacks
+      #
+      # Files present in :files are not processed further. The others
+      #   are added to the Hash. This behavior is the same implemented in openstack-infra/shade
+      #   see https://github.com/openstack-infra/shade/blob/1d16f64fbf376a956cafed1b3edd8e51ccc16f2c/shade/openstackcloud.py#L1200
+      #
+      # This implementation just process nested templates but not resource
+      #  registries.
+      class RecursiveHotFileLoader
+        attr_reader :files
+        attr_reader :template
+
+        def initialize(template, files = nil)
+          # According to https://github.com/fog/fog-openstack/blame/master/docs/orchestration.md#L122
+          #  templates can be either String or Hash.
+          #  If it's an Hash, we deep_copy it so the passed argument
+          #  is not modified by get_file_contents.
+          template = deep_copy(template)
+          @visited = Set.new
+          @files = files || {}
+          @template = get_template_contents(template)
+        end
+
+        # Return string
+        def url_join(prefix, suffix)
+          if prefix
+            # URI.join replaces prefix parts before a
+            #  trailing slash. See https://docs.ruby-lang.org/en/2.3.0/URI.html.
+            prefix += '/' unless prefix.to_s.end_with?("/")
+            suffix = URI.join(prefix, suffix)
+            # Force URI to use traditional file scheme representation.
+            suffix.host = "" if suffix.scheme == "file"
+          end
+          suffix.to_s
+        end
+
+        # Retrieve a template content.
+        #
+        # @param template_file can be either:
+        #          - a raw_template string
+        #          - an URI string
+        #          - an Hash containing the parsed template.
+        #
+        # XXX: we could use named parameters
+        # and better mimic heatclient implementation.
+        def get_template_contents(template_file)
+          Fog::Logger.debug("get_template_contents [#{template_file}]")
+
+          raise "template_file should be Hash or String, not #{template_file.class.name}" unless
+            template_file.kind_of?(String) || template_file.kind_of?(Hash)
+
+          local_base_url = url_join("file:/", File.absolute_path(Dir.pwd))
+
+          if template_file.kind_of?(Hash)
+            template_base_url = local_base_url
+            template = template_file
+          elsif template_is_raw?(template_file)
+            template_base_url = local_base_url
+            template = YAML.safe_load(template_file, [Date])
+          elsif template_is_url?(template_file)
+            template_file = normalise_file_path_to_url(template_file)
+            template_base_url = base_url_for_url(template_file)
+            raw_template = read_uri(template_file)
+            template = YAML.safe_load(raw_template, [Date])
+
+            Fog::Logger.debug("Template visited: #{@visited}")
+            @visited.add(template_file)
+          else
+            raise "template_file is not a string of the expected form"
+          end
+
+          get_file_contents(template, template_base_url)
+
+          template
+        end
+
+        # Traverse the template tree looking for get_file and type
+        #   and populating the @files attribute with their content.
+        #   Resource referenced by get_file and type are eventually
+        #   replaced with their absolute URI as done in heatclient
+        #   and shade.
+        #
+        def get_file_contents(from_data, base_url)
+          Fog::Logger.debug("Processing #{from_data} with base_url #{base_url}")
+
+          # Recursively traverse the tree
+          #   if recurse_data is Array or Hash
+          recurse_data = from_data.kind_of?(Hash) ? from_data.values : from_data
+          recurse_data.each { |value| get_file_contents(value, base_url) } if recurse_data.kind_of?(Array)
+
+          # I'm on a Hash, process it.
+          return unless from_data.kind_of?(Hash)
+          from_data.each do |key, value|
+            next if ignore_if(key, value)
+
+            # Resolve relative paths.
+            str_url = url_join(base_url, value)
+
+            next if @files.key?(str_url)
+
+            file_content = read_uri(str_url)
+
+            # get_file should not recurse hot templates.
+            if key == "type" && template_is_raw?(file_content) && !@visited.include?(str_url)
+              template = get_template_contents(str_url)
+              file_content = YAML.dump(template)
+            end
+
+            @files[str_url] = file_content
+            # replace the data value with the normalised absolute URL as required
+            #  by https://docs.openstack.org/heat/pike/template_guide/hot_spec.html#get-file
+            from_data[key] = str_url
+          end
+        end
+
+        private
+
+        # Retrive the content of a local or remote file.
+        #
+        # @param A local or remote uri.
+        #
+        # @raise ArgumentError if it's not a valid uri
+        #
+        # Protect open-uri from malign arguments like
+        #  - "|ls"
+        #  - multiline strings
+        def read_uri(uri_or_filename)
+          remote_schemes = %w[http https ftp]
+          Fog::Logger.debug("Opening #{uri_or_filename}")
+
+          begin
+            # Validate URI to protect from open-uri attacks.
+            url = URI(uri_or_filename)
+
+            if remote_schemes.include?(url.scheme)
+              # Remote schemes must contain an host.
+              raise ArgumentError if url.host.nil?
+
+              # Encode URI with spaces.
+              uri_or_filename = uri_or_filename.gsub(/ /, "%20")
+            end
+          rescue URI::InvalidURIError
+            raise ArgumentError, "Not a valid URI: #{uri_or_filename}"
+          end
+
+          # TODO: A future revision may implement a retry.
+          content = ''
+          # open-uri doesn't open "file:///" uris.
+          uri_or_filename = uri_or_filename.sub(/^file:/, "")
+
+          open(uri_or_filename) { |f| content = f.read }
+          content
+        end
+
+        # Return true if the file is an heat template, false otherwise.
+        def template_is_raw?(content)
+          htv = content.strip.index("heat_template_version")
+          # Tolerate some leading character in case of a json template.
+          htv && htv < 5
+        end
+
+        # Return true if it's an URI, false otherwise.
+        def template_is_url?(path)
+          normalise_file_path_to_url(path)
+          true
+        rescue ArgumentError, URI::InvalidURIError
+          false
+        end
+
+        # Return true if I should I process this this file.
+        #
+        # @param [String] An heat template key
+        #
+        def ignore_if(key, value)
+          return true if key != 'get_file' && key != 'type'
+
+          return true unless value.kind_of?(String)
+
+          return true if key == 'type' &&
+                         !value.end_with?('.yaml', '.template')
+
+          false
+        end
+
+        # Returns the string baseurl of the given url.
+        def base_url_for_url(url)
+          parsed = URI(url)
+          parsed_dir = File.dirname(parsed.path)
+          url_join(parsed, parsed_dir)
+        end
+
+        def normalise_file_path_to_url(path)
+          # Nothing to do on URIs
+          return path if URI(path).scheme
+
+          path = File.absolute_path(path)
+          url_join('file:/', path)
+        end
+
+        def deep_copy(item)
+          return item if item.kind_of?(String)
+
+          YAML.safe_load(YAML.dump(item), [Date])
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/models/plan.rb

@@ -0,0 +1,69 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Plan < Fog::HuaweiCloud::Model
+        MASTER_TEMPLATE_NAME = 'plan.yaml'.freeze
+        ENVIRONMENT_NAME = 'environment.yaml'.freeze
+
+        identity :uuid
+
+        attribute :description
+        attribute :name
+        attribute :uuid
+        attribute :created_at
+        attribute :updated_at
+        attribute :parameters
+
+        def templates
+          service.get_plan_templates(uuid).body
+        end
+
+        def master_template
+          templates[MASTER_TEMPLATE_NAME]
+        end
+
+        def environment
+          templates[ENVIRONMENT_NAME]
+        end
+
+        def provider_resource_templates
+          templates.select do |key, _template|
+            ![MASTER_TEMPLATE_NAME, ENVIRONMENT_NAME].include?(key)
+          end
+        end
+
+        def patch(parameters)
+          service.patch_plan(uuid, parameters[:parameters]).body
+        end
+
+        def add_role(role_uuid)
+          service.add_role_to_plan(uuid, role_uuid)
+        end
+
+        def remove_role(role_uuid)
+          service.remove_role_from_plan(uuid, role_uuid)
+        end
+
+        def destroy
+          requires :uuid
+          service.delete_plan(uuid)
+          true
+        end
+
+        def create
+          requires :name
+          merge_attributes(service.create_plan(attributes).body)
+          self
+        end
+
+        def update(parameters = nil)
+          requires :uuid
+          merge_attributes(service.patch_plan(uuid, parameters).body)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/models/plans.rb

@@ -0,0 +1,31 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/planning/huaweicloud/models/plan'
+
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Plans < Fog::HuaweiCloud::Collection
+        model Fog::HuaweiCloud::Planning::Plan
+
+        def all(options = {})
+          load_response(service.list_plans(options))
+        end
+
+        def find_by_uuid(plan_uuid)
+          new(service.get_plan(plan_uuid).body)
+        end
+        alias get find_by_uuid
+
+        def method_missing(method_sym, *arguments, &block)
+          if method_sym.to_s =~ /^find_by_(.*)$/
+            all.find do |plan|
+              plan.send($1) == arguments.first
+            end
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/models/role.rb

@@ -0,0 +1,23 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Role < Fog::HuaweiCloud::Model
+        identity :uuid
+
+        attribute :description
+        attribute :name
+        attribute :uuid
+
+        def add_to_plan(plan_uuid)
+          service.add_role_to_plan(plan_uuid, uuid)
+        end
+
+        def remove_from_plan(plan_uuid)
+          service.remove_role_from_plan(plan_uuid, uuid)
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/models/roles.rb

@@ -0,0 +1,16 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/planning/huaweicloud/models/role'
+
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Roles < Fog::HuaweiCloud::Collection
+        model Fog::HuaweiCloud::Planning::Role
+
+        def all(options = {})
+          load_response(service.list_roles(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/requests/add_role_to_plan.rb

@@ -0,0 +1,40 @@
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Real
+        def add_role_to_plan(plan_uuid, role_uuid)
+          request(
+            :expects => [201],
+            :method  => 'POST',
+            :path    => "plans/#{plan_uuid}/roles",
+            :body    => Fog::JSON.encode('uuid' => role_uuid)
+          )
+        end
+      end
+
+      class Mock
+        def add_role_to_plan(_plan_uuid, _role_uuid)
+          response = Excon::Response.new
+          response.status = 201
+          response.body = {
+            "created_at"  => "2014-09-26T20:23:14.222815",
+            "description" => "Development testing cloud",
+            "name"        => "dev-cloud",
+            "parameters"  => [],
+            "roles"       => [
+              {
+                "description" => "HuaweiCloud hypervisor node. Can be wrapped in a ResourceGroup for scaling.\n",
+                "name"        => "compute",
+                "uuid"        => "f72c0656-5696-4c66-81a5-d6d88a48e385",
+                "version"     => 1
+              }
+            ],
+            "updated_at"  => nil,
+            "uuid"        => "53268a27-afc8-4b21-839f-90227dd7a001"
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/requests/create_plan.rb

@@ -0,0 +1,33 @@
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Real
+        def create_plan(parameters)
+          request(
+            :expects => [201],
+            :method  => 'POST',
+            :path    => "plans",
+            :body    => Fog::JSON.encode(parameters)
+          )
+        end
+      end
+
+      class Mock
+        def create_plan(_parameters)
+          response = Excon::Response.new
+          response.status = 201
+          response.body = {
+            "created_at"  => "2014-09-26T20:23:14.222815",
+            "description" => "Development testing cloud",
+            "name"        => "dev-cloud",
+            "parameters"  => [],
+            "roles"       => [],
+            "updated_at"  => nil,
+            "uuid"        => "53268a27-afc8-4b21-839f-90227dd7a001"
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/requests/delete_plan.rb

@@ -0,0 +1,23 @@
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Real
+        def delete_plan(plan_uuid)
+          request(
+            :expects => [204],
+            :method  => 'DELETE',
+            :path    => "plans/#{plan_uuid}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_plan(_plan_uuid)
+          response = Excon::Response.new
+          response.status = 204
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/requests/get_plan.rb

@@ -0,0 +1,58 @@
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Real
+        def get_plan(plan_uuid)
+          request(
+            :expects => [200, 204],
+            :method  => 'GET',
+            :path    => "plans/#{plan_uuid}"
+          )
+        end
+      end
+
+      class Mock
+        def get_plan(_parameters = nil)
+          response = Excon::Response.new
+          response.status = [200, 204][rand(2)]
+          response.body = {
+            "created_at"  => "2014-09-26T20:23:14.222815",
+            "description" => "Development testing cloud",
+            "name"        => "dev-cloud",
+            "parameters"  =>
+                             [
+                               {
+                                 "default"     => "guest",
+                                 "description" => "The password for RabbitMQ",
+                                 "hidden"      => true,
+                                 "label"       => nil,
+                                 "name"        => "compute-1 => =>RabbitPassword",
+                                 "value"       => "secret-password"
+                               },
+                               {
+                                 "default"     => "default",
+                                 "description" => "description",
+                                 "hidden"      => true,
+                                 "label"       => nil,
+                                 "name"        => "name",
+                                 "value"       => "value"
+                               },
+                             ],
+            "roles"       =>
+                             [
+                               {
+                                 "description" => "HuaweiCloud hypervisor node. Can be wrapped in a ResourceGroup for scaling.\n",
+                                 "name"        => "compute",
+                                 "uuid"        => "b7b1583c-5c80-481f-a25b-708ed4a39734",
+                                 "version"     => 1
+                               }
+                             ],
+            "updated_at"  => nil,
+            "uuid"        => "53268a27-afc8-4b21-839f-90227dd7a001"
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/requests/get_plan_templates.rb

@@ -0,0 +1,28 @@
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Real
+        def get_plan_templates(plan_uuid)
+          request(
+            :expects => [200, 204],
+            :method  => 'GET',
+            :path    => "plans/#{plan_uuid}/templates"
+          )
+        end
+      end
+
+      class Mock
+        def get_plan_templates(_plan_uuid)
+          response = Excon::Response.new
+          response.status = [200, 204][rand(2)]
+          response.body = {
+            "environment.yaml"        => "... content of template file ...",
+            "plan.yaml"               => "... content of template file ...",
+            "provider-compute-1.yaml" => "... content of template file ..."
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/requests/list_plans.rb

@@ -0,0 +1,61 @@
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Real
+        def list_plans(options = {})
+          request(
+            :expects => [200, 204],
+            :method  => 'GET',
+            :path    => 'plans',
+            :query   => options
+          )
+        end
+      end
+
+      class Mock
+        def list_plans(_options = {})
+          response = Excon::Response.new
+          response.status = [200, 204][rand(2)]
+          response.body = [
+            {
+              "created_at"  => "2014-09-26T20:23:14.222815",
+              "description" => "Development testing cloud",
+              "name"        => "dev-cloud",
+              "parameters"  =>
+                               [
+                                 {
+                                   "default"     => "guest",
+                                   "description" => "The password for RabbitMQ",
+                                   "hidden"      => true,
+                                   "label"       => nil,
+                                   "name"        => "compute-1 => =>RabbitPassword",
+                                   "value"       => "secret-password"
+                                 },
+                                 {
+                                   "default"     => "default",
+                                   "description" => "description",
+                                   "hidden"      => true,
+                                   "label"       => nil,
+                                   "name"        => "name",
+                                   "value"       => "value"
+                                 },
+                               ],
+              "roles"       =>
+                               [
+                                 {
+                                   "description" => "HuaweiCloud hypervisor node. Can be wrapped in a ResourceGroup for scaling.\n",
+                                   "name"        => "compute",
+                                   "uuid"        => "b7b1583c-5c80-481f-a25b-708ed4a39734",
+                                   "version"     => 1
+                                 }
+                               ],
+              "updated_at"  => nil,
+              "uuid"        => "53268a27-afc8-4b21-839f-90227dd7a001"
+            }
+          ]
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/planning/huaweicloud/requests/list_roles.rb

@@ -0,0 +1,32 @@
+module Fog
+  module HuaweiCloud
+    class Planning
+      class Real
+        def list_roles(options = {})
+          request(
+            :expects => [200, 204],
+            :method  => 'GET',
+            :path    => 'roles',
+            :query   => options
+          )
+        end
+      end
+
+      class Mock
+        def list_roles(_options = {})
+          response = Excon::Response.new
+          response.status = [200, 204][rand(2)]
+          response.body = [
+            {
+              "description" => "HuaweiCloud hypervisor node. Can be wrapped in a ResourceGroup for scaling.\n",
+              "name"        => "compute",
+              "uuid"        => "f72c0656-5696-4c66-81a5-d6d88a48e385",
+              "version"     => 1
+            }
+          ]
+          response
+        end
+      end
+    end
+  end
+end