knife-cloudformation 0.1.22 → 0.2.0

data/lib/knife-cloudformation/monkey_patch.rb

@@ -0,0 +1,8 @@
+require 'knife-cloudformation'
+
+module KnifeCloudformation
+  # Container for monkey patches
+  module MonkeyPatch
+    autoload :Stack, 'knife-cloudformation/monkey_patch/stack'
+  end
+end

data/lib/knife-cloudformation/monkey_patch/stack.rb

@@ -0,0 +1,195 @@
+require 'base64'
+require 'knife-cloudformation'
+
+module KnifeCloudformation
+  module MonkeyPatch
+
+    # Expand stack model functionality
+    module Stack
+
+      include KnifeCloudformation::Utils::AnimalStrings
+
+      ## Status helpers
+
+      # Check for state suffix
+      #
+      # @param args [String, Symbol] state suffix to check for (multiple allowed)
+      # @return [TrueClass, FalseClass] true if any matches found in argument list
+      def status_ends_with?(*args)
+        stat = status.to_s.downcase
+        !!args.map(&:to_s).map(&:downcase).detect do |suffix|
+          stat.end_with?(suffix)
+        end
+      end
+
+      # Check for state prefix
+      #
+      # @param args [String, Symbol] state prefix to check for (multiple allowed)
+      # @return [TrueClass, FalseClass] true if any matches found in argument list
+      def status_starts_with?(*args)
+        stat = status.to_s.downcase
+        !!args.map(&:to_s).map(&:downcase).detect do |prefix|
+          stat.start_with?(prefix)
+        end
+      end
+
+      # Check for state inclusion
+      #
+      # @param args [String, Symbol] state string to check for (multiple allowed)
+      # @return [TrueClass, FalseClass] true if any matches found in argument list
+      def status_includes?(*args)
+        stat = status.to_s.downcase
+        !!args.map(&:to_s).map(&:downcase).detect do |string|
+          stat.include?(string)
+        end
+      end
+
+      # @return [TrueClass, FalseClass] stack is in progress
+      def in_progress?
+        status_ends_with?(:in_progress)
+      end
+
+      # @return [TrueClass, FalseClass] stack is in complete state
+      def complete?
+        status_ends_with?(:complete, :failed)
+      end
+
+      # @return [TrueClass, FalseClass] stack is failed state
+      def failed?
+        status_ends_with?(:failed) ||
+          (status_includes?(:rollback) && status_ends_with?(:complete))
+      end
+
+      # @return [TrueClass, FalseClass] stack is in success state
+      def success?
+        !failed? && complete?
+      end
+
+      # @return [TrueClass, FalseClass] stack is creating
+      def creating?
+        in_progress? && status_starts_with?(:create)
+      end
+
+      # @return [TrueClass, FalseClass] stack is deleting
+      def deleting?
+        in_progress? && status_starts_with?(:delete)
+      end
+
+      # @return [TrueClass, FalseClass] stack is updating
+      def updating?
+        in_progress? && status_starts_with?(:update)
+      end
+
+      # @return [TrueClass, FalseClass] stack is rolling back
+      def rollbacking?
+        in_progress? && status_starts_with?(:rollback)
+      end
+
+      # @return [String] action currently being performed
+      def performing
+        if(in_progress?)
+          status.to_s.downcase.split('_').first.to_sym
+        end
+      end
+
+      ### Color coders
+
+      # @return [TrueClass, FalseClass] stack is in red state
+      def red?
+        failed? || deleting?
+      end
+
+      # @return [TrueClass, FalseClass] stack is in green state
+      def green?
+        success?
+      end
+
+      # @return [TrueClass, FalseClass] stack is in yellow state
+      def yellow?
+        !red? && !green?
+      end
+
+      # Provides color of stack state. Red is an error state, yellow
+      # is a warning state and green is a success state
+      #
+      # @return [Symbol] color of state (:red, :yellow, :green)
+      def color_state
+        red? ? :red : green? ? :green : :yellow
+      end
+
+      # Provides text of stack state. Danger is an error state, warning
+      # is a warning state and success is a success state
+      #
+      # @return [Symbol] color of state (:danger, :warning, :success)
+      def text_state
+        red? ? :danger : green? ? :success : :warning
+      end
+
+      # @return [String] URL safe encoded stack id
+      def encoded_id
+        Base64.urlsafe_encode64(id)
+      end
+
+      # Whole number representation of current completion
+      #
+      # @param min [Integer] lowest allowed return value (defaults 5)
+      # @return [Integer] percent complete (0..100)
+      def percent_complete(min = 5)
+        if(in_progress?)
+          total_resources = load_template.fetch('Resources', []).size
+          total_complete = resources.all.find_all do |resource|
+            resource.resource_status.downcase.end_with?('complete')
+          end.size
+          result = ((total_complete.to_f / total_resources) * 100).to_i
+          result > min.to_i ? result : min
+        else
+          100
+        end
+      end
+
+      # Apply stack outputs to current stack parameters
+      #
+      # @param remote_stack [Miasma::Orchestration::Stack]
+      # @return [self]
+      # @note setting `DisableApply` within parameter hash will
+      #   prevent parameters being overridden
+      def apply_stack(remote_stack)
+        default_key = 'Default'
+        stack_parameters = template.fetch('Parameters',
+          template.fetch('parameters', {})
+        )
+        valid_parameters = Hash[
+          stack_parameters.map do |key, val|
+            unless(val['DisableApply'])
+              [snake(key), key]
+            end
+          end.compact
+        ]
+        if(defined?(Chef::Config) && Chef::Config[:knife][:cloudformation][:ignore_parameters])
+          valid_parameters = valid_parameters.map do |snake_param, camel_param|
+            unless(Chef::Config[:knife][:cloudformation][:ignore_parameters].include?(camel_param))
+              [snake_param, camel_param]
+            end
+          end.compact
+        end
+        if(persisted?)
+          remote_stack.outputs.each do |output|
+            if(param_key = valid_parameters[snake(output.key)])
+              parameters.merge!(param_key => output.value)
+            end
+          end
+        else
+          remote_stack.outputs.each do |output|
+            if(param_key = valid_parameters[snake(output.key)])
+              stack_parameters[param_key][default_key] = output.value
+            end
+          end
+        end
+      end
+
+    end
+  end
+end
+
+# Infect miasma
+Miasma::Models::Orchestration::Stack.send(:include, KnifeCloudformation::MonkeyPatch::Stack)

