humidifier 0.1.0

data/lib/humidifier/props.rb

@@ -0,0 +1,127 @@
+module Humidifier
+
+  # Container for property of CFN resources
+  module Props
+
+    # Superclass for all CFN properties
+    class Base
+
+      # The list of classes that are valid beyond the normal values for each prop
+      WHITELIST = [Fn, Ref].freeze
+
+      attr_accessor :key
+      attr_reader :value
+
+      def initialize(key = nil)
+        self.key = key
+      end
+
+      # true if the property type knows how to convert its values
+      def convertable?
+        respond_to?(:convert)
+      end
+
+      # the name of the property
+      def name
+        @name ||= Utils.underscore(key)
+      end
+
+      # CFN stack syntax
+      def to_cf(value)
+        [key, Serializer.dump(value)]
+      end
+
+      # true if the given value is of a type contained in the whitelist
+      def whitelisted_value?(value)
+        WHITELIST.any? { |clazz| value.is_a?(clazz) }
+      end
+    end
+
+    # An array property
+    class ArrayProp < Base
+      def valid?(value)
+        value.is_a?(Array)
+      end
+    end
+
+    # A boolean property
+    class BooleanProp < Base
+      # converts through value == 'true'
+      def convert(value)
+        if %w[true false].include?(value)
+          puts "WARNING: Property #{name} should be a boolean, not a string"
+          value == 'true'
+        else
+          value
+        end
+      end
+
+      # true if it is a boolean
+      def valid?(value)
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      end
+    end
+
+    # A JSON property (and the default)
+    class JSONProp < Base
+      def valid?(value)
+        whitelisted_value?(value) || value.is_a?(Hash) || value.is_a?(Array)
+      end
+    end
+
+    # An integer property
+    class IntegerProp < Base
+      # converts the value through #to_i unless it is whitelisted
+      def convert(value)
+        puts "WARNING: Property #{name} should be an integer" unless valid?(value)
+        value.to_i
+      end
+
+      # true if it is whitelisted or a Fixnum
+      def valid?(value)
+        whitelisted_value?(value) || value.is_a?(Fixnum)
+      end
+    end
+
+    # A string property
+    class StringProp < Base
+      # converts the value through #to_s unless it is whitelisted
+      def convert(value)
+        puts "WARNING: Property #{name} should be a string" unless valid?(value)
+        whitelisted_value?(value) ? value : value.to_s
+      end
+
+      # true if it is whitelisted or a String
+      def valid?(value)
+        whitelisted_value?(value) || value.is_a?(String)
+      end
+    end
+
+    class << self
+      # builds the appropriate prop object from the given spec line
+      def from(spec_line)
+        key, type = parse(spec_line)
+
+        case type
+        when 'Boolean' then BooleanProp.new(key)
+        when 'Integer' then IntegerProp.new(key)
+        when 'String' then StringProp.new(key)
+        when /\[.*?\]/ then ArrayProp.new(key)
+        else JSONProp.new(key)
+        end
+      end
+
+      # parses a spec line to return a key and type
+      def parse(spec_line)
+        spec_line.strip!
+
+        if spec_line.include?(':')
+          key, type = spec_line.gsub(/,\z/, '').split(': ').map(&:strip)
+          [key[1..-2], type]
+        else
+          [nil, spec_line]
+        end
+      end
+    end
+  end
+end

data/lib/humidifier/ref.rb

@@ -0,0 +1,17 @@
+module Humidifier
+
+  # Builds CFN references
+  class Ref
+
+    attr_accessor :reference
+
+    def initialize(reference)
+      self.reference = reference
+    end
+
+    # Builds CFN syntax
+    def to_cf
+      { 'Ref' => reference }
+    end
+  end
+end

data/lib/humidifier/resource.rb

