knife-cloudformation 0.2.24 → 0.5.0

data/lib/chef/knife/cloudformation_validate.rb

@@ -1,36 +0,0 @@
-require 'pathname'
-require 'sparkle_formation'
-require 'knife-cloudformation'
-
-class Chef
-  class Knife
-    # Cloudformation validate command
-    class CloudformationValidate < Knife
-
-      include KnifeCloudformation::Knife::Base
-      include KnifeCloudformation::Knife::Template
-
-      banner 'knife cloudformation validate'
-
-      def _run
-        file = load_template_file
-        file.delete('sfn_nested_stack')
-        ui.info "#{ui.color('Cloud Formation Validation: ', :bold)} #{Chef::Config[:knife][:cloudformation][:file].sub(Dir.pwd, '').sub(%r{^/}, '')}"
-        file = KnifeCloudformation::Utils::StackParameterScrubber.scrub!(file)
-        file = translate_template(file)
-        begin
-          result = provider.connection.stacks.build(
-            :name => 'validation-stack',
-            :template => file
-          ).validate
-          ui.info ui.color('  -> VALID', :bold, :green)
-        rescue => e
-          ui.info ui.color('  -> INVALID', :bold, :red)
-          ui.fatal e.message
-          failed = true
-        end
-      end
-
-    end
-  end
-end

data/lib/knife-cloudformation/cache.rb

