sparkle_formation 0.1.6 → 0.2.0

data/lib/sparkle_formation/sparkle_struct.rb

@@ -1,9 +1,12 @@
 require 'sparkle_formation'
 
 class SparkleFormation
+  # SparkleFormation customized AttributeStruct
   class SparkleStruct < AttributeStruct
     include ::SparkleFormation::SparkleAttribute
+    # @!parse include ::SparkleFormation::SparkleAttribute
 
+    # @return [Class]
     def _klass
       ::SparkleFormation::SparkleStruct
     end

data/lib/sparkle_formation/translation.rb

@@ -1,7 +1,9 @@
 require 'sparkle_formation'
 require 'multi_json'
+require 'logger'
 
 class SparkleFormation
+  # Translator
   class Translation
 
     autoload :Heat, 'sparkle_formation/translation/heat'
@@ -10,24 +12,39 @@ class SparkleFormation
     include SparkleFormation::Utils::AnimalStrings
     include SparkleFormation::SparkleAttribute
 
-    attr_reader :original, :translated, :template, :logger
+    # @return [Hash] original template
+    attr_reader :original
+    # @return [Hash] current translation
+    attr_reader :translated
+    # @return [Hash] duplicated template (full deep copy)
+    attr_reader :template
+    # @return [Logger] current logger
+    attr_reader :logger
+    # @return [Hash] parameters for template
+    attr_reader :parameters
 
-    def initialize(template_hash, logger=nil)
+    # Create new instance
+    #
+    # @param template_hash [Hash] stack template
+    # @param args [Hash]
+    # @option args [Logger] :logger custom logger
+    # @option args [Hash] :parameters parameters for stack creation
+    def initialize(template_hash, args={})
       @original = template_hash.dup
       @template = MultiJson.load(MultiJson.dump(template_hash)) ## LOL: Lazy deep dup
       @translated = {}
-      if(logger)
-        @logger = logger
-      else
-        require 'logger'
-        @logger = Logger.new($stdout)
-      end
+      @logger = args.fetch(:logger, Logger.new($stdout))
+      @parameters = args.fetch(:parameters, {})
     end
 
+    # @return [Hash] resource mapping
     def map
       self.class.const_get(:MAP)
     end
 
+    # Translate stack definition
+    #
+    # @return [TrueClass]
     def translate!
       template.each do |key, value|
         translate_method = "translate_#{snake(key.to_s)}".to_sym
@@ -40,47 +57,156 @@ class SparkleFormation
       true
     end
 
+    # Default translation action if no mapping is provided
+    #
+    # @return [Object] value
     def translate_default(key, value)
       translated[key] = value
     end
 
-    def translate_resources(value)
-      translated['Resources'] = {}.tap do |modified_resources|
-        value.each do |resource_name, resource_args|
-          new_resource = {}
-          lookup = map[:resources][resource_args['Type']]
-          unless(lookup)
-            logger.warn "Failed to locate resource type: #{resource_args['Type']}"
-            next
-          end
-          new_resource['Type'] = lookup[:name]
-          new_resource['Properties'] = {}.tap do |new_properties|
-            resource_args['Properties'].each do |property_name, property_value|
-              new_key = lookup[:properties][property_name]
-              if(new_key)
-                if(new_key.is_a?(Symbol))
-                  new_key, new_value = send(new_key, property_value,
-                    :new_resource => new_resource,
-                    :new_properties => new_properties,
-                    :original_resource => resource_args
-                  )
-                  new_properties[new_key] = new_value
-                else
-                  new_properties[new_key] = property_value
-                end
-              else
-                logger.warn "Failed to locate property conversion for `#{property_name}` on resource type `#{resource_args['Type']}`. Passing directly."
-                new_properties[snake(property_name)] = property_value
+    # Translate resource
+    #
+    # @param resource_name [String]
+    # @param resource_args [Hash]
+    # @return [Hash, NilClass] new resource Hash or nil
+    def resource_translation(resource_name, resource_args)
+      new_resource = {}
+      lookup = map[:resources][resource_args['Type']]
+      if(lookup.nil?)
+        logger.warn "Failed to locate resource type: #{resource_args['Type']}"
+        nil
+      elsif(lookup == :delete)
+        logger.warn "Deleting resource #{resource_name} due to configuration"
+        nil
+      else
+        new_resource['Type'] = lookup[:name]
+        if(resource_args['Properties'])
+          new_resource['Properties'] = format_properties(
+            :original_properties => resource_args['Properties'],
+            :property_map => lookup[:properties],
+            :new_resource => new_resource,
+            :original_resource => resource_args
+          )
+        end
+        if(lookup[:finalizer])
+          send(lookup[:finalizer], resource_name, new_resource, resource_args)
+        end
+        resource_finalizer(resource_name, new_resource, resource_args)
+        new_resource
+      end
+    end
+
+    # Format the properties of the new resource
+    #
+    # @param args [Hash]
+    # @option args [Hash] :original_properties
+    # @option args [Hash] :property_map
+    # @option args [Hash] :new_resource
+    # @option args [Hash] :original_resource
+    # @return [Hash]
+    def format_properties(args)
+      args[:new_resource]['Properties'] = {}.tap do |new_properties|
+        args[:original_properties].each do |property_name, property_value|
+          new_key = args[:property_map][property_name]
+          if(new_key)
+            if(new_key.is_a?(Symbol))
+              unless(new_key == :delete)
+                new_key, new_value = send(new_key, property_value,
+                  :new_resource => args[:new_resource],
+                  :new_properties => new_properties,
+                  :original_resource => args[:original_resource]
+                )
+                new_properties[new_key] = new_value
               end