@@ -0,0 +1,108 @@
+module Humidifier
+
+  # Superclass for all AWS resources
+  class Resource
+
+    # Attributes that are available to every stack
+    COMMON_ATTRIBUTES =
+      Utils.underscored(%w[Condition CreationPolicy DeletionPolicy DependsOn Metadata UpdatePolicy])
+
+    attr_accessor :properties, *COMMON_ATTRIBUTES.values
+
+    def initialize(properties = {}, raw = false)
+      self.properties = {}
+      update(properties, raw)
+    end
+
+    # Patches method_missing to include property accessors
+    # After the first method call, builds the accessor methods to get a speed boost
+    def method_missing(name, *args)
+      if !valid_accessor?(name)
+        super
+      elsif self.class.prop?(name.to_s)
+        self.class.build_property_reader(name)
+        send(name)
+      else
+        self.class.build_property_writer(name)
+        send(name, args.first)
+      end
+    end
+
+    # Patches respond_to_missing? to include property accessors
+    def respond_to_missing?(name, *)
+      valid_accessor?(name) || super
+    end
+
+    # CFN stack syntax
+    def to_cf
+      props_cf = Utils.enumerable_to_h(properties) { |(key, value)| self.class.props[key].to_cf(value) }
+      { 'Type' => self.class.aws_name, 'Properties' => props_cf }.merge(common_attributes)
+    end
+
+    # Update a set of properties defined by the given properties hash
+    def update(properties, raw = false)
+      properties.each { |property, value| update_property(property, value, raw) }
+    end
+
+    # Update an individual property on this resource
+    def update_property(property, value, raw = false)
+      property = property.to_s
+      property = validate_property(property, raw)
+      value = validate_value(property, value, raw)
+      properties[property] = value
+    end
+
+    class << self
+      attr_accessor :aws_name, :props
+
+      # @private builds a cached method for a property reader
+      def build_property_reader(name)
+        define_method(name) do
+          properties[name.to_s]
+        end
+      end
+
+      # @private builds a cached method for a property writer
+      def build_property_writer(name)
+        define_method(name) do |value|
+          update_property(name.to_s[0..-2], value)
+        end
+      end
+
+      # true if this resource has the given property
+      def prop?(prop)
+        props.key?(prop)
+      end
+    end
+
+    private
+
+    def common_attributes
+      COMMON_ATTRIBUTES.each_with_object({}) do |(name, prop), result|
+        value = send(prop)
+        result[name] = value if value
+      end
+    end
+
+    def valid_accessor?(method)
+      (self.class.props.keys & [method.to_s, method.to_s[0..-2]]).any?
+    end
+
+    def validate_property(property, raw)
+      property = Utils.underscore(property) if raw
+      unless self.class.prop?(property)
+        raise ArgumentError, "Attempting to set invalid property for #{self.class.name}: #{property}"
+      end
+      property
+    end
+
+    def validate_value(property, value, raw)
+      prop = self.class.props[property]
+      value = prop.convert(value) if raw && prop.convertable?
+      unless prop.valid?(value)
+        raise ArgumentError, "Invalid value for #{property}: #{value.inspect}"
+      end
+      value
+    end
+  end
+end

data/lib/humidifier/sdk_payload.rb

@@ -0,0 +1,30 @@
+module Humidifier
+
+  # The payload sent to the shim methods, representing the stack and the options
+  class SdkPayload
+
+    # The maximum amount of time that Humidifier should wait for a stack to complete a CRUD operation
+    MAX_WAIT = 180
+
+    attr_accessor :stack, :options, :max_wait
+
+    extend Forwardable
+    def_delegators :stack, :id=, :identifier, :name, :to_cf
+
+    def initialize(stack, options)
+      self.stack    = stack
+      self.options  = options
+      self.max_wait = options.delete(:max_wait) || MAX_WAIT
+    end
+
+    # True if the stack and options are the same as the other (used for testing)
+    def ==(other)
+      stack == other.stack && options == other.options
+    end
+
+    # Merge in options
+    def merge(new_options)
+      self.options = new_options.merge(options)
+    end
+  end
+end

data/lib/humidifier/serializer.rb

@@ -0,0 +1,18 @@
+module Humidifier
+
+  # Dumps an object to CFN syntax
+  class Serializer
+
+    class << self
+      # dumps the given object out to CFN syntax recursively
+      def dump(node)
+        case node
+        when Hash then Utils.enumerable_to_h(node) { |(key, value)| [key, dump(value)] }
+        when Array then node.map { |value| dump(value) }
+        when Ref, Fn then dump(node.to_cf)
+        else node
+        end
+      end
+    end
+  end
+end