@@ -1,385 +0,0 @@
-require 'digest/sha2'
-require 'thread'
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  # Data caching helper
-  class Cache
-
-    class << self
-
-      # Configure the caching approach to use
-      #
-      # @param type [Symbol] :redis or :local
-      # @param args [Hash] redis connection arguments if used
-      def configure(type, args={})
-        type = type.to_sym
-        case type
-        when :redis
-          begin
-            require 'redis-objects'
-          rescue LoadError
-            $stderr.puts 'The `redis-objects` gem is required for Cache support!'
-            raise
-          end
-          @_pid = Process.pid
-          Redis::Objects.redis = Redis.new(args)
-        when :local
-        else
-          raise TypeError.new("Unsupported caching type: #{type}")
-        end
-        enable(type)
-      end
-
-      # Set enabled caching type
-      #
-      # @param type [Symbol]
-      # @return [Symbol]
-      def enable(type)
-        @type = type.to_sym
-      end
-
-      # @return [Symbol] type of caching enabled
-      def type
-        @type || :local
-      end
-
-      # Set/get time limit on data type
-      #
-      # @param kind [String, Symbol] data type
-      # @param seconds [Integer]
-      # return [Integer] seconds
-      def apply_limit(kind, seconds=nil)
-        @apply_limit ||= {}
-        if(seconds)
-          @apply_limit[kind.to_sym] = seconds.to_i
-        end
-        @apply_limit[kind.to_sym].to_i
-      end
-
-      # @return [Hash] default limits
-      def default_limits
-        (@apply_limit || {}).dup
-      end
-
-      # Ping the redis connection and reconnect if dead
-      def redis_ping!
-        if((@_pid && @_pid != Process.pid) || !Redis::Objects.redis.connected?)
-          Redis::Objects.redis.client.reconnect
-          @_pid = Process.pid
-        end
-      end
-
-    end
-
-    # @return [String] custom key for this cache
-    attr_reader :key
-
-    # Create new instance
-    #
-    # @param key [String, Array]
-    def initialize(key)
-      if(key.respond_to?(:sort))
-        key = key.flatten if key.respond_to?(:flatten)
-        key = key.map(&:to_s).sort
-      end
-      @key = Digest::SHA256.hexdigest(key.to_s)
-      @apply_limit = self.class.default_limits
-    end
-
-    # Initialize a new data type
-    #
-    # @param name [Symbol] name of data
-    # @param kind [Symbol] data type
-    # @param args [Hash] options for data type
-    def init(name, kind, args={})
-      get_storage(self.class.type, kind, name, args)
-      true
-    end
-
-    # @return [Hash] data registry
-    def registry
-      get_storage(self.class.type, :hash, "registry_#{key}")
-    end
-
-    # Clear data
-    #
-    # @param args [Symbol] list of names to delete
-    # @return [TrueClass]
-    # @note clears all data if no names provided
-    def clear!(*args)
-      internal_lock do
-        args = registry.keys if args.empty?
-        args.each do |key|
-          value = self[key]
-          if(value.respond_to?(:clear))
-            value.clear
-          elsif(value.respond_to?(:value))
-            value.value = nil
-          end
-          registry.delete(key)
-        end
-        yield if block_given?
-      end
-      true
-    end
-
-    # Fetch item from storage
-    #
-    # @param store_type [Symbol]
-    # @param data_type [Symbol]
-    # @param name [Symbol] name of data
-    # @param args [Hash] options for underlying storage
-    # @return [Object]
-    def get_storage(store_type, data_type, name, args={})
-      full_name = "#{key}_#{name}"
-      result = nil
-      case store_type.to_sym
-      when :redis
-        result = get_redis_storage(data_type, full_name.to_s, args)
-      when :local
-        @_local_cache ||= {}
-        unless(@_local_cache[full_name.to_s])
-          @_local_cache[full_name.to_s] = get_local_storage(data_type, full_name.to_s, args)
-        end
-        result = @_local_cache[full_name.to_s]
-      else
-        raise TypeError.new("Unsupported caching storage type encountered: #{store_type}")
-      end
-      unless(full_name == "#{key}_registry_#{key}")
-        registry[name.to_s] = data_type
-      end
-      result
-    end
-
-    # Fetch item from redis storage
-    #
-    # @param data_type [Symbol]
-    # @param full_name [Symbol]
-    # @param args [Hash]
-    # @return [Object]
-    def get_redis_storage(data_type, full_name, args={})
-      self.class.redis_ping!
-      case data_type.to_sym
-      when :array
-        Redis::List.new(full_name, {:marshal => true}.merge(args))
-      when :hash
-        Redis::HashKey.new(full_name)
-      when :value
-        Redis::Value.new(full_name, {:marshal => true}.merge(args))
-      when :lock
-        Redis::Lock.new(full_name, {:expiration => 60, :timeout => 0.1}.merge(args))
-      when :stamped
-        Stamped.new(full_name.sub("#{key}_", '').to_sym, get_redis_storage(:value, full_name), self)
-      else
-        raise TypeError.new("Unsupported caching data type encountered: #{data_type}")
-      end
-    end
-
-    # Fetch item from local storage
-    #
-    # @param data_type [Symbol]
-    # @param full_name [Symbol]
-    # @param args [Hash]
-    # @return [Object]
-    # @todo make proper singleton for local storage
-    def get_local_storage(data_type, full_name, args={})
-      @storage ||= {}
-      @storage[full_name] ||= case data_type.to_sym
-        when :array
-          []
-        when :hash
-          {}
-        when :value
-          LocalValue.new
-        when :lock
-          LocalLock.new(full_name, {:expiration => 60, :timeout => 0.1}.merge(args))
-        when :stamped
-          Stamped.new(full_name.sub("#{key}_", '').to_sym, get_local_storage(:value, full_name), self)
-        else
-          raise TypeError.new("Unsupported caching data type encountered: #{data_type}")
-        end
-    end
-
-    # Execute block within internal lock
-    #
-    # @return [Object] result of yield
-    # @note for internal use
-    def internal_lock
-      get_storage(self.class.type, :lock, :internal_access, :timeout => 20, :expiration => 120).lock do
-        yield
-      end
-    end
-
-    # Fetch data
-    #
-    # @param name [String, Symbol]
-    # @return [Object, NilClass]
-    def [](name)
-      if(kind = registry[name.to_s])
-        get_storage(self.class.type, kind, name)
-      else
-        nil
-      end
-    end
-
-    # Set data
-    #
-    # @param key [Object]
-    # @param val [Object]
-    # @note this will never work, thus you should never use it
-    def []=(key, val)
-      raise 'Setting backend data is not allowed'
-    end
-
-    # Check if cache time has expired
-    #
-    # @param key [String, Symbol] value key
-    # @param stamp [Time, Integer]
-    # @return [TrueClass, FalseClass]
-    def time_check_allow?(key, stamp)
-      Time.now.to_i - stamp.to_i > apply_limit(key)
-    end
-
-    # Apply time limit for data type
-    #
-    # @param kind [String, Symbol] data type
-    # @param seconds [Integer]
-    # return [Integer]
-    def apply_limit(kind, seconds=nil)
-      @apply_limit ||= {}
-      if(seconds)
-        @apply_limit[kind.to_sym] = seconds.to_i
-      end
-      @apply_limit[kind.to_sym].to_i
-    end
-
-    # Perform action within lock
-    #
-    # @param lock_name [String, Symbol] name of lock
-    # @param raise_on_locked [TrueClass, FalseClass] raise execption if lock wait times out
-    # @return [Object] result of yield
-    def locked_action(lock_name, raise_on_locked=false)
-      begin
-        self[lock_name].lock do
-          yield
-        end
-      rescue => e
-        if(e.class.to_s == 'Redis::Lock::LockTimeout')
-          raise if raise_on_locked
-        else
-          raise
-        end
-      end
-    end
-
-    # Simple value for memory cache
-    class LocalValue
-      # @return [Object] value
-      attr_accessor :value
-      def initialize(*args)
-        @value = nil
-      end
-    end
-
-    # Simple lock for memory cache
-    class LocalLock
-
-      # @return [Symbol] key name
-      attr_reader :_key
-      # @return [Numeric] timeout
-      attr_reader :_timeout
-      # @return [Mutex] underlying lock
-      attr_reader :_lock
-
-      # Create new instance
-      #
-      # @param name [Symbol] name of lock
-      # @param args [Hash]
-      # @option args [Numeric] :timeout
-      def initialize(name, args={})
-        @_key = name
-        @_timeout = args.fetch(:timeout, -1).to_f
-        @_lock = Mutex.new
-      end
-
-      # Aquire lock and yield
-      #
-      # @yield block to execute within lock
-      # @return [Object] result of yield
-      def lock
-        locked = false
-        attempt_start = Time.now.to_f
-        while(!locked && (_timeout < 0 || Time.now.to_f - attempt_start < _timeout))
-          locked = _lock.try_lock
-        end
-        if(locked)
-          begin
-            yield
-          ensure
-            _lock.unlock if _lock.locked?
-          end
-        else
-          raise Redis::Lock::LockTimeout.new "Timeout on lock #{_key} exceeded #{_timeout} sec"
-        end
-      end
-
-      # Clear the lock
-      #
-      # @note this is a noop
-      def clear
-        # noop
-      end
-    end
-
-    # Wrapper to auto stamp values
-    class Stamped
-
-      # Create new instance
-      #
-      # @param name [String, Symbol]
-      # @param base [Redis::Value, LocalValue]
-      # @param cache [Cache]
-      def initialize(name, base, cache)
-        @name = name.to_sym
-        @base = base
-        @cache = cache
-      end
-
-      # @return [Object] value stored
-      def value
-        @base.value[:value] if set?
-      end
-
-      # Store value and update timestamp
-      #
-      # @param v [Object] value
-      # @return [Object]
-      def value=(v)
-        @base.value = {:stamp => Time.now.to_f, :value => v}
-        v
-      end
-
-      # @return [TrueClass, FalseClass] is value set
-      def set?
-        @base.value.is_a?(Hash)
-      end
-
-      # @return [Float] timestamp of last set (or 0.0 if unset)
-      def stamp
-        set? ? @base.value[:stamp] : 0.0
-      end
-
-      # Force a timestamp update
-      def restamp!
-        self.value = value
-      end
-
-      # @return [TrueClass, FalseClass] update is allowed based on stamp and limits
-      def update_allowed?
-        !set? || @cache.time_check_allow?(@name, @base.value[:stamp])
-      end
-    end
-
-  end
-end

