sparkle_formation 0.2.2 → 0.2.4

data/bin/aws_resources

@@ -1,85 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'json'
-require 'nokogiri'
-require 'fileutils'
-
-STORE = '/tmp/aws-cfn-docs'
-
-unless(File.directory?(STORE))
-  FileUtils.mkdir_p(STORE)
-  Dir.chdir(STORE) do
-    unless(system('wget -q -r -l 1 -A "aws-*" "http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html"'))
-      puts "FAILED: Documentation fetching failed!"
-      exit -1
-    end
-  end
-end
-
-aws_resources = {}
-
-Dir.glob(File.join(STORE, '**/*.html')).each do |path|
-  resource = nil
-  begin
-    file = Nokogiri::HTML(File.open(path, 'r'))
-    type = file.css('h1.topictitle').text.strip
-    if(type.include?(' '))
-      next
-    end
-    resource = file.css('div.variablelist').first
-    if(resource)
-      names = resource.css('dt').css('span').map(&:text).map(&:strip)
-      types = resource.css('dd p').map(&:text).find_all do |x|
-        x.include?('Type')
-      end.map do |x|
-        if(x.downcase.match(/(\s|^)list(\s|$)/))
-          'Array'
-        elsif(x.include?('Type: String'))
-          'String'
-        elsif(x.include?('Type: Boolean'))
-          'Boolean'
-        elsif(x.include?('Type: Integer'))
-          'Number'
-        elsif(x.include?('Type:') && x.include?('JSON') && x.include?('document'))
-          'JSON'
-        else
-          'Unknown'
-        end
-      end
-      requires = resource.css('dd p').map(&:text).find_all do |x|
-        x.include?('Required:')
-      end.map do |x|
-        x.include?('No') ? false : true
-      end
-      descriptions = resource.css('dd').map do |dd|
-        dd.css('p').first.text.strip
-      end.map do |string|
-        string.split("\n").map(&:strip).join(' ')
-      end
-      property_hashes = names.size.times.map do |i|
-        [names[i], {:description => descriptions[i], :required => requires[i], :type => types[i]}]
-      end
-      aws_resources[type] = {
-        :properties => names,
-        :full_properties => Hash[property_hashes]
-      }
-    else
-      resource = file.css('div.informaltable')
-      if(resource)
-        aws_resources[type] = {
-          :properties => resource.css('tr').map{|tr|
-            item = tr.css('td').first
-            item ? item.text.strip : nil
-          }.compact
-        }
-      else
-        next
-      end
-    end
-    aws_resources[type][:path] = File.basename(path)
-  end
-end
-
-require 'pp'
-
-pp aws_resources

data/bin/heat_resources