data/lib/humidifier/sleeper.rb

@@ -0,0 +1,25 @@
+module Humidifier
+
+  # Manages waiting for stack events for v1 of the SDK
+  class Sleeper
+
+    attr_accessor :attempts
+
+    # Store attempts and wait for the block to return true
+    def initialize(attempts, &block)
+      self.attempts = attempts
+      hibernate_until(&block)
+    end
+
+    private
+
+    def hibernate_until(&block)
+      raise 'Waited too long, giving up' if attempts.zero?
+      return if yield
+
+      self.attempts -= 1
+      sleep 1
+      hibernate_until(&block)
+    end
+  end
+end

data/lib/humidifier/stack.rb

@@ -0,0 +1,66 @@
+module Humidifier
+
+  # Represents a CFN stack
+  class Stack
+
+    # Single settings on the stack
+    STATIC_RESOURCES     = Utils.underscored(%w[AWSTemplateFormatVersion Description Metadata])
+
+    # Lists of objects linked to the stack
+    ENUMERABLE_RESOURCES = Utils.underscored(%w[Conditions Mappings Outputs Parameters Resources])
+
+    attr_accessor :id, :name, *ENUMERABLE_RESOURCES.values, *STATIC_RESOURCES.values
+
+    def initialize(opts = {})
+      self.name = opts[:name]
+      self.id   = opts[:id]
+
+      ENUMERABLE_RESOURCES.values.each { |prop| send(:"#{prop}=", opts.fetch(prop, {})) }
+      STATIC_RESOURCES.values.each { |prop| send(:"#{prop}=", opts[prop]) }
+    end
+
+    # Add a resource to the stack
+    def add(name, resource)
+      resources[name] = resource
+    end
+
+    # The identifier used by the shim to find the stack in CFN, prefers id to name
+    def identifier
+      id || name
+    end
+
+    # A string representation of the stack that's valid for CFN
+    def to_cf
+      JSON.pretty_generate(enumerable_resources.merge(static_resources))
+    end
+
+    %i[condition mapping output parameter].each do |resource_type|
+      define_method(:"add_#{resource_type}") do |name, opts = {}|
+        send(:"#{resource_type}s")[name] = Humidifier.const_get(resource_type.capitalize).new(opts)
+      end
+    end
+
+    AwsShim::STACK_METHODS.each do |method|
+      define_method(method) { |opts = {}| AwsShim.send(method, SdkPayload.new(self, opts)) }
+    end
+
+    private
+
+    def enumerable_resources
+      ENUMERABLE_RESOURCES.each_with_object({}) do |(name, prop), list|
+        resources = send(prop)
+        next if resources.empty?
+        list[name] = Utils.enumerable_to_h(resources) do |resource_name, resource|
+          [resource_name, resource.to_cf]
+        end
+      end
+    end
+
+    def static_resources
+      STATIC_RESOURCES.each_with_object({}) do |(name, prop), list|
+        resource = send(prop)
+        list[name] = resource if resource
+      end
+    end
+  end
+end

data/lib/humidifier/utils.rb

@@ -0,0 +1,21 @@
+module Humidifier
+
+  # Dumps an object to CFN syntax
+  module Utils
+
+    class << self
+      # back-supporting ruby 2.0's lack of Enumerable#to_h
+      def enumerable_to_h(enumerable)
+        enumerable.each_with_object({}) do |item, result|
+          key, value = yield item
+          result[key] = value
+        end
+      end
+
+      # a frozen hash of the given names mapped to their underscored version
+      def underscored(names)
+        names.each_with_object({}) { |name, map| map[name] = underscore(name).to_sym }.freeze
+      end
+    end
+  end
+end

data/lib/humidifier/version.rb

@@ -0,0 +1,4 @@
+module Humidifier
+  # Gem version
+  VERSION = '0.1.0'.freeze
+end

data/lib/humidifier.rb