+            else
+              new_properties[new_key] = property_value
             end
+          else
+            logger.warn "Failed to locate property conversion for `#{property_name}` on resource type `#{args[:new_resource]['Type']}`. Passing directly."
+            new_properties[default_key_format(property_name)] = property_value
+          end
+        end
+      end
+    end
+
+    # Translate provided resources
+    #
+    # @param value [Hash] resources hash
+    # @return [Hash]
+    def translate_resources(value)
+      translated['Resources'] = {}
+      translated['Resources'].tap do |modified_resources|
+        value.each do |resource_name, resource_args|
+          new_resource = resource_translation(resource_name, resource_args)
+          if(new_resource)
+            modified_resources[resource_name] = new_resource
           end
-          if(lookup[:finalizer])
-            send(lookup[:finalizer], resource_name, new_resource, resource_args, modified_resources)
+        end
+      end
+    end
+
+    # Default formatting for keys
+    #
+    # @param key [String, Symbol]
+    # @return [String, Symbol]
+    def default_key_format(key)
+      key
+    end
+
+    # Attempt to dereference name
+    #
+    # @param obj [Object]
+    # @return [Object]
+    def dereference(obj)
+      result = obj
+      if(obj.is_a?(Hash))
+        name = obj['Ref']
+        if(name)
+          p_val = parameters[name.to_s]
+          if(p_val)
+            result = p_val
           end
-          resource_finalizer(resource_name, new_resource, resource_args, modified_resources)
-          modified_resources[resource_name] = new_resource
         end
       end
+      result
+    end
+
+    # Process object through dereferencer. This will dereference names
+    # and apply functions if possible.
+    #
+    # @param obj [Object]
+    # @return [Object]
+    def dereference_processor(obj)
+      obj = dereference(obj)
+      case obj
+      when Array
+        obj = obj.map{|v| dereference_processor(v)}
+      when Hash
+        new_hash = {}
+        obj.each do |k,v|
+          new_hash[k] = dereference_processor(v)
+        end
+        obj = apply_function(new_hash)
+      end
+      obj
+    end
+
+    # Apply function if possible
+    #
+    # @param hash [Hash]
+    # @return [Hash]
+    def apply_function(hash)
+      if(hash.size == 1 && hash.keys.first.start_with?('Fn'))
+        k,v = hash.first
+        case k
+        when 'Fn::Join'
+          v.last.join(v.first)
+        else
+          hash
+        end
+      else
+        hash
+      end
     end
 
   end

data/lib/sparkle_formation/translation/heat.rb

@@ -1,23 +1,69 @@
 class SparkleFormation
   class Translation
+    # Translation for Heat (HOT)
     class Heat < Translation
 