data/lib/knife-cloudformation/provider.rb

@@ -0,0 +1,225 @@
+require 'chef/mash'
+require 'logger'
+require 'chef/mixin/deep_merge'
+require 'knife-cloudformation'
+
+module KnifeCloudformation
+  # Remote provider interface
+  class Provider
+
+    include KnifeCloudformation::Utils::AnimalStrings
+
+    # Minimum number of seconds to wait before re-expanding in
+    # progress stack
+    STACK_EXPAND_INTERVAL = 45
+
+    # Default interval for refreshing stack list in cache
+    STACK_LIST_INTERVAL = 120
+
+    # @return [Miasma::Models::Orchestration]
+    attr_reader :connection
+    # @return [Cache]
+    attr_reader :cache
+    # @return [Thread, NilClass] stack list updater
+    attr_accessor :updater
+    # @return [TrueClass, FalseClass] async updates
+    attr_reader :async
+    # @return [Logger, NilClass] logger in use
+    attr_reader :logger
+    # @return [Numeric] interval between stack expansions
+    attr_reader :stack_expansion_interval
+    # @return [Numeric] interval between stack list updates
+    attr_reader :stack_list_interval
+
+    # Create new instance
+    #
+    # @param args [Hash]
+    # @option args [Hash] :miasma miasma connection hash
+    # @option args [Cache] :cache
+    # @option args [TrueClass, FalseClass] :async fetch stacks async (defaults true)
+    # @option args [Logger] :logger use custom logger
+    # @option args [Numeric] :stack_expansion_interval interval to wait between stack data expands
+    # @option args [Numeric] :stack_list_interval interval to wait between stack list refresh
+    def initialize(args={})
+      unless(args[:miasma][:provider])
+        best_guess = args[:miasma].keys.group_by do |key|
+          key.to_s.split('_').first
+        end.sort do |x, y|
+          y.size <=> x.size
+        end.first
+        if(best_guess)
+          provider = best_guess.first.to_sym
+        else
+          raise ArgumentError.new 'Cannot auto determine :provider value for credentials'
+        end
+      else
+        provider = args[:miasma].delete(:provider).to_sym
+      end
+      if(provider == :aws)
+        if(args[:miasma][:region])
+          args[:miasma][:aws_region] = args[:miasma].delete(:region)
+        end
+      end
+      if(ENV['DEBUG'].to_s.downcase == 'true')
+        log_to = STDOUT
+      else
+        if(Gem.win_platform?)
+          log_to = 'NUL'
+        else
+          log_to = '/dev/null'
+        end
+      end
+      @logger = args.fetch(:logger, Logger.new(log_to))
+      @stack_expansion_interval = args.fetch(:stack_expansion_interval, STACK_EXPAND_INTERVAL)
+      @stack_list_interval = args.fetch(:stack_list_interval, STACK_LIST_INTERVAL)
+      @connection = Miasma.api(
+        :provider => provider,
+        :type => :orchestration,
+        :credentials => args[:miasma]
+      )
+      @cache = args.fetch(:cache, Cache.new(:local))
+      @async = args.fetch(:async, true)
+      @miamsa_args = args[:miasma].dup
+      cache.init(:stacks_lock, :lock, :timeout => 0.1)
+      cache.init(:stacks, :stamped)
+      cache.init(:stack_expansion_lock, :lock, :timeout => 0.1)
+      if(args.fetch(:fetch, false))
+        async ? update_stack_list! : fetch_stacks
+      end
+    end
+
+    # @return [Miasma::Orchestration::Stacks]
+    def stacks
+      connection.stacks.from_json(cached_stacks)
+    end
+
+    # @return [String] json representation of cached stacks
+    def cached_stacks
+      fetch_stacks unless @initial_fetch_complete
+      value = cache[:stacks].value
+      value ? MultiJson.dump(MultiJson.load(value).values) : '[]'
+    end
+
+    # @return [Miasma::Orchestration::Stack, NilClass]
+    def stack(stack_id)
+      stacks.get(stack_id)
+    end
+
+    # Store stack attribute changes
+    #
+    # @param stack_id [String]
+    # @param stack_attributes [Hash]
+    # @return [TrueClass]
+    def save_expanded_stack(stack_id, stack_attributes)
+      current_stacks = MultiJson.load(cached_stacks)
+      cache.locked_action(:stacks_lock) do
+        logger.info "Saving expanded stack attributes in cache (#{stack_id})"
+        current_stacks[stack_id] = stack_attributes.merge('Cached' => Time.now.to_i)
+        cache[:stacks].value = MultiJson.dump(current_stacks)
+      end
+      true
+    end
+
+    # Remove stack from the cache
+    #
+    # @param stack_id [String]
+    # @return [TrueClass, FalseClass]
+    def remove_stack(stack_id)
+      current_stacks = MultiJson.load(cached_stacks)
+      logger.info "Attempting to remove stack from internal cache (#{stack_id})"
+      cache.locked_action(:stacks_lock) do
+        val = current_stacks.delete(stack_id)
+        logger.info "Successfully removed stack from internal cache (#{stack_id})"
+        cache[:stacks].value = MultiJson.dump(current_stacks)
+        !!val
+      end
+    end
+
+    # Expand all lazy loaded attributes within stack
+    #
+    # @param stack [Miasma::Models::Orchestration::Stack]
+    def expand_stack(stack)
+      logger.info "Stack expansion requested (#{stack.id})"
+      if((stack.in_progress? && Time.now.to_i - stack.attributes['Cached'].to_i > stack_expansion_interval) ||
+          !stack.attributes['Cached'])
+        begin
+          expanded = false
+          cache.locked_action(:stack_expansion_lock) do
+            expanded = true
+            stack.reload
+            stack.data['Cached'] = Time.now.to_i
+          end
+          if(expanded)
+            save_expanded_stack(stack.id, stack.to_json)
+          end
+        rescue => e
+          logger.error "Stack expansion failed (#{stack.id}) - #{e.class}: #{e}"
+        end
+      else
+        logger.info "Stack has been cached within expand interval. Expansion prevented. (#{stack.id})"
+      end
+    end
+
+    # Request stack information and store in cache
+    #
+    # @return [TrueClass]
+    def fetch_stacks
+      cache.locked_action(:stacks_lock) do
+        logger.info "Lock aquired for stack update. Requesting stacks from upstream. (#{Thread.current})"
+        stacks = Hash[
+          connection.stacks.reload.all.map do |stack|
+            [stack.id, stack.attributes]
+          end
+        ]
+        if(cache[:stacks].value)
+          existing_stacks = MultiJson.load(cache[:stacks].value)
+          # Force common types
+          stacks = MultiJson.load(MultiJson.dump(stacks))
+          # Remove stacks that have been deleted
+          stale_ids = existing_stacks.keys - stacks.keys
+          stacks = Chef::Mixin::DeepMerge.merge(existing_stacks, stacks)
+          stale_ids.each do |stale_id|
+            stacks.delete(stale_id)
+          end
+        end
+        cache[:stacks].value = stacks.to_json
+        logger.info 'Stack list has been updated from upstream and cached locally'
+      end
+      @initial_fetch_complete = true
+    end
+
+    # Start async stack list update. Creates thread that loops every
+    # `self.stack_list_interval` seconds and refreshes stack list in cache
+    #
+    # @return [TrueClass, FalseClass]
+    def update_stack_list!
+      if(updater.nil? || !updater.alive?)
+        self.updater = Thread.new{
+          loop do
+            begin
+              fetch_stacks
+              sleep(stack_list_interval)
+            rescue => e
+              logger.error "Failure encountered on stack fetch: #{e.class} - #{e}"
+            end
+          end
+        }
+        true
+      else
+        false
+      end
+    end
+
+    # Build API connection for service type
+    #
+    # @param service [String, Symbol]
+    # @return [Miasma::Model]
+    def service_for(service)
+      connection.api_for(service)
+    end
+
+  end
+end
+
+# Release the monkeys!
+KnifeCloudformation::MonkeyPatch::Stack