@@ -0,0 +1,50 @@
+require 'forwardable'
+require 'json'
+require 'pathname'
+
+require 'humidifier/humidifier'
+require 'humidifier/utils'
+
+require 'humidifier/fn'
+require 'humidifier/ref'
+require 'humidifier/props'
+
+require 'humidifier/aws_shim'
+require 'humidifier/condition'
+require 'humidifier/loader'
+require 'humidifier/mapping'
+require 'humidifier/output'
+require 'humidifier/parameter'
+require 'humidifier/resource'
+require 'humidifier/sdk_payload'
+require 'humidifier/serializer'
+require 'humidifier/sleeper'
+require 'humidifier/stack'
+require 'humidifier/version'
+
+# container module for all gem classes
+module Humidifier
+  class << self
+    # convenience method for calling cloudformation functions
+    def fn
+      Fn
+    end
+
+    # convenience method for creating references
+    def ref(reference)
+      Ref.new(reference)
+    end
+
+    # the list of all registered resources
+    def registry
+      @registry ||= {}
+    end
+
+    # convenience method for finding classes by AWS name
+    def [](aws_name)
+      registry[aws_name]
+    end
+  end
+end
+
+Humidifier::Loader.load

data/specs/ApiGateway-Account.cf

@@ -0,0 +1,6 @@
+{
+  "Type" : "AWS::ApiGateway::Account",
+  "Properties" : {
+    "CloudWatchRoleArn" : String
+  }
+}

data/specs/ApiGateway-ApiKey.cf

@@ -0,0 +1,9 @@
+{
+  "Type" : "AWS::ApiGateway::ApiKey",
+  "Properties" : {
+    "Description" : String,
+    "Enabled" : Boolean,
+    "Name" : String,
+    "StageKeys" : [ StageKey, ... ]
+  }
+}

data/specs/ApiGateway-Authorizer.cf

@@ -0,0 +1,13 @@
+{
+  "Type" : "AWS::ApiGateway::Authorizer",
+  "Properties" : {
+    "AuthorizerCredentials" : String,
+    "AuthorizerResultTtlInSeconds" : Integer,
+    "AuthorizerUri" : String,
+    "IdentitySource" : String,
+    "IdentityValidationExpression" : String,
+    "Name" : String,
+    "RestApiId" : String,
+    "Type" : String
+  }
+}

data/specs/ApiGateway-BasePathMapping.cf

@@ -0,0 +1,9 @@
+{
+  "Type" : "AWS::ApiGateway::BasePathMapping",
+  "Properties" : {
+    "BasePath" : String,
+    "DomainName" : String,
+    "RestApiId" : String,
+    "Stage" : String
+  }
+}

data/specs/ApiGateway-ClientCertificate.cf

@@ -0,0 +1,6 @@
+{
+  "Type" : "AWS::ApiGateway::ClientCertificate",
+  "Properties" : {
+    "Description" : String
+  }
+}

data/specs/ApiGateway-Deployment.cf

@@ -0,0 +1,9 @@
+{
+  "Type" : "AWS::ApiGateway::Deployment",
+  "Properties" : {
+    "Description" : String,
+    "RestApiId" : String,
+    "StageDescription" : StageDescription,
+    "StageName" : String
+  }
+}

data/specs/ApiGateway-Method.cf

@@ -0,0 +1,15 @@
+{
+  "Type" : "AWS::ApiGateway::Method",
+  "Properties" : {
+    "ApiKeyRequired" : Boolean,
+    "AuthorizationType" : String,
+    "AuthorizerId" : String,
+    "HttpMethod" : String,
+    "Integration" : Integration,
+    "MethodResponses" : [ MethodResponse, ... ],
+    "RequestModels" : { String:String, ... },
+    "RequestParameters" : { String:Boolean, ... },
+    "ResourceId" : String,
+    "RestApiId" : String
+  }
+}

data/specs/ApiGateway-Model.cf

@@ -0,0 +1,10 @@
+{
+  "Type" : "AWS::ApiGateway::Model",
+  "Properties" : {
+    "ContentType" : String,
+    "Description" : String,
+    "Name" : String,
+    "RestApiId" : String,
+    "Schema" : String
+  }
+}

data/specs/ApiGateway-Resource.cf

@@ -0,0 +1,8 @@
+{
+  "Type" : "AWS::ApiGateway::Resource",
+  "Properties" : {
+    "ParentId" : String,
+    "PathPart" : String,
+    "RestApiId" : String
+  }
+}

