fog-huaweicloud 0.0.1 → 0.0.2

data/lib/fog/orchestration/huaweicloud/models/stack.rb

@@ -0,0 +1,128 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Stack < Fog::HuaweiCloud::Model
+        identity :id
+
+        %w(capabilities description disable_rollback links notification_topics outputs parameters
+           stack_name stack_status stack_status_reason template_description timeout_mins parent
+           creation_time updated_time stack_user_project_id stack_owner files).each do |a|
+          attribute a.to_sym
+        end
+
+        def save(options = {})
+          if persisted?
+            stack_default_options = default_options
+            if (options.key?(:template_url))
+              stack_default_options.delete(:template)
+            end
+            service.update_stack(self, stack_default_options.merge(options)).body['stack']
+          else
+            service.stacks.create(default_options.merge(options))
+          end
+        end
+
+        # Deprecated
+        def create
+          Fog::Logger.deprecation("#create is deprecated, use #save(options) instead [light_black](#{caller.first})[/]")
+          requires :stack_name
+          service.stacks.create(default_options)
+        end
+
+        # Deprecated
+        def update
+          Fog::Logger.deprecation("#update is deprecated, use #save(options) instead [light_black](#{caller.first})[/]")
+          requires :stack_name
+          service.update_stack(self, default_options).body['stack']
+        end
+
+        def patch(options = {})
+          requires :stack_name
+          service.patch_stack(self, options).body['stack']
+        end
+
+        def delete
+          service.delete_stack(self)
+        end
+        alias destroy delete
+
+        def details
+          @details ||= service.stacks.get(stack_name, id)
+        end
+
+        def resources(options = {})
+          @resources ||= service.resources.all({:stack => self}.merge(options))
+        end
+
+        def events(options = {})
+          @events ||= service.events.all(self, options)
+        end
+
+        def template
+          @template ||= service.templates.get(self)
+        end
+
+        def abandon
+          service.abandon_stack(self)
+        end
+
+        def cancel_update
+          service.cancel_update(self)
+        end
+
+        # Deprecated
+        def template_url
+          Fog::Logger.deprecation("#template_url is deprecated, use it in options for #save(options) instead [light_black](#{caller.first})[/]")
+          @template_url
+        end
+
+        # Deprecated
+        def template_url=(url)
+          Fog::Logger.deprecation("#template_url= is deprecated, use it in options for #save(options) instead [light_black](#{caller.first})[/]")
+          @template_url = url
+        end
+
+        # Deprecated
+        def template=(content)
+          Fog::Logger.deprecation("#template=(content) is deprecated, use it in options for #save(options) instead [light_black](#{caller.first})[/]")
+          @template = content
+        end
+
+        # Deprecated
+        def timeout_in_minutes
+          Fog::Logger.deprecation("#timeout_in_minutes is deprecated, set timeout_mins in options for save(options) instead [light_black](#{caller.first})[/]")
+          timeout_mins
+        end
+
+        # Deprecated
+        def timeout_in_minutes=(minutes)
+          Fog::Logger.deprecation("#timeout_in_minutes=(minutes) is deprecated, set timeout_mins in options for save(options) instead [light_black](#{caller.first})[/]")
+          timeout_mins = minutes
+        end
+
+        # build options to create or update stack
+        def default_options
+          template_content =
+            if template && template.kind_of?(Fog::Orchestration::HuaweiCloud::Template)
+              template.content
+            else
+              template
+            end
+
+          options = {
+            :stack_name       => stack_name,
+            :disable_rollback => disable_rollback,
+            :timeout_mins     => timeout_mins
+          }
+          options[:template] = template_content if template_content
+          options[:template_url] = @template_url if @template_url
+          options[:files] = @files if @files
+          options
+        end
+        private :default_options
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/models/stacks.rb

