knife-cloudformation 0.2.24 → 0.5.0

data/lib/knife-cloudformation/provider.rb

@@ -1,225 +0,0 @@
-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,24 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  # Utility classes and modules
-  module Utils
-
-    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
-
-  end
-end

data/lib/knife-cloudformation/utils/animal_strings.rb

@@ -1,28 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Utils
-
-    # Helper methods for string format modification
-    module AnimalStrings
-
-      # Camel case string
-      #
-      # @param string [String]
-      # @return [String]
-      def camel(string)
-        string.to_s.split('_').map{|k| "#{k.slice(0,1).upcase}#{k.slice(1,k.length)}"}.join
-      end
-
-      # Snake case string
-      #
-      # @param string [String]
-      # @return [Symbol]
-      def snake(string)
-        string.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
-      end
-
-    end
-
-  end
-end

data/lib/knife-cloudformation/utils/debug.rb

@@ -1,31 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Utils
-    # Debug helpers
-    module Debug
-      # Output helpers
-      module Output
-        # Write debug message
-        #
-        # @param msg [String]
-        def debug(msg)
-          puts "<KnifeCloudformation>: #{msg}" if ENV['DEBUG']
-        end
-      end
-
-      class << self
-        # Load module into class
-        #
-        # @param klass [Class]
-        def included(klass)
-          klass.class_eval do
-            include Output
-            extend Output
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/knife-cloudformation/utils/json.rb

@@ -1,64 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Utils
-
-    # JSON helper methods
-    module JSON
-
-      # Attempt to load chef JSON compat helper
-      #
-      # @return [TrueClass, FalseClass] chef compat helper available
-      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
-
-      # Convert to JSON
-      #
-      # @param thing [Object]
-      # @return [String]
-      def _to_json(thing)
-        if(try_json_compat)
-          Chef::JSONCompat.to_json(thing)
-        else
-          JSON.dump(thing)
-        end
-      end
-
-      # Load JSON data
-      #
-      # @param thing [String]
-      # @return [Object]
-      def _from_json(thing)
-        if(try_json_compat)
-          Chef::JSONCompat.from_json(thing)
-        else
-          JSON.read(thing)
-        end
-      end
-
-      # Format object into pretty JSON
-      #
-      # @param thing [Object]
-      # @return [String]
-      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
-
-  end
-end

data/lib/knife-cloudformation/utils/object_storage.rb

@@ -1,28 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Utils
-
-    # Storage helpers
-    module ObjectStorage
-
-      # Write to file
-      #
-      # @param object [Object]
-      # @param path [String] path to write object
-      # @param directory [Miasma::Models::Storage::Directory]
-      # @return [String] file path
-      def file_store(object, path, directory)
-        raise NotImplementedError.new 'Internal updated required! :('
-        content = object.is_a?(String) ? object : Utils._format_json(object)
-        directory.files.create(
-          :identity => path,
-          :body => content
-        )
-        loc = directory.service.service.name.split('::').last.downcase
-        "#{loc}://#{directory.identity}/#{path}"
-      end
-
-    end
-  end
-end

data/lib/knife-cloudformation/utils/output.rb

@@ -1,79 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Utils
-    # Output Helpers
-    module Output
-
-      # Process things and return items
-      #
-      # @param things [Array] items to process
-      # @param args [Hash] options
-      # @option args [TrueClass, FalseClass] :flat flatten result array
-      # @option args [Array] :attributes attributes to extract
-      # @todo this was extracted from events and needs to be cleaned up
-      def process(things, args={})
-        @event_ids ||= []
-        processed = things.reverse.map do |thing|
-          next if @event_ids.include?(thing['id'])
-          @event_ids.push(thing['id']).compact!
-          if(args[:attributes])
-            args[:attributes].map do |key|
-              thing[key].to_s
-            end
-          else
-            thing.values
-          end
-        end
-        args[:flat] ? processed.flatten : processed
-      end
-
-      # Generate formatted titles
-      #
-      # @param thing [Object] thing being processed
-      # @param args [Hash]
-      # @option args [Array] :attributes
-      # @return [Array<String>] formatted titles
-      def get_titles(thing, args={})
-        attrs = args[:attributes] || []
-        if(attrs.empty?)
-          hash = thing.is_a?(Array) ? thing.first : thing
-          hash ||= {}
-          attrs = hash.keys
-        end
-        titles = attrs.map do |key|
-          camel(key).gsub(/([a-z])([A-Z])/, '\1 \2')
-        end.compact
-        if(args[:format])
-          titles.map{|s| @ui.color(s, :bold)}
-        else
-          titles
-        end
-      end
-
-      # Output stack related things in nice format
-      #
-      # @param stack [String] name of stack
-      # @param things [Array] things to display
-      # @param what [String] description of things for output
-      # @param args [Symbol] options (:ignore_empty_output)
-      def things_output(stack, things, what, *args)
-        unless(args.include?(:no_title))
-          output = get_titles(things, :format => true, :attributes => allowed_attributes)
-        else
-          output = []
-        end
-        columns = allowed_attributes.size
-        output += process(things, :flat => true, :attributes => allowed_attributes)
-        output.compact!
-        if(output.empty?)
-          ui.warn 'No information found' unless args.include?(:ignore_empty_output)
-        else
-          ui.info "#{what.to_s.capitalize} for stack: #{ui.color(stack, :bold)}" if stack
-          ui.info "#{ui.list(output, :uneven_columns_across, columns)}"
-        end
-      end
-
-    end
-  end
-end