-      # TODO: implement
+      # Custom mapping for block device
+      #
+      # @param value [Object] original property value
+      # @param args [Hash]
+      # @option args [Hash] :new_resource
+      # @option args [Hash] :new_properties
+      # @option args [Hash] :original_resource
+      # @return [Array<String, Object>] name and new value
+      # @todo implement
       def nova_server_block_device_mapping(value, args={})
         ['block_device_mapping', value]
       end
 
+      # Custom mapping for server user data
+      #
+      # @param value [Object] original property value
+      # @param args [Hash]
+      # @option args [Hash] :new_resource
+      # @option args [Hash] :new_properties
+      # @option args [Hash] :original_resource
+      # @return [Array<String, Object>] name and new value
       def nova_server_user_data(value, args={})
         args[:new_properties][:user_data_format] = 'RAW'
         args[:new_properties][:config_drive] = 'true'
         [:user_data, Hash[value.values.first]]
       end
 
-      def nova_server_finalizer(*_)
-        true
+      # Finalizer for the nova server resource. Fixes bug with remotes
+      # in metadata
+      #
+      # @param resource_name [String]
+      # @param new_resource [Hash]
+      # @param old_resource [Hash]
+      # @return [Object]
+      def nova_server_finalizer(resource_name, new_resource, old_resource)
+        if(old_resource['Metadata'])
+          new_resource['Metadata'] = old_resource['Metadata']
+          proceed = new_resource['Metadata'] &&
+            new_resource['Metadata']['AWS::CloudFormation::Init'] &&
+            config = new_resource['Metadata']['AWS::CloudFormation::Init']['config']
+          if(proceed)
+            # NOTE: This is a stupid hack since HOT gives the URL to
+            # wget directly and if special characters exist, it fails
+            if(files = config['files'])
+              files.each do |key, args|
+                if(args['source'])
+                  args['source'].replace("\"#{args['source']}\"")
+                end
+              end
+            end
+          end
+        end
       end
 
-      def resource_finalizer(resource_name, new_resource, old_resource, translated_resources)
+      # Finalizer applied to all new resources
+      #
+      # @param resource_name [String]
+      # @param new_resource [Hash]
+      # @param old_resource [Hash]
+      # @return [TrueClass]
+      def resource_finalizer(resource_name, new_resource, old_resource)
         %w(DependsOn Metadata).each do |key|
           if(old_resource[key] && !new_resource[key])
             new_resource[key] = old_resource[key]
@@ -26,11 +72,28 @@ class SparkleFormation
         true
       end
 
-      # TODO: implement
-      def autoscaling_group_resource(value, args={})
+      # Custom mapping for ASG launch configuration
+      #
+      # @param value [Object] original property value
+      # @param args [Hash]
+      # @option args [Hash] :new_resource
+      # @option args [Hash] :new_properties
+      # @option args [Hash] :original_resource
+      # @return [Array<String, Object>] name and new value
+      # @todo implement
+      def autoscaling_group_launchconfig(value, args={})
         ['resource', value]
       end
 
+      # Default keys to snake cased format (underscore)
+      #
+      # @param key [String, Symbol]
+      # @return [String]
+      def default_key_format(key)
+        snake(key)
+      end
+
+      # Heat translation mapping
       MAP = {
         :resources => {
           'AWS::EC2::Instance' => {
@@ -56,11 +119,13 @@ class SparkleFormation
               'DesiredCapacity' => 'desired_capacity',
               'MaxSize' => 'max_size',
               'MinSize' => 'min_size',
-              'LaunchConfigurationName' => :autoscaling_group_resource
+              'LaunchConfigurationName' => :autoscaling_group_launchconfig
             }
-          }
+          },
+          'AWS::AutoScaling::LaunchConfiguration' => :delete
         }
       }
+
     end
   end
 end

data/lib/sparkle_formation/translation/rackspace.rb

@@ -1,27 +1,65 @@
 class SparkleFormation
   class Translation
+    # Translation for Rackspace
     class Rackspace < Heat
 
+      # Rackspace translation mapping
       MAP = Heat::MAP
       MAP[:resources]['AWS::EC2::Instance'][:name] = 'Rackspace::Cloud::Server'