data/specs/ApiGateway-RestApi.cf

@@ -0,0 +1,12 @@
+{
+  "Type" : "AWS::ApiGateway::RestApi",
+  "Properties" : {
+    "Body" : String,
+    "BodyS3Location" : S3Location,
+    "CloneFrom" : String,
+    "Description" : String,
+    "FailOnWarnings" : Boolean,
+    "Name" : String,
+    "Parameters" : [ String, ... ]
+  }
+}

data/specs/ApiGateway-Stage.cf

@@ -0,0 +1,14 @@
+{
+  "Type" : "AWS::ApiGateway::Stage",
+  "Properties" : {
+    "CacheClusterEnabled" : Boolean,
+    "CacheClusterSize" : String,
+    "ClientCertificateId" : String,
+    "DeploymentId" : String,
+    "Description" : String,
+    "MethodSettings" : [ MethodSetting ],
+    "RestApiId" : String,
+    "StageName" : String,
+    "Variables" : { String:String, ... }
+  }
+}

data/specs/AutoScaling-AutoScalingGroup.cf

@@ -0,0 +1,21 @@
+{
+   "Type" : "AWS::AutoScaling::AutoScalingGroup",
+   "Properties" : {
+      "AvailabilityZones" : [ String, ... ],
+      "Cooldown" : String,
+      "DesiredCapacity" : String,
+      "HealthCheckGracePeriod" : Integer,
+      "HealthCheckType" : String,
+      "InstanceId" : String,
+      "LaunchConfigurationName" : String,
+      "LoadBalancerNames" : [ String, ... ],
+      "MaxSize" : String,
+      "MetricsCollection" : [ MetricsCollection, ... ]
+      "MinSize" : String,
+      "NotificationConfigurations" : [ NotificationConfigurations, ... ],
+      "PlacementGroup" : String,
+      "Tags" : [ Auto Scaling Tag, ..., ],
+      "TerminationPolicies" : [ String, ..., ],
+      "VPCZoneIdentifier" : [ String, ... ]
+   }
+}

data/specs/AutoScaling-LaunchConfiguration.cf

@@ -0,0 +1,22 @@
+{
+   "Type" : "AWS::AutoScaling::LaunchConfiguration",
+   "Properties" : {
+      "AssociatePublicIpAddress" : Boolean,
+      "BlockDeviceMappings" : [ BlockDeviceMapping, ... ],
+      "ClassicLinkVPCId" : String,
+      "ClassicLinkVPCSecurityGroups" : [ String, ... ],
+      "EbsOptimized" : Boolean,
+      "IamInstanceProfile" : String,
+      "ImageId" : String,
+      "InstanceId" : String,
+      "InstanceMonitoring" : Boolean,
+      "InstanceType" : String,
+      "KernelId" : String,
+      "KeyName" : String,
+      "PlacementTenancy" : String,
+      "RamDiskId" : String,
+      "SecurityGroups" : [ SecurityGroup, ... ],
+      "SpotPrice" : String,
+      "UserData" : String
+   }
+}

data/specs/AutoScaling-LifecycleHook.cf

@@ -0,0 +1,12 @@
+{
+  "Type" : "AWS::AutoScaling::LifecycleHook",
+  "Properties" : {
+    "AutoScalingGroupName" : String,
+    "DefaultResult" : String,
+    "HeartbeatTimeout" : Integer,
+    "LifecycleTransition" : String,
+    "NotificationMetadata" : String,
+    "NotificationTargetARN" : String,
+    "RoleARN" : String
+  }
+}

data/specs/AutoScaling-ScalingPolicy.cf

@@ -0,0 +1,14 @@
+{
+   "Type" : "AWS::AutoScaling::ScalingPolicy",
+   "Properties" : {
+      "AdjustmentType" : String,
+      "AutoScalingGroupName" : String,
+      "Cooldown" : String,
+      "EstimatedInstanceWarmup" : Integer,
+      "MetricAggregationType" : String,
+      "MinAdjustmentMagnitude" : Integer,
+      "PolicyType" : String,
+      "ScalingAdjustment" : Integer,
+      "StepAdjustments" : [ StepAdjustments, ... ]
+   }
+}