@@ -1,33 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'json'
-require 'nokogiri'
-require 'fileutils'
-
-STORE = '/tmp/openstack-heat-docs'
-
-unless(File.directory?(STORE))
-  FileUtils.mkdir_p(STORE)
-  Dir.chdir(STORE) do
-    unless(system('wget -q "http://docs.openstack.org/developer/heat/template_guide/openstack.html"'))
-      puts "FAILED: Documentation fetching failed!"
-      exit -1
-    end
-  end
-end
-
-file = Nokogiri::HTML(File.open(File.join(STORE, 'openstack.html'), 'r'))
-
-resources = Hash[
-  file.css('div.section[id*="json"]').css('pre.literal-block').map do |node|
-    [
-      node.text.scan(/Type":.*"(.+?)"/).flatten.first,
-      node.text.scan(/Properties.*?\{(.+)$/m).flatten.first.
-      strip.split("\n").map{|z| z.split(' ')}.flatten.find_all{|z| !z.scan(/^[A-Za-z0-9_"]+:$/).empty?}.map{|z| z.tr('":', '')}
-    ]
-  end
-]
-
-require 'pp'
-
-pp resources

data/docs/README.md

@@ -1,177 +0,0 @@
-## Overview
-SparkleFormation is a Ruby DSL for programatically composing
-[AWS Cloudformation][cloudformation], [OpenStack Heat][heat]
-provisioning templates for the purpose of interacting with cloud
-infrastructure orchestration APIs.
-
-SparkleFormation templates describe the creation and configuration of
-collections of cloud resources (a stack) as code, allowing you to
-provision stacks in a predictable and repeatable manner. Stacks can be
-managed as single unit, allowing you to create, modify, or delete
-collections of resources via a single API call.
-
-SparkleFormation composes templates in the native cloud orchestration
-formats for AWS, Rackspace, Google Compute, and similar services.
-
-## Table of Contents
-
-- [Getting Started](#getting-started)
-- [What It Looks Like](#what-it-looks-like)
-- [Building Blocks](building-blocks.md)
-  - [Components](building-blocks.md#components)
-  - [Dynamics](building-blocks.md#dynamics)
-  - [Registries](building-blocks.md#registries)
-- [Template Anatomy](anatomy.md)
-  - [Parameters](anatomy.md#parameters)
-  - [Resources](anatomy.md#resources)
-  - [Mappings](anatomy.md#mappings)
-  - [Outputs](anatomy.md#outputs)
-- [Intrinsic Functions](functions.md)
-  - [Ref](functions.md#ref)
-  - [Attr](functions.md#attr)
-  - [Join](functions.md#join)
-- [Universal Properties](properties.md)
- - [Tags](properties.md#tags)
-
-## Getting Started
-### Gemfile
-SparkleFormation is in active development. To access all the features
-detailed in the documentation (using the knife plugin CLI), you should
-install the plugin and supporting libraries from git:
-
-```ruby
-gem 'fog', :git => 'https://github.com/chrisroberts/fog.git', :ref => 'feature/orchestration'
-gem 'fog-core', :git => 'https://github.com/chrisroberts/fog-core.git', :ref => 'feature/orchestration'
-gem 'knife-cloudformation', :git => 'https://github.com/heavywater/knife-cloudformation.git', :ref => 'feature/fog-model'
-```
-
-The Knife Cloudformation gem is only needed for stack provisioning via
-knife. You could also upload SparkleFormation generated templates to AWS via the WebUI.
-
-### Knife Config
-To use Knife for provisioning, you will need to add the following to
-your `knife.rb` file:
-
-```ruby
-knife[:aws_access_key_id] = ENV['AWS_ACCESS_KEY_ID']
-knife[:aws_secret_access_key] = ENV['AWS_SECRET_ACCESS_KEY']
-
-[:cloudformation, :options].inject(knife){ |m,k| m[k] ||= Mash.new }
-knife[:cloudformation][:options][:disable_rollback] = ENV['AWS_CFN_DISABLE_ROLLBACK'].to_s.downcase == 'true'
-knife[:cloudformation][:options][:capabilities] = ['CAPABILITY_IAM']
-knife[:cloudformation][:processing] = true
-knife[:cloudformation][:credentials] = {
-  :aws_access_key_id => knife[:aws_access_key_id],
-  :aws_secret_access_key => knife[:aws_secret_access_key]
-}
-```
-
-| Attribute                                        | Function                                                                                                       |
-|--------------------------------------------------|----------------------------------------------------------------------------------------------------------------|
-| `[:cloudformation][:options][:disable_rollback]` | Disables rollback if stack is unsuccessful. Useful for debugging.                                              |
-| `[:cloudformation][:credentials]`                | Credentials for a user that is allowed to create stacks.                                                       |
-| `[:cloudformation][:options][:capabilities]`     | Enables IAM creation (AWS only). Options are `nil` or `['CAPABILITY_IAM']`                                     |
-| `[:cloudformation][:processing]`                 | Enables processing SparkleFormation templates (otherwise knife cloudformation will expect a JSON CFN template. |
-
-## What it Looks Like
-Below is a basic SparkleFormation template which would provision an
-elastic load balancer forwarding port 80 to an autoscaling group of
-ec2 instances.
-
-```ruby
-SparkleFormation.new('website') do
-
-  set!('AWSTemplateFormatVersion', '2010-09-09')
-
-  description 'Supercool Website'
-
-  resources.cfn_user do
-    type 'AWS::IAM::User'
-    properties.path '/'
-    properties.policies _array(
-      -> {
-        policy_name 'cfn_access'
-        policy_document.statement _array(
-          -> {
-            effect 'Allow'
-            action 'cloudformation:DescribeStackResource'
-            resource '*'
-          }
-        )
-      }
-    )
-  end
-
-  resources.cfn_keys do
-    type 'AWS::IAM::AccessKey'
-    properties.user_name ref!(:cfn_user)
-  end
-
-  parameters.web_nodes do
-    type 'Number'
-    description 'Number of web nodes for ASG.'
-    default 2
-  end
-
-  resources.website_autoscale do
-    type 'AWS::AutoScaling::AutoScalingGroup'
-    properties do
-      availability_zones({'Fn::GetAZs' => ''})
-      launch_configuration_name ref!(:website_launch_config)
-      min_size ref!(:web_nodes)
-      max_size ref!(:web_nodes)
-    end
-  end
-
-  resources.website_launch_config do
-    type 'AWS::AutoScaling::LaunchConfiguration'
-    properties do
-      image_id 'ami-123456'
-      instance_type 'm3.medium'
-    end
-  end
-
-  resources.website_elb do
-    type 'AWS::ElasticLoadBalancing::LoadBalancer'
-    properties do
-      availability_zones._set('Fn::GetAZs', '')
-      listeners _array(
-        -> {
-          load_balancer_port '80'
-          protocol 'HTTP'
-          instance_port '80'
-          instance_protocol 'HTTP'
-        }
-      )
-      health_check do
-        target 'HTTP:80/'
-        healthy_threshold '3'
-        unhealthy_threshold '3'
-        interval '5'
-        timeout '15'
-      end
-    end
-  end
-end
-```
-
-This template is 74 lines long (with generous spacing for
-readability). The [json template this
-renders](examples/template_json/website.json) is 88 lines, without
-spacing). This can be improved, though. SparkleFormation allows you to
-create resusable files such that the above template can become :
-
-```ruby
-SparkleFormation.new(:website).load(:base).overrides do
-
-  description 'Supercool Website'
-
-  dynamic!(:autoscale, 'website', :nodes => 2)
-  dynamic!(:launch_config, 'website', :image_id => 'ami-123456', :instance_type => 'm3.medium')
-  dynamic!(:elb, 'website')
-
-end
-```
-
-[cloudformation]: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html
-[heat]: http://docs.openstack.org/developer/heat/template_guide/index.html

data/docs/anatomy.md

@@ -1,203 +0,0 @@
-## Template Anatomy
-
-### Parameters
-Parameters are prompts for stack specific values. A default may be
-specified, but is not required. Every parameter must have a value at runtime.
-
-In the Getting Started example we had one parameter, `web_nodes` which
-set the min and max for the autoscaling group:
-
-```ruby
-parameters.web_nodes do
-  type 'Number'
-  description 'Number of web nodes for ASG.'
-  default 2
-end
-```
-
-Every parameter must have a type and a description. Available types are `String`,
-`Number` (an integer), and `CommaDelimitedList` (an array of
-strings, as-in: `['alpha', 'beta', '1', 2']`). The descriptions is a
-string describing the resource. 
-
-Parameters support optional default values, declared as
-above. An array of accepted values may be set, as well:
-
-```ruby
-parameters.web_nodes do
-  type 'Number'
-  description 'Number of web nodes for ASG.'
-  default 2
-  allowed_values [1, 2, 3, 5]
-end
-```
-
-### Resources
-Resources are the infrastructure resources that are provisioned with
-the stack. Every resource must have a type that corresponds to a
-supported cloud resource. Resources typically have a properties hash
-that configures the resource. Some resources also have metadata. For
-the complete list of required and optional options, see the
-individual resource documentation.
-
-Resource availability is not consistent across
-providers. SparkleFormation's resources support is based on AWS, and
-not all resources will be available on other platforms. See the
-[resource reference](resource-reference.md) table for more information.
-
-The prior example included the following resources:
-- cfn_user: The IAM user for the stack, which will be used to
-provision stack resources.
-
-```ruby
-resources.cfn_user do
-  type 'AWS::IAM::User'
-  properties.path '/'
-  properties.policies _array(
-    -> {
-      policy_name 'cfn_access'
-      policy_document.statement _array(
-        -> {
-          effect 'Allow'
-          action 'cloudformation:DescribeStackResource'
-          resource '*' 
-        }
-      )
-    }
-  )
-end
-```
-
-- cfn_key: The IAM keys for the stack IAM user.
-
-```ruby
-resources.cfn_keys do
-  type 'AWS::IAM::AccessKey'
-  properties.user_name ref!(:cfn_user)
-end
-```
-
-- website_asg: The autoscaling group containing website nodes. The
-size of the autoscaling group is set to the value of the web_nodes
-parameter. 
-
-```ruby
-resources.website_autoscale do
-  type 'AWS::AutoScaling::AutoScalingGroup'
-  properties do
-    availability_zones({'Fn::GetAZs' => ''})
-    launch_configuration_name ref!(:website_launch_config)
-    min_size ref!(:web_nodes)
-    max_size ref!(:web_nodes)
-  end
-end
-```
-
-- website_launch_configuration: The launch configuration for
-website_asg nodes. The AMI image ID and instance type (size) are
-required. 
-
-```ruby
-resources.website_launch_config do
-  type 'AWS::AutoScaling::LaunchConfiguration'
-  properties do
-    image_id 'ami-123456'
-    instance_type 'm3.medium'
-  end
-end
-```
-
-- website_elb: The elastic load balancer for the website. The
-listeners array configures port forwarding. The health check
-configures the load balancer health check target and thresholds.
-
-```ruby
-resources.website_elb do
-  type 'AWS::ElasticLoadBalancing::LoadBalancer'
-  properties do
-    availability_zones._set('Fn::GetAZs', '')
-    listeners _array(
-      -> {
-        load_balancer_port '80'
-        protocol 'HTTP'
-        instance_port '80'
-        instance_protocol 'HTTP'
-      }
-    )
-    health_check do
-      target 'HTTP:80/'
-      healthy_threshold '3'
-      unhealthy_threshold '3'
-      interval '5'
-      timeout '15'
-    end
-  end
-end
-```
-
-### Mappings
-Mappings allow you to create key/value pairs which can be referenced
-at runtime. This is useful for things like an image id that differs
-by region or environment. 
-
-Mappings for the 2014.09 Amazon Linux PV Instance Store 64-bit AMIs
-for each US region:
-
-```ruby
-mappings.region_map do
-  set!('us-east-1', :ami => 'ami-8e852ce6')
-  set!('us-west-1', :ami => 'ami-03a8a146')
-  set!('us-west-2', :ami => 'ami-f786c6c7')
-end
-```
-
-These can be referenced, in turn, with the following:
-
-```ruby
-map!(:region_map, ref!('AWS::Region'), :ami)
-```
-
-'AWS::Region' is a psuedo parameter. We could also perform a lookup
-based on a parameter we provide, e.g. an instance size based on the environment:
-
-```ruby
-parameters.environment do
-  type 'String'
-  allowed_values ['development', 'staging', 'production']                
-end
-
-mappings.instance_size do
-  set!('development', :instance => 'm3.small')
-  set!('staging', :instance => 'm3.medium')
-  set!('production', :instance => 'm3.large')
-end
-
-resources.website_launch_config do
-  type 'AWS::AutoScaling::LaunchConfiguration'
-  properties do
-    image_id map!(:region_map, 'AWS::Region', :ami)
-    instance_type map!(:instance_size, ref!(:environment), :instance)
-  end
-end
-```
-
-### Outputs
-Outputs provide metadata for the stack, as key/value pairs within an
-outputs block. Note that this block lives outside the resource
-blocks. This will retrieve the DNSName attribute for our load
-balancer, and provide it as a value for an 'Elb Dns' output:
-
-```ruby
-outputs do
-  elb_dns do
-    value attr!(:website_elb, 'DNSName')
-    description "Website ELB DNS name"
-  end
-end
-```
-
-Outputs are not simply informational. You can interact with them
-during [provisioning](provisioning.md#knife-cloudformation) using the [knife-cloudformation
-plugin](https://rubygems.org/gems/knife-cloudformation). 
-
-