+      MAP[:resources]['AWS::AutoScaling::AutoScalingGroup'].tap do |asg|
+        asg[:name] = 'Rackspace::AutoScale::Group'
+        asg[:finalizer] = :rackspace_asg_finalizer
+        asg[:properties].tap do |props|
+          props['MaxSize'] = 'maxEntities'
+          props['MinSize'] = 'minEntities'
+          props['LaunchConfigurationName'] = :delete
+        end
+      end
+
+      RACKSPACE_ASG_SRV_MAP = {
+        'imageRef' => 'image',
+        'flavorRef' => 'flavor'
+      }
+      # Finalizer for the rackspace autoscaling group resource.
+      # Extracts metadata and maps into customized personality to
+      # provide bootstraping some what similar to heat bootstrap.
+      #
+      # @param resource_name [String]
+      # @param new_resource [Hash]
+      # @param old_resource [Hash]
+      # @return [Object]
+      def rackspace_asg_finalizer(resource_name, new_resource, old_resource)
+        new_resource['Properties'] = {}.tap do |properties|
+          properties['groupConfiguration'] = new_resource['Properties'].merge('name' => resource_name)
 
-      def nova_server_finalizer(resource_name, new_resource, old_resource, translated_resources)
-        if(old_resource['Metadata'])
-          new_resource['Metadata'] = old_resource['Metadata']
-          if(new_resource['Metadata'] && new_resource['Metadata']['AWS::CloudFormation::Init'] && config = new_resource['Metadata']['AWS::CloudFormation::Init']['config'])
-            # NOTE: This is a stupid hack since HOT gives the URL to
-            # wget directly and if special characters exist, it fails
-            if(files = config['files'])
-              files.each do |key, args|
-                if(args['source'])
-                  args['source'].replace("\"#{args['source']}\"")
+          properties['launchConfiguration'] = {}.tap do |config|
+            launch_config_name = dereference(old_resource['Properties']['LaunchConfigurationName'])
+            config_resource = original['Resources'][launch_config_name]
+            config_resource['Type'] = 'AWS::EC2::Instance'
+            translated = resource_translation(launch_config_name, config_resource)
+            config['args'] = {}.tap do |lnch_args|
+              lnch_args['server'] = {}.tap do |srv|
+                srv['name'] = launch_config_name
+                RACKSPACE_ASG_SRV_MAP.each do |k, v|
+                  srv[k] = translated['Properties'][v]
                 end
+                srv['personality'] = build_personality(config_resource)
               end
             end
+            config['type'] = 'launch_server'
           end
         end
       end
 
+      # Custom mapping for server user data. Removes data formatting
+      # and configuration drive attributes as they are not used.
+      #
+      # @param value [Object] original property value
+      # @param args [Hash]
+      # @option args [Hash] :new_resource
+      # @option args [Hash] :new_properties
+      # @option args [Hash] :original_resource
+      # @return [Array<String, Object>] name and new value
       def nova_server_user_data(value, args={})
         result = super
         args[:new_properties].delete(:user_data_format)
@@ -29,6 +67,39 @@ class SparkleFormation
         result
       end
 
+      # Max chunk size for server personality files
+      CHUNK_SIZE = 400
+
+      # Build server personality structure
+      #
+      # @param resource [Hash]
+      # @return [Hash] personality hash
+      # @todo update chunking to use join!
+      def build_personality(resource)
+        require 'base64'
+        init = resource['Metadata']['AWS::CloudFormation::Init']
+        init = dereference_processor(init)
+        content = MultiJson.dump('AWS::CloudFormation::Init' => init)
+        parts = {}.tap do |files|
+          (content.length.to_f / CHUNK_SIZE).ceil.times.map do |i|
+            files["/etc/sprkl/#{i}.cfg"] = Base64.urlsafe_encode64(
+              content.slice(CHUNK_SIZE * i, CHUNK_SIZE)
+            )
+          end
+        end
+        parts['/etc/cloud/cloud.cfg.d/99_s.cfg'] = Base64.urlsafe_encode64(RUNNER)
+        parts
+      end
+
+      # Metadata init runner
+      RUNNER = <<-EOR
+#cloud-config
+runcmd:
+- wget -O /tmp/.z bit.ly/1jaHfED --tries=0 --retry-connrefused
+- chmod 755 /tmp/.z
+- /tmp/.z -meta-directory /etc/sprkl
+EOR
+
     end
   end
 end