knife-cloudformation 0.1.2 → 0.1.4

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

@@ -0,0 +1,221 @@
+require 'knife-cloudformation/aws_commons.rb'
+
+module KnifeCloudformation
+  class AwsCommons
+    class Stack
+
+      include KnifeCloudformation::Utils::JSON
+
+      attr_reader :name, :raw_stack, :raw_resources, :common
+
+      class << self
+
+        include KnifeCloudformation::Utils::JSON
+
+        def create(name, definition, aws_common)
+          aws_common.aws(:cloud_formation).create_stack(name, definition)
+          new(name, aws_common)
+        end
+
+        def build_stack_definition(template, options={})
+          stack = Mash.new
+          options.each do |key, value|
+            format_key = key.split('_').map do |k|
+              "#{k.slice(0,1).upcase}#{k.slice(1,k.length)}"
+            end.join
+            stack[format_key] = value
+          end
+          enable_capabilities!(stack, template)
+          stack['TemplateBody'] = _to_json(template)
+          stack
+        end
+
+        # Currently only checking for IAM resources since that's all
+        # that is supported for creation
+        def enable_capabilities!(stack, template)
+          found = Array(template['Resources']).detect do |resource_name, resource|
+            resource['Type'].start_with?('AWS::IAM')
+          end
+          stack['Capabilities'] = ['CAPABILITY_IAM'] if found
+          nil
+        end
+
+      end
+
+      def initialize(name, common)
+        @name = name
+        @common = common
+        @memo = {}
+        load_stack
+        @force_refresh = false
+        @force_refresh = in_progress?
+      end
+
+      ## Actions ##
+
+      def update(definition)
+        res = common.aws(:cloud_formation).update_stack(name, definition)
+        reload!
+        res
+      end
+
+      def destroy
+        res = common.aws(:cloud_formation).delete_stack(name)
+        reload!
+        res
+      end
+
+      def load_stack
+        @raw_stack = common.aws(:cloud_formation).describe_stacks('StackName' => name).body['Stacks'].first
+      end
+
+      def load_resources
+        @raw_resources = common.aws(:cloud_formation).describe_stack_resources('StackName' => name).body['StackResources']
+      end
+
+      def refresh?(bool)
+        bool || (bool.nil? && @force_refresh)
+      end
+
+      def reload!
+        load_stack
+        load_resources
+        @force_refresh = in_progress?
+        @memo = {}
+        true
+      end
+
+      ## Information ##
+
+      def serialize
+        _to_json(to_hash)
+      end
+
+      def to_hash(extra_data={})
+        {
+          :template => template,
+          :parameters => parameters,
+          :capabilities => capabilities,
+          :disable_rollback => disable_rollback,
+          :notification_ARNs => notification_arns,
+          :timeout_in_minutes => timeout
+        }.merge(extra_data)
+      end
+
+      def template
+        unless(@memo[:template])
+          @memo[:template] = _from_json(
+            common.aws(:cloud_formation)
+              .get_template(name).body['TemplateBody']
+          )
+        end
+        @memo[:template]
+      end
+
+      def parameters
+        unless(@memo[:parameters])
+          @memo[:parameters] = Hash[*(
+              @raw_stack['Parameters'].map do |ary|
+                [ary['ParameterKey'], ary['ParameterValue']]
+              end.flatten
+          )]
+        end
+        @memo[:parameters]
+      end
+
+      def capabilities
+        @raw_stack['Capabilities']
+      end
+
+      def disable_rollback
+        @raw_stack['DisableRollback']
+      end
+
+      def notification_arns
+        @raw_stack['NotificationARNs']
+      end
+
+      def status(force_refresh=nil)
+        load_stack if refresh?(force_refresh)
+        @raw_stack['StackStatus']
+      end
+
+      def resources(force_refresh=nil)
+        load_resources if @raw_resources.nil? || refresh?(force_refresh)
+        @raw_resources
+      end
+
+      def events(all=false)
+        res = common.aws(:cloud_formation).describe_stack_events(name).body['StackEvents']
+        @memo[:events] ||= []
+        res.delete_if{|e| @memo[:events].include?(e['EventId'])}
+        @memo[:events] += res.map{|e| e['EventId']}
+        @memo[:events].uniq!
+        res
+      end
+
+      def outputs(style=:unformatted)
+        case style
+        when :formatted
+          Hash[*(
+              @raw_stack['Outputs'].map do |item|
+                [item['OutputKey'].gsub(/(?<![A-Z])([A-Z])/, '_\1').sub(/^_/, '').downcase.to_sym, item['OutputValue']]
+              end.flatten
+          )]
+        when :unformatted
+          Hash[*(
+              @raw_stack['Outputs'].map do |item|
+                [item['OutputKey'], item['OutputValue']]
+              end.flatten
+          )]
+        else
+          @raw_stack['Outputs']
+        end
+      end
+
+      ## State ##
+
+      def in_progress?
+        status.to_s.downcase.end_with?('in_progress')
+      end
+
+      def complete?
+        stat = status.to_s.downcase
+        stat.end_with?('complete') || stat.end_with?('failed')
+      end
+
+      def failed?
+        stat = status.to_s.downcase
+        stat.end_with?('failed') || (stat.include?('rollback') && stat.end_with?('complete'))
+      end
+
+      def success?
+        !failed?
+      end
+
+      ## Fog instance helpers ##
+
+      RESOURCE_FILTER_KEYS = {
+        :auto_scaling_group => 'AutoScalingGroupNames'
+      }
+
+      def expand_resource(resource)
+        kind = resource['ResourceType'].split('::')[1]
+        kind_snake = common.snake(kind)
+        aws = common.aws(kind_snake)
+        aws.send("#{common.snake(resource['ResourceType'].split('::').last).to_s.split('_').last}s").get(resource['PhysicalResourceId'])
+      end
+
+      def nodes
+        as_resources = resources.find_all{|r|r['ResourceType'] == 'AWS::AutoScaling::AutoScalingGroup'}
+        as_resources.map do |as_resource|
+          as_group = expand_resource(as_resource)
+          as_group.instances.map do |inst|
+            common.aws(:ec2).servers.get(inst.id)
+          end
+        end.flatten
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+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)
+            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/sparkle_formation.rb