data/lib/knife-cloudformation/knife.rb

@@ -1,9 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Knife
-    autoload :Base, 'knife-cloudformation/knife/base'
-    autoload :Stack, 'knife-cloudformation/knife/stack'
-    autoload :Template, 'knife-cloudformation/knife/template'
-  end
-end

data/lib/knife-cloudformation/knife/base.rb

@@ -1,195 +0,0 @@
-require 'chef/knife'
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Knife
-    # Base to build cloudformation related knife commands
-    module Base
-
-      # Instance methods for cloudformation command classes
-      module InstanceMethods
-
-        # @return [KnifeCloudformation::Provider]
-        def provider
-          self.class.provider
-        end
-
-        # Write exception information if debug is enabled
-        #
-        # @param e [Exception]
-        # @param args [String] extra strings to output
-        def _debug(e, *args)
-          if(ENV['DEBUG'])
-            ui.fatal "Exception information: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}\n"
-            if(e.is_a?(Miasma::Error::ApiError))
-              ui.fatal "Response body: #{e.response.body.to_s.inspect}"
-            end
-            args.each do |string|
-              ui.fatal string
-            end
-          end
-        end
-
-        # Get stack
-        #
-        # @param name [String] name of stack
-        # @return [Miasma::Models::Orchestration::Stack]
-        def stack(name)
-          provider.stacks.get(name)
-        end
-
-        # @return [Array<String>] attributes to display
-        def allowed_attributes
-          Chef::Config[:knife][:cloudformation][:attributes] || default_attributes
-        end
-
-        # @return [Array<String>] default attributes to display
-        def default_attributes
-          %w(timestamp stack_name id)
-        end
-
-        # Check if attribute is allowed for display
-        #
-        # @param attr [String]
-        # @return [TrueClass, FalseClass]
-        def attribute_allowed?(attr)
-          config[:all_attributes] || allowed_attributes.include?(attr)
-        end
-
-        # Poll events on stack
-        #
-        # @param name [String] name of stack
-        def poll_stack(name)
-          retry_attempts = 0
-          begin
-            provider.connection.stacks.reload
-            knife_events = Chef::Knife::CloudformationEvents.new
-            knife_events.name_args.push(name)
-            Chef::Config[:knife][:cloudformation][:poll] = true
-            knife_events.run
-          rescue => e
-            if(retry_attempts < Chef::Config[:knife][:cloudformation].fetch(:max_poll_retries, 5))
-              retry_attempts += 1
-              warn "Unexpected error encountered (#{e.class}: #{e}) Retrying [retry count: #{retry_attempts}]"
-              sleep(1)
-              retry
-            else
-              raise
-            end
-          end
-        end
-
-        # Wrapper for information retrieval. Provides consistent error
-        # message for failures
-        #
-        # @param stack [String] stack name
-        # @param message [String] failure message
-        # @yield block to wrap error handling
-        # @return [Object] result of yield
-        def get_things(stack=nil, message=nil)
-          begin
-            yield
-          rescue => e
-            ui.fatal "#{message || 'Failed to retrieve information'}#{" for requested stack: #{stack}" if stack}"
-            ui.fatal "Reason: #{e}"
-            _debug(e)
-            exit 1
-          end
-        end
-
-        # Disable chef configuration. Let the dep loader do that for us
-        # so it doesn't squash config values set via options
-        def configure_chef
-          true
-        end
-
-        # Wrapper to allow consistent exception handling
-        def run
-          begin
-            _run
-          rescue => e
-            ui.fatal "Unexpected Error: #{e.message}"
-            _debug(e)
-            exit 1
-          end
-        end
-
-      end
-
-      module ClassMethods
-
-        # @return [KnifeCloudformation::Provider]
-        def provider
-          Thread.current[:_provider] ||= KnifeCloudformation::Provider.new(
-            :miasma => Chef::Config[:knife][:cloudformation][:credentials],
-            :async => false,
-            :fetch => false
-          )
-        end
-
-        # @return [FalseClass]
-        def use_separate_defaults?
-          false
-        end
-
-      end
-
-      class << self
-        def included(klass)
-          klass.instance_eval do
-
-            extend KnifeCloudformation::Knife::Base::ClassMethods
-            include KnifeCloudformation::Knife::Base::InstanceMethods
-            include KnifeCloudformation::Utils::JSON
-            include KnifeCloudformation::Utils::AnimalStrings
-            include KnifeCloudformation::Utils::Output
-
-            deps do
-              Chef::Knife.new.configure_chef
-              require 'miasma'
-              Chef::Config[:knife][:cloudformation] ||= Mash.new
-              Chef::Config[:knife][:cloudformation][:credentials] ||= Mash.new
-              Chef::Config[:knife][:cloudformation][:options] ||= Mash.new
-              Chef::Config[:knife][:cloudformation][:ignore_parameters] = []
-              %w(poll interactive_parameters apply_nesting).each do |key|
-                if(Chef::Config[:knife][:cloudformation][key].nil?)
-                  Chef::Config[:knife][:cloudformation][key] = true
-                end
-              end
-            end
-
-            option(:credentials,
-              :short => '-S CREDENTIALS',
-              :long => '--credentials CREDENTIALS',
-              :description => 'Miasma API options. Comma delimited or used multiple times. (-S "aws_access_key_id=MYKEY")',
-              :proc => lambda {|val|
-                val.split(',').each do |pair|
-                  key, value = pair.split('=')
-                  Chef::Config[:knife][:cloudformation][:credentials][key] = value
-                end
-              }
-            )
-
-            option(:ignore_parameter,
-              :long => '--ignore-parameter PARAMETER_NAME',
-              :description => 'Parameter to ignore during modifications (can be used multiple times)',
-              :proc => lambda{|val| Chef::Config[:knife][:cloudformation][:ignore_parameters].push(val).uniq! }
-            )
-
-            # Populate up the hashes so they are available for knife config
-            # with issues of nils
-            ['knife.cloudformation.credentials', 'knife.cloudformation.options'].each do |stack|
-              stack.split('.').inject(Chef::Config) do |memo, item|
-                memo[item.to_sym] = Mash.new unless memo[item.to_sym]
-                memo[item.to_sym]
-              end
-            end
-
-          end
-
-        end
-      end
-    end
-
-  end
-end