@@ -0,0 +1,64 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/orchestration/huaweicloud/models/stack'
+
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Stacks < Fog::HuaweiCloud::Collection
+        model Fog::Orchestration::HuaweiCloud::Stack
+
+        def all(options = {})
+          # TODO(lsmola) we can uncomment this when https://bugs.launchpad.net/heat/+bug/1468318 is fixed, till then
+          # we will use non detailed list
+          # data = service.list_stack_data_detailed(options).body['stacks']
+          data = service.list_stack_data(options)
+          load_response(data, 'stacks')
+        end
+
+        def summary(options = {})
+          data = service.list_stack_data(options)
+          load_response(data, 'stacks')
+        end
+
+        # Deprecated
+        def find_by_id(id)
+          Fog::Logger.deprecation("#find_by_id(id) is deprecated, use #get(name, id) instead [light_black](#{caller.first})[/]")
+          find { |stack| stack.id == id }
+        end
+
+        def get(arg1, arg2 = nil)
+          if arg2.nil?
+            # Deprecated: get(id)
+            Fog::Logger.deprecation("#get(id) is deprecated, use #get(name, id) instead [light_black](#{caller.first})[/]")
+            return find_by_id(arg1)
+          end
+
+          # Normal use: get(name, id)
+          name = arg1
+          id = arg2
+          data = service.show_stack_details(name, id).body['stack']
+          new(data)
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+
+        def adopt(options = {})
+          service.create_stack(options)
+        end
+
+        def create(options = {})
+          service.create_stack(options).body['stack']
+        end
+
+        def preview(options = {})
+          data = service.preview_stack(options).body['stack']
+          new(data)
+        end
+
+        def build_info
+          service.build_info.body
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/models/template.rb

@@ -0,0 +1,13 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Template < Fog::HuaweiCloud::Model
+        %w(format description template_version parameters resources content).each do |a|
+          attribute a.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/models/templates.rb