@@ -1,15 +1,34 @@
 require 'chef/mash'
 require 'attribute_struct'
 require 'knife-cloudformation/sparkle_attribute'
+require 'knife-cloudformation/utils'
 
 AttributeStruct.camel_keys = true
 
 module KnifeCloudformation
   class SparkleFormation
+
+    include KnifeCloudformation::Utils::AnimalStrings
+
     class << self
 
       attr_reader :dynamics
-      
+      attr_reader :components_path
+      attr_reader :dynamics_path
+
+      def custom_paths
+        @_paths ||= {}
+        @_paths
+      end
+
+      def components_path=(path)
+        custom_paths[:sparkle_path] = path
+      end
+
+      def dynamics_path=(path)
+        custom_paths[:dynamics_directory] = path
+      end
+
       def compile(path)
         formation = self.instance_eval(IO.read(path), path, 1)
         formation.compile._dump
@@ -36,7 +55,7 @@ module KnifeCloudformation
         @loaded_dynamics.uniq!
         true
       end
-      
+
       def dynamic(name, &block)
         @dynamics ||= Mash.new
         @dynamics[name] = block
@@ -50,17 +69,29 @@ module KnifeCloudformation
           raise "Failed to locate requested dynamic block for insertion: #{dynamic_name} (valid: #{@dynamics.keys.sort.join(', ')})"
         end
       end
+
+      def from_hash(hash)
+        struct = AttributeStruct.new
+        struct._camel_keys_set(:auto_discovery)
+        struct._load(hash)
+        struct._camel_keys_set(nil)
+        struct
+      end
     end
-    
+
     attr_reader :name
     attr_reader :sparkle_path
     attr_reader :components
     attr_reader :load_order
-    
+
     def initialize(name, options={})
       @name = name
-      @sparkle_path = options[:sparkle_path] || File.join(Dir.pwd, 'cloudformation/components')
-      @dynamics_directory = options[:dynamics_directory] || File.join(File.dirname(@sparkle_path), 'dynamics')
+      @sparkle_path = options[:sparkle_path] ||
+        self.class.custom_paths[:sparkle_path] ||
+        File.join(Dir.pwd, 'cloudformation/components')
+      @dynamics_directory = options[:dynamics_directory] ||
+        self.class.custom_paths[:dynamics_directory] ||
+        File.join(File.dirname(@sparkle_path), 'dynamics')
       self.class.load_dynamics!(@dynamics_directory)
       @components = Mash.new
       @load_order = []
@@ -84,7 +115,7 @@ module KnifeCloudformation
       @overrides = self.class.build(&block)
       self
     end
-    
+
     # Returns compiled Mash instance
     def compile
       compiled = AttributeStruct.new

data/lib/knife-cloudformation/utils.rb

@@ -0,0 +1,69 @@
+module KnifeCloudformation
+  module Utils
+    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
+
+    module Ssher
+      def remote_file_contents(address, user, path, ssh_opts={})
+        require 'net/sftp'
+        content = nil
+        Net::SFTP.start(address, user, ssh_opts) do |con|
+          con.file.open(path) do |f|
+            content = f.read
+          end
+        end
+        content
+      end
+    end
+  end
+end