knife-cloudformation 0.1.22 → 0.2.0

data/lib/knife-cloudformation/aws_commons/stack_parameter_validator.rb

@@ -1,79 +0,0 @@
-require 'knife-cloudformation/aws_commons/stack'
-
-module KnifeCloudformation
-  class AwsCommons
-
-    class Stack
-
-      class ParameterValidator
-        class << self
-
-          include KnifeCloudformation::Utils::AnimalStrings
-
-          def validate(value, parameter_definition)
-            return [[:blank, 'Value cannot be blank']] if value.to_s.strip.empty?
-            result = %w(AllowedValues AllowedPattern MaxLength MinLength MaxValue MinValue).map do |key|
-              if(parameter_definition[key])
-                res = self.send(snake(key), value, parameter_definition)
-                res == true ? true : [snake(key), res]
-              else
-                true
-              end
-            end
-            result.delete_if{|x| x == true}
-            result.empty? ? true : result
-          end
-
-          def allowed_values(value, pdef)
-            if(pdef['AllowedValues'].include?(value))
-              true
-            else
-              "Not an allowed value: #{pdef['AllowedValues'].join(', ')}"
-            end
-          end
-
-          def allowed_pattern(value, pdef)
-            if(value.match(/#{pdef['AllowedPattern']}/))
-              true
-            else
-              "Not a valid pattern. Must match: #{pdef['AllowedPattern']}"
-            end
-          end
-
-          def max_length(value, pdef)
-            if(value.length <= pdef['MaxLength'].to_i)
-              true
-            else
-              "Value must not exceed #{pdef['MaxLength']} characters"
-            end
-          end
-
-          def min_length(value, pdef)
-            if(value.length >= pdef['MinLength'].to_i)
-              true
-            else
-              "Value must be at least #{pdef['MinLength']} characters"
-            end
-          end
-
-          def max_value(value, pdef)
-            if(value.to_i <= pdef['MaxValue'].to_i)
-              true
-            else
-              "Value must not be greater than #{pdef['MaxValue']}"
-            end
-          end
-
-          def min_value(value, pdef)
-            if(value.to_i >= pdef['MinValue'].to_i)
-              true
-            else
-              "Value must not be less than #{pdef['MinValue']}"
-            end
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/knife-cloudformation/cloudformation_base.rb

@@ -1,168 +0,0 @@
-require 'chef/knife'
-require 'knife-cloudformation/utils'
-require 'knife-cloudformation/aws_commons'
-
-module KnifeCloudformation
-
-  module KnifeBase
-
-    module InstanceMethods
-
-      def aws
-        self.class.con(ui)
-      end
-
-      def _debug(e, *args)
-        if(ENV['DEBUG'])
-          ui.fatal "Exception information: #{e.class}: #{e}\n#{e.backtrace.join("\n")}\n"
-          args.each do |string|
-            ui.fatal string
-          end
-        end
-      end
-
-      def stack(name)
-        self.class.con(ui).stack(name, :ignore_seeds)
-      end
-
-      def allowed_attributes
-        Chef::Config[:knife][:cloudformation][:attributes] || default_attributes
-      end
-
-      def default_attributes
-        %w(Timestamp StackName StackId)
-      end
-
-      def attribute_allowed?(attr)
-        config[:all_attributes] || allowed_attributes.include?(attr)
-      end
-
-      def poll_stack(name)
-        knife_events = Chef::Knife::CloudformationEvents.new
-        knife_events.name_args.push(name)
-        Chef::Config[:knife][:cloudformation][:poll] = true
-        knife_events.run
-      end
-
-      def things_output(stack, things, what, *args)
-        unless(args.include?(:no_title))
-          output = aws.get_titles(things, :format => true, :attributes => allowed_attributes)
-        else
-          output = []
-        end
-        columns = allowed_attributes.size
-        output += aws.process(things, :flat => true, :attributes => allowed_attributes)
-        output.compact.flatten
-        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
-
-      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
-
-    end
-
-    module ClassMethods
-
-      def con(ui=nil)
-        unless(@common)
-          @common = KnifeCloudformation::AwsCommons.new(
-            :ui => ui,
-            :fog => {
-              :aws_access_key_id => _key,
-              :aws_secret_access_key => _secret,
-              :region => _region
-            }
-          )
-        end
-        @common
-      end
-
-      def _key
-        Chef::Config[:knife][:cloudformation][:credentials][:key] ||
-          Chef::Config[:knife][:aws_access_key_id]
-      end
-
-      def _secret
-        Chef::Config[:knife][:cloudformation][:credentials][:secret] ||
-          Chef::Config[:knife][:aws_secret_access_key]
-      end
-
-      def _region
-        Chef::Config[:knife][:cloudformation][:credentials][:region] ||
-          Chef::Config[:knife][:region]
-      end
-
-    end
-
-    class << self
-      def included(klass)
-        klass.instance_eval do
-
-          extend KnifeCloudformation::KnifeBase::ClassMethods
-          include KnifeCloudformation::KnifeBase::InstanceMethods
-          include KnifeCloudformation::Utils::JSON
-          include KnifeCloudformation::Utils::AnimalStrings
-
-          deps do
-            require 'fog'
-            Chef::Config[:knife][:cloudformation] ||= Mash.new
-            Chef::Config[:knife][:cloudformation][:credentials] ||= Mash.new
-            Chef::Config[:knife][:cloudformation][:options] ||= Mash.new
-          end
-
-          option(:key,
-            :short => '-K KEY',
-            :long => '--key KEY',
-            :description => 'AWS access key id',
-            :proc => lambda {|val|
-              Chef::Config[:knife][:cloudformation][:credentials][:key] = val
-            }
-          )
-          option(:secret,
-            :short => '-S SECRET',
-            :long => '--secret SECRET',
-            :description => 'AWS secret access key',
-            :proc => lambda {|val|
-              Chef::Config[:knife][:cloudformation][:credentials][:secret] = val
-            }
-          )
-          option(:region,
-            :short => '-r REGION',
-            :long => '--region REGION',
-            :description => 'AWS region',
-            :proc => lambda {|val|
-              Chef::Config[:knife][:cloudformation][:credentials][:region] = val
-            }
-          )
-
-
-          # 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
-
-          Chef::Config[:knife][:cloudformation] ||= Mash.new
-
-        end
-      end
-    end
-  end
-
-end

data/lib/knife-cloudformation/export.rb

@@ -1,174 +0,0 @@
-require 'knife-cloudformation/aws_commons'
-require 'chef'
-
-module KnifeCloudformation
-  class Export
-
-    DEFAULT_OPTIONS = {
-      :chef_popsicle => true,
-      :ignored_parameters => ['Environment', 'StackCreator'],
-      :chef_environment_parameter => 'Environment',
-      :aws_commons => nil
-    }
-
-    attr_reader :stack, :stack_name, :stack_id, :options, :aws_commons
-
-    def initialize(stack_name, options={})
-      @stack_name = stack_name
-      @options = DEFAULT_OPTIONS.merge(options)
-      if(aws_commons?)
-        @aws_commons = options[:aws_commons]
-      else
-        raise ArgumentError.new('Expecting `AwsCommons` instance but none provided!')
-      end
-      load_stack
-    end
-
-    def export
-      exported = stack.to_hash
-      if(chef_popsicle?)
-        freeze_runlists(exported)
-      end
-      remove_ignored_parameters(exported)
-      exported
-    end
-
-    def method_missing(*args)
-      m = args.first.to_s
-      if(m.end_with?('?') && options.has_key?(k = m.sub('?', '').to_sym))
-        !!options[k]
-      else
-        super
-      end
-    end
-
-    protected
-
-    def remove_ignored_parameters(export)
-      options[:ignored_parameters].each do |param|
-        export[:parameters].delete(param)
-      end
-    end
-
-    def chef_environment_name
-      if(chef_environment_parameter?)
-        name = stack[:parameters][options[:chef_environment_parameter]]
-      end
-      name || '_default'
-    end
-
-    def environment
-      unless(@env)
-        @env = Chef::Environment.load('imdev')
-      end
-      @env
-    end
-
-    def load_stack
-      @stack = AwsCommons::Stack.new(stack_name, aws_commons)
-      @stack_id = @stack.stack_id
-      @stack
-    end
-
-    def allowed_cookbook_version(cookbook)
-      restriction = environment.cookbook_versions[cookbook]
-      requirement = Gem::Requirement.new(restriction)
-      Chef::CookbookVersion.available_versions(cookbook).detect do |v|
-        requirement.satisfied_by?(Gem::Version.new(v))
-      end
-    end
-
-    def extract_runlist_item(item)
-      rl_item = item.is_a?(Chef::RunList::RunListItem) ? item : Chef::RunList::RunListItem.new(item)
-      static_content = Mash.new(:run_list => [])
-      if(rl_item.recipe?)
-        cookbook, recipe = rl_item.name.split('::')
-        peg_version = allowed_cookbook_version(cookbook)
-        static_content[:run_list] << "recipe[#{[cookbook, recipe || 'default'].join('::')}@#{peg_version}]"
-      elsif(rl_item.role?)
-        role = Chef::Role.load(rl_item.name)
-        role.run_list.each do |item|
-          static_content = Chef::Mixin::DeepMerge.merge(static_content, extract_runlist_item(item))
-        end
-        static_content = Chef::Mixin::DeepMerge.merge(
-          static_content, Chef::Mixin::DeepMerge.merge(role.default_attributes, role.override_attributes)
-        )
-      else
-        # dunno what this is
-      end
-      static_content
-    end
-
-    def unpack_and_freeze_runlist(first_run)
-      extracted_runlists = first_run['run_list'].map do |item|
-        extract_runlist_item(cf_replace(item))
-      end
-      first_run.delete('run_list')
-      first_run.replace(
-        extracted_runlists.inject(first_run) do |memo, first_run_item|
-          Chef::Mixin::DeepMerge.merge(memo, first_run_item)
-        end
-      )
-    end
-
-    def freeze_runlists(exported)
-      first_runs = locate_runlists(exported)
-      first_runs.each do |first_run|
-        unpack_and_freeze_runlist(first_run)
-      end
-    end
-
-    def locate_runlists(thing)
-      result = []
-      case thing
-      when Hash
-        if(thing['content'] && thing['content']['run_list'])
-          result << thing['content']
-        else
-          thing.each do |k,v|
-            result += locate_runlists(v)
-          end
-        end
-      when Array
-        thing.each do |v|
-          result += locate_runlists(v)
-        end
-      end
-      result
-    end
-
-    def cf_replace(hsh)
-      if(hsh.is_a?(Hash))
-        case hsh.keys.first
-        when 'Fn::Join'
-          cf_join(*hsh.values.first)
-        when 'Ref'
-          cf_ref(hsh.values.first)
-        else
-          hsh
-        end
-      else
-        hsh
-      end
-    end
-
-    def cf_ref(ref_name)
-      if(stack.parameters.has_key?(ref_name))
-        stack.parameters[ref_name]
-      else
-        raise KeyError.new("No parameter found with given reference name (#{ref_name}). " <<
-          "Only parameter based references supported!")
-      end
-    end
-
-    def cf_join(delim, args)
-      args.map do |arg|
-        if(arg.is_a?(Hash))
-          cf_replace(arg)
-        else
-          arg.to_s
-        end
-      end.join(delim)
-    end
-  end
-end