data/lib/knife-cloudformation/utils.rb

@@ -1,104 +1,24 @@
+require 'knife-cloudformation'
+
 module KnifeCloudformation
+  # Utility classes and modules
   module Utils
 
-    module Debug
-      module Output
-        def debug(msg)
-          puts "<KnifeCloudformation>: #{msg}" if ENV['DEBUG']
-        end
-      end
-
-      class << self
-        def included(klass)
-          klass.class_eval do
-            include Output
-            extend Output
-          end
-        end
-      end
-    end
-
-    module JSON
-
-      def try_json_compat
-        unless(@_json_loaded)
-          begin
-            require 'chef/json_compat'
-          rescue
-            require "#{ENV['RUBY_JSON_LIB'] || 'json'}"
-          end
-          @_json_loaded = true
-        end
-        defined?(Chef::JSONCompat)
-      end
-
-      def _to_json(thing)
-        if(try_json_compat)
-          Chef::JSONCompat.to_json(thing)
-        else
-          JSON.dump(thing)
-        end
-      end
-
-      def _from_json(thing)
-        if(try_json_compat)
-          Chef::JSONCompat.from_json(thing)
-        else
-          JSON.read(thing)
-        end
-      end
-
-      def _format_json(thing)
-        thing = _from_json(thing) if thing.is_a?(String)
-        if(try_json_compat)
-          Chef::JSONCompat.to_json_pretty(thing)
-        else
-          JSON.pretty_generate(thing)
-        end
-      end
-
-    end
-
-    module AnimalStrings
-
-      def camel(string)
-        string.to_s.split('_').map{|k| "#{k.slice(0,1).upcase}#{k.slice(1,k.length)}"}.join
-      end
-
-      def snake(string)
-        string.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
-      end
-
-    end
+    autoload :Output, 'knife-cloudformation/utils/output'
+    autoload :StackParameterValidator, 'knife-cloudformation/utils/stack_parameter_validator'
+    autoload :StackParameterScrubber, 'knife-cloudformation/utils/stack_parameter_scrubber'
+    autoload :StackExporter, 'knife-cloudformation/utils/stack_exporter'
+    autoload :Debug, 'knife-cloudformation/utils/debug'
+    autoload :JSON, 'knife-cloudformation/utils/json'
+    autoload :AnimalStrings, 'knife-cloudformation/utils/animal_strings'
+    autoload :Ssher, 'knife-cloudformation/utils/ssher'
+    autoload :ObjectStorage, 'knife-cloudformation/utils/object_storage'
+    autoload :PathSelector, 'knife-cloudformation/utils/path_selector'
+
+    # Provide methods directly from module for previous version compatibility
+    extend JSON
+    extend AnimalStrings
+    extend ObjectStorage
 
-    module Ssher
-      def remote_file_contents(address, user, path, ssh_opts={})
-        require 'net/sftp'
-        content = ''
-        ssh_session = Net::SSH.start(address, user, ssh_opts)
-        con = Net::SFTP::Session.new(ssh_session)
-        con.loop{ con.opening? }
-        f_handle = con.open!(path)
-        data = ''
-        count = 0
-        while(data)
-          data = nil
-          request = con.read(f_handle, count, 1024) do |response|
-            unless(response.eof?)
-              if(response.ok?)
-                count += 1024
-                content << response[:data]
-                data = true
-              end
-            end
-          end
-          request.wait
-        end
-        con.close!(f_handle)
-        con.close_channel
-        ssh_session.close
-        content.empty? ? nil : content
-      end
-    end
   end
 end