@@ -0,0 +1,45 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/orchestration/huaweicloud/models/template'
+
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Templates < Fog::HuaweiCloud::Collection
+        model Fog::Orchestration::HuaweiCloud::Template
+
+        def get(obj)
+          data = if obj.kind_of?(Stack)
+                   service.get_stack_template(obj).body
+                 else
+                   service.show_resource_template(obj.resource_name).body
+                 end
+
+          if data.key?('AWSTemplateFormatVersion')
+            data['content'] = data.to_json
+            data['format'] = 'CFN'
+            data['template_version'] = data.delete('AWSTemplateFormatVersion')
+            data['description'] = data.delete('Description')
+            data['parameter'] = data.delete('Parameters')
+            data['resources'] = data.delete('Resources')
+          else
+            data['content'] = data.to_yaml
+            data['format'] = 'HOT'
+            data['template_version'] = data.delete('heat_template_version')
+          end
+
+          new(data)
+        rescue Fog::Orchestration::HuaweiCloud::NotFound
+          nil
+        end
+
+        def validate(options = {})
+          data = service.validate_template(options).body
+          temp = new
+          temp.parameters  = data['Parameters']
+          temp.description = data['Description']
+          temp
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/abandon_stack.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        def abandon_stack(stack)
+          request(
+            :expects => [200],
+            :method  => 'DELETE',
+            :path    => "stacks/#{stack.stack_name}/#{stack.id}/abandon"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/build_info.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        def build_info
+          request(
+            :expects => [200],
+            :method  => 'GET',
+            :path    => 'build_info'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/cancel_update.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        def cancel_update(stack)
+          request(
+            :expects => 200,
+            :method  => 'POST',
+            :path    => "stacks/#{stack.stack_name}/#{stack.id}/actions",
+            :body    => Fog::JSON.encode('cancel_update' => nil)
+          )
+        end
+      end
+
+      class Mock
+        def cancel_update(_)
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/create_stack.rb

@@ -0,0 +1,99 @@
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        # Create a stack.
+        #
+        #
+        # * options [Hash]:
+        #   * :stack_name [String] Name of the stack to create.
+        #   * :template [String] Structure containing the template body.
+        #   or (one of the two Template parameters is required)
+        #   * :template_url [String] URL of file containing the template body.
+        #   * :files [Hash] Hash with files resources.
+        #   * :disable_rollback [Boolean] Controls rollback on stack creation failure, defaults to false.
+        #   * :parameters [Hash] Hash of providers to supply to template
+        #   * :timeout_mins [Integer] Minutes to wait before status is set to CREATE_FAILED
+        #
+        # @see http://developer.openstack.org/api-ref-orchestration-v1.html
+
+        def create_stack(arg1, arg2 = nil)
+          if arg1.kind_of?(Hash)
+            # Normal use: create_stack(options)
+            options = arg1
+          else
+            # Deprecated: create_stack(stack_name, options = {})
+            Fog::Logger.deprecation("#create_stack(stack_name, options) is deprecated, use #create_stack(options) instead [light_black](#{caller.first})[/]")
+            options = {
+              :stack_name => arg1
+            }.merge(arg2.nil? ? {} : arg2)
+          end
+
+          # Templates should always:
+          #  - be strings
+          #  - contain URI references instead of relative paths.
+          # Passing :template_url may not work well with `get_file` and remote `type`:
+          #  the python client implementation in shade retrieves from :template_uri
+          #  and replaces it with :template.
+          #  see https://github.com/openstack-infra/shade/blob/master/shade/openstackcloud.py#L1201
+          #  see https://developer.openstack.org/api-ref/orchestration/v1/index.html#create-stack
+          file_resolver = Util::RecursiveHotFileLoader.new(options[:template] || options[:template_url], options[:files])
+          options[:template] = file_resolver.template
+          options[:files] = file_resolver.files unless file_resolver.files.empty?
+
+          request(
+            :expects => 201,
+            :path    => 'stacks',
+            :method  => 'POST',
+            :body    => Fog::JSON.encode(options)
+          )
+        end
+      end
+
+      class Mock
+        def create_stack(arg1, arg2 = nil)
+          if arg1.kind_of?(Hash)
+            # Normal use: create_stack(options)
+            options = arg1
+          else
+            # Deprecated: create_stack(stack_name, options = {})
+            Fog::Logger.deprecation("#create_stack(stack_name, options) is deprecated, use #create_stack(options) instead [light_black](#{caller.first})[/]")
+            options = {
+              :stack_name => arg1
+            }.merge(arg2.nil? ? {} : arg2)
+          end
+
+          stack_id = Fog::Mock.random_hex(32)
+          stack = data[:stacks][stack_id] = {
+            'id'                  => stack_id,
+            'stack_name'          => options[:stack_name],
+            'links'               => [],
+            'description'         => options[:description],
+            'stack_status'        => 'CREATE_COMPLETE',
+            'stack_status_reason' => 'Stack successfully created',
+            'creation_time'       => Time.now,
+            'updated_time'        => Time.now
+          }
+
+          response = Excon::Response.new
+          response.status = 201
+          response.body = {
+            'id'    => stack_id,
+            'links' => [{"href" => "http://localhost:8004/v1/fake_tenant_id/stacks/#{options[:stack_name]}/#{stack_id}", "rel" => "self"}]
+          }
+
+          if options.key?(:files)
+            response.body['files'] = {'foo.sh' => 'hello'}
+          end
+
+          if options.key?(:template) || options.key?(:template_url)
+            file_resolver = Util::RecursiveHotFileLoader.new(options[:template] || options[:template_url], options[:files])
+            response.body['files'] = file_resolver.files unless file_resolver.files.empty?
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/delete_stack.rb

@@ -0,0 +1,58 @@
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        # Delete a stack.
+        #
+        # @param [Stack] Stack to be deleted
+        #
+        # @return [Excon::Response]
+        #
+        # @see http://developer.openstack.org/api-ref-orchestration-v1.html
+
+        def delete_stack(arg1, arg2 = nil)
+          if arg1.kind_of?(Stack)
+            # Normal use: delete_stack(stack)
+            stack = arg1
+            stack_name = stack.stack_name
+            stack_id = stack.id
+          else
+            # Deprecated: delete_stack(stack_name, stack_id)
+            Fog::Logger.deprecation("#delete_stack(stack_name, stack_id) is deprecated, use #delete_stack(stack) instead [light_black](#{caller.first})[/]")
+            stack_name = arg1
+            stack_id = arg2
+          end
+
+          request(
+            :expects => 204,
+            :path    => "stacks/#{stack_name}/#{stack_id}",
+            :method  => 'DELETE'
+          )
+        end
+      end
+
+      class Mock
+        def delete_stack(arg1, arg2 = nil)
+          if arg1.kind_of?(Stack)
+            # Normal use: delete_stack(stack)
+            stack = arg1
+            stack_name = stack.stack_name
+            stack_id = stack.id
+          else
+            # Deprecated: delete_stack(stack_name, stack_id)
+            Fog::Logger.deprecation("#delete_stack(stack_name, stack_id) is deprecated, use #delete_stack(stack) instead [light_black](#{caller.first})[/]")
+            stack_name = arg1
+            stack_id = arg2
+          end
+
+          data[:stacks].delete(stack_id)
+
+          response = Excon::Response.new
+          response.status = 204
+          response.body = {}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/get_stack_template.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        def get_stack_template(stack)
+          request(
+            :method  => 'GET',
+            :path    => "stacks/#{stack.stack_name}/#{stack.id}/template",
+            :expects => 200
+          )
+        end
+      end
+
+      class Mock
+        def get_stack_template(stack)
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/list_events.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        def list_events(options = {})
+          if !options.key?(:stack) && !(options.key?(:stack_name) && options.key?(:stack_id))
+            raise(ArgumentError, "Missing required options keys: :stack or :stack_name and :stack_id, while calling "\
+                                 " .list_events(options)")
+          end
+
+          stack        = options.delete(:stack)
+          stack_name   = options.delete(:stack_name)
+          stack_name ||= stack.stack_name if stack && stack.respond_to?(:stack_name)
+          stack_id     = options.delete(:stack_id)
+          stack_id   ||= stack.id if stack && stack.respond_to?(:id)
+
+          resource        = options.delete(:resource)
+          resource_name   = options.delete(:resource_name)
+          resource_name ||= resource.resource_name if resource && resource.respond_to?(:resource_name)
+
+          path = if resource_name
+                   "stacks/#{stack_name}/#{stack_id}/resources/#{resource_name}/events"
+                 else
+                   "stacks/#{stack_name}/#{stack_id}/events"
+                 end
+
+          request(:method  => 'GET',
+                  :path    => path,
+                  :expects => 200,
+                  :query   => options)
+        end
+      end
+
+      class Mock
+        def list_events(_options = {})
+          events = data[:events].values
+
+          Excon::Response.new(
+            :body   => {'events' => events},
+            :status => 200
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/list_resource_events.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        def list_resource_events(stack, resource, options = {})
+          Fog::Logger.deprecation('Calling HuaweiCloud[:orchestration].list_resource_events(stack, resource, options)'\
+                                  ' is deprecated, call .list_events(:stack => stack, :resource => resource) or '\
+                                  ' .list_events(:stack_name => value, :stack_id => value, :resource_name => value)'\
+                                  ' instead')
+
+          uri = "stacks/#{stack.stack_name}/#{stack.id}/resources/#{resource.resource_name}/events"
+          request(:method => 'GET', :path => uri, :expects => 200, :query => options)
+        end
+      end
+
+      class Mock
+        def list_resource_events(_stack, _resource, _options = {})
+          events = data[:events].values
+
+          Excon::Response.new(
+            :body   => {'events' => events},
+            :status => 200
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/list_resource_types.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        def list_resource_types(_options = {})
+          request(
+            :method  => 'GET',
+            :path    => "resource_types",
+            :expects => 200,
+            :query   => {}
+          )
+        end
+      end
+
+      class Mock
+        def list_resource_types
+          resources = data[:resource_types].values
+
+          Excon::Response.new(
+            :body   => {'resource_types' => resources},
+            :status => 200
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/list_resources.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        def list_resources(options = {}, options_deprecated = {})
+          if options.kind_of?(Hash)
+            if !options.key?(:stack) && !(options.key?(:stack_name) && options.key?(:stack_id))
+              raise(ArgumentError, "Missing required options keys: :stack or :stack_name and :stack_id, while calling "\
+                                   " .list_resources(options)")
+            end
+
+            stack        = options.delete(:stack)
+            stack_name   = options.delete(:stack_name)
+            stack_name ||= stack.stack_name if stack && stack.respond_to?(:stack_name)
+            stack_id     = options.delete(:stack_id)
+            stack_id   ||=  stack.id if stack && stack.respond_to?(:id)
+            path         = "stacks/#{stack_name}/#{stack_id}/resources"
+            params       = options
+          else
+            Fog::Logger.deprecation('Calling HuaweiCloud[:orchestration].list_resources(stack, options) is deprecated, '\
+                                    ' call .list_resources(:stack => stack) or '\
+                                    ' .list_resources(:stack_name => value, :stack_id => value) instead')
+            path   = "stacks/#{options.stack_name}/#{options.id}/resources"
+            params = options_deprecated
+          end
+
+          request(:method  => 'GET',
+                  :path    => path,
+                  :expects => 200,
+                  :query   => params)
+        end
+      end
+
+      class Mock
+        def list_resources(_options = {}, _options_deprecated = {})
+          resources = data[:resources].values
+
+          Excon::Response.new(
+            :body   => {'resources' => resources},
+            :status => 200
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/orchestration/huaweicloud/requests/list_stack_data.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Orchestration
+    class HuaweiCloud
+      class Real
+        def list_stack_data(options = {})
+          request(
+            :method  => 'GET',
+            :path    => 'stacks',
+            :expects => 200,
+            :query   => options
+          )
+        end
+      end
+
+      class Mock
+        def list_stack_data(_options = {})
+          stacks = data[:stacks].values
+
+          Excon::Response.new(
+            :body   => {'stacks' => stacks},
+            :status => 200
+          )
+        end
+      end
+    end
+  end
+end