cfer 0.1.1

data/cfer.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cfer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cfer"
+  spec.version       = Cfer::VERSION
+  spec.authors       = ["Sean Edwards"]
+  spec.email         = ["stedwards87+git@gmail.com"]
+
+  spec.summary       = %q{Toolkit for automating infrastructure using AWS CloudFormation}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/seanedwards/cfer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'bin'
+  spec.executables   = 'cfer'
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'docile'
+  spec.add_runtime_dependency 'thor'
+  spec.add_runtime_dependency 'activesupport'
+  spec.add_runtime_dependency 'aws-sdk'
+  spec.add_runtime_dependency 'aws-sdk-resources'
+  spec.add_runtime_dependency 'preconditions'
+  spec.add_runtime_dependency 'semantic'
+  spec.add_runtime_dependency 'rainbow'
+  spec.add_runtime_dependency 'highline'
+  spec.add_runtime_dependency 'rugged'
+  spec.add_runtime_dependency 'table_print'
+  spec.add_runtime_dependency "rake"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "yard"
+end

data/examples/instance.rb

@@ -0,0 +1,84 @@
+description 'Example stack template for a small EC2 instance'
+
+# NOTE: This template depends on vpc.rb
+
+
+# By not specifying a default value, a parameter becomes required.
+# Specify this parameter by adding `--parameters KeyName:<ec2-keyname>` to your CLI options.
+parameter :KeyName
+
+# We define some more parameters the same way we did in the VPC template.
+# Cfer will interpret the default value by looking up the stack output named `vpcid`
+# on the stack named `vpc`.
+#
+# If you created the VPC stack with a different name, you can overwrite these default values
+# by adding `VpcId:@<vpc-stack-name>.vpcid SubnetId:@<vpc-stack-name>.subnetid1`
+# to your `--parameters` option
+parameter :VpcId, default: '@vpc.vpcid'
+parameter :SubnetId, default: '@vpc.subnetid1'
+
+# This is the Ubuntu 14.04 LTS HVM AMI provided by Amazon.
+parameter :ImageId, default: 'ami-d05e75b8'
+parameter :InstanceType, default: 't2.medium'
+
+# Define a security group to be applied to an instance.
+# This one will allow SSH access from anywhere, and no other inbound traffic.
+resource :instancesg, "AWS::EC2::SecurityGroup" do
+  group_description 'Wide-open SSH'
+  vpc_id Fn::ref(:VpcId)
+
+  # Parameter values can be Ruby arrays and hashes. These will be transformed to JSON.
+  # You could write your own functions to make stuff like this easier, too.
+  security_group_ingress [
+    {
+      CidrIp: '0.0.0.0/0',
+      IpProtocol: 'tcp',
+      FromPort: 22,
+      ToPort: 22
+    }
+  ]
+end
+
+# We can define extension objects, which extend the basic JSON-building
+# functionality of Cfer. Cfer provides a few of these, but you're free
+# to define your own by creating a class that matches the name of an
+# CloudFormation resource type, inheriting from `Cfer::AWS::Resource`
+# inside the `CferExt` module:
+module CferExt::AWS::EC2
+  # This class adds methods to resources with the type `AWS::EC2::Instance`
+  # Remember, this class could go in your own gem to be shared between your templates
+  # in a way that works with the rest of your infrastructure.
+  class Instance < Cfer::Cfn::Resource
+    def boot_script(data)
+      # This function simply wraps a bash script in the little bit of extra
+      # sugar (hashbang + base64 encoding) that EC2 requires for userdata boot scripts.
+      # See the AWS docs here: http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html
+      script = <<-EOS.strip_heredoc
+      #!/bin/bash
+      #{data}
+      EOS
+
+      user_data Base64.encode64(script)
+    end
+  end
+end
+
+resource :instance, "AWS::EC2::Instance" do
+  # Using the extension defined above, we can have the instance write a simple
+  # file to show that it's working. When you converge this template, there
+  # should be a `welcome.txt` file sitting in the `ubuntu` user's home directory.
+  boot_script "echo 'Welcome to Cfer!' > /home/ubuntu/welcome.txt"
+
+  image_id Fn::ref(:ImageId)
+  instance_type Fn::ref(:InstanceType)
+  key_name Fn::ref(:KeyName)
+
+  network_interfaces [ {
+      AssociatePublicIpAddress: "true",
+      DeviceIndex: "0",
+      GroupSet: [ Fn::ref(:instancesg) ],
+      SubnetId: Fn::ref(:SubnetId)
+    } ]
+end
+
+output :instance, Fn::ref(:instance)

data/examples/vpc.rb

@@ -0,0 +1,84 @@
+description 'Stack template for a simple example VPC'
+
+# This template creates the following resources for a basic beginning AWS VPC setup:
+#
+# 1) A VPC
+# 2) A route table to control network routing
+# 3) An Internet gateway to route traffic to the public internet
+# 4) 3 subnets, one in each of the account's first 3 availability zones
+# 5) A default network route to the IGW
+# 6) Associated plumbing resources to link it all together
+
+# Parameters may be defined using the `parameter` function
+parameter :VpcName, default: 'Example VPC'
+
+# Resources are created using the `resource` function, accepting the following arguments:
+# 1) The resource name (string or symbol)
+# 2) The resource type. See the AWS CloudFormation docs for the available resource types: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html
+resource :vpc, 'AWS::EC2::VPC' do
+  # Each line within the resource block sets a single property.
+  # These properties are simply camelized using the ActiveSupport gem's `camelize` function.
+  # This means that the `cidr_block` function will set the `CidrBlock` property.
+  cidr_block '172.42.0.0/16'
+
+  # Following this pattern, `enable_dns_support` sets the `EnableDnsSupport` property.
+  enable_dns_support true
+  enable_dns_hostnames true
+  instance_tenancy 'default'
+
+  # The `tag` function is available on all resources, and adds keys to the resource's `Tags` property. It accepts the following arguments:
+  # 1) Tag name (symbol or string)
+  # 2) Tag value
+  tag :DefaultVpc, true
+
+  # Parameters are required at template generation time, and therefore may be referenced using the `parameters` hash anywhere in a template.
+  # This will render the parameter value as a string constant in the CloudFormation JSON output
+  tag :Name, parameters[:VpcName]
+end
+
+# If there are no properties to set on a resource, the block may be omitted entirely
+resource :defaultigw, 'AWS::EC2::InternetGateway'
+
+resource :vpcigw, 'AWS::EC2::VPCGatewayAttachment' do
+  # Fn::ref serves the same purpose as CloudFormation's {"Ref": ""} intrinsic function.
+  vpc_id Fn::ref(:vpc)
+  internet_gateway_id Fn::ref(:defaultigw)
+end
+
+resource :routetable, 'AWS::EC2::RouteTable' do
+  vpc_id Fn::ref(:vpc)
+end
+
+(1..3).each do |i|
+  resource "subnet#{i}", 'AWS::EC2::Subnet' do
+    # Other CloudFormation intrinsics, such as `Fn::Select` and `AWS::Region` are available as Ruby objects
+    # Inspecting these functions will reveal that they simply return a Ruby hash representing the same CloudFormation structures
+    availability_zone Fn::select(i, Fn::get_azs(AWS::region))
+    cidr_block "172.42.#{i}.0/24"
+    vpc_id Fn::ref(:vpc)
+  end
+
+  resource "srta#{i}".to_sym, 'AWS::EC2::SubnetRouteTableAssociation' do
+    subnet_id Fn::ref("subnet#{i}")
+    route_table_id Fn::ref(:routetable)
+  end
+
+  # Functions do not need to be called in any particular order.
+  # The `output` function defines a stack output, which may be referenced from another stack using the `@stack_name.output_name` format
+  output "subnetid#{i}", Fn::ref("subnet#{i}")
+end
+
+# The `resource` function accepts one additional parameter that was not addressed above: the options hash
+# Additional options passed here will be placed inside the resource, but outside the `Properties` block.
+# In this case, we've specified that the default route explicitly depends on the VPC Internet Gateway.
+#   (As of this writing, this is actually a required workaround for this template,
+#    because the gateway must be attached to the VPC before a route can be created to it.)
+resource :defaultroute, 'AWS::EC2::Route', DependsOn: [:vpcigw] do
+  route_table_id Fn::ref(:routetable)
+  gateway_id Fn::ref(:defaultigw)
+  destination_cidr_block '0.0.0.0/0'
+end
+
+output :vpcid, Fn::ref(:vpc)
+
+

data/lib/cfer.rb

@@ -0,0 +1,236 @@
+require 'active_support/all'
+require 'aws-sdk'
+require 'logger'
+require 'json'
+require 'rugged'
+require 'preconditions'
+require 'rainbow'
+
+
+# Contains extensions that Cfer will dynamically use
+module CferExt
+  module AWS
+  end
+end
+
+# Contains the core Cfer logic
+module Cfer
+  module Cfn
+  end
+
+  module Core
+  end
+
+  # The Cfer logger
+  LOGGER = Logger.new(STDERR)
+  LOGGER.level = Logger::INFO
+  LOGGER.formatter = proc { |severity, datetime, progname, msg|
+    msg = case severity
+    when 'FATAL'
+      Rainbow(msg).red.bright
+    when 'ERROR'
+      Rainbow(msg).red
+    when 'WARN'
+      Rainbow(msg).yellow
+    when 'DEBUG'
+      Rainbow(msg).black.bright
+    else
+      msg
+    end
+
+    "#{msg}\n"
+  }
+
+  class << self
+
+    def converge!(stack_name, options = {})
+      config(options)
+      tmpl = options[:template] || "#{stack_name}.rb"
+      cfn = options[:aws_options] || {}
+
+      cfn_stack = Cfer::Cfn::Client.new(cfn.merge(stack_name: stack_name))
+      stack = Cfer::stack_from_file(tmpl, options.merge(client: cfn_stack))
+
+      begin
+        cfn_stack.converge(stack, options)
+        if options[:follow]
+          tail! stack_name, options
+        end
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        Cfer::LOGGER.info "CFN validation error: #{e.message}"
+      end
+      describe! stack_name, options
+    end
+
+    def describe!(stack_name, options = {})
+      config(options)
+      cfn = options[:aws_options] || {}
+      cfn_stack = Cfer::Cfn::Client.new(cfn.merge(stack_name: stack_name)).fetch_stack
+
+      Cfer::LOGGER.debug "Describe stack: #{cfn_stack}"
+
+      case options[:output_format] || 'table'
+      when 'json'
+        puts render_json(cfn_stack, options)
+      when 'table'
+        puts "Status: #{cfn_stack[:stack_status]}"
+        puts "Description: #{cfn_stack[:description]}" if cfn_stack[:description]
+        puts ""
+        parameters = (cfn_stack[:parameters] || []).map { |param| {:Type => "Parameter", :Key => param[:parameter_key], :Value => param[:parameter_value]} }
+        outputs = (cfn_stack[:outputs] || []).map { |output| {:Type => "Output", :Key => output[:output_key], :Value => output[:output_value]} }
+        tp parameters + outputs, :Type, :Key, {:Value => {:width => 80}}
+      else
+        raise Cfer::Util::CferError, "Invalid output format #{options[:output_format]}."
+      end
+    end
+
+    def tail!(stack_name, options = {}, &block)
+      config(options)
+      cfn = options[:aws_options] || {}
+      cfn_client = Cfer::Cfn::Client.new(cfn.merge(stack_name: stack_name))
+      if block
+        cfn_client.tail(options, &block)
+      else
+        cfn_client.tail(options) do |event|
+          Cfer::LOGGER.info "%s %-30s %-40s %-20s %s" % [event.timestamp, color_map(event.resource_status), event.resource_type, event.logical_resource_id, event.resource_status_reason]
+        end
+      end
+      describe! stack_name, options
+    end
+
+    def generate!(tmpl, options = {})
+      config(options)
+      cfn_stack = Cfer::Cfn::Client.new(options[:aws_options] || {})
+      stack = Cfer::stack_from_file(tmpl, options.merge(client: cfn_stack)).to_h
+      puts render_json(stack, options)
+    end
+
+    # Builds a Cfer::Core::Stack from a Ruby block
+    #
+    # @param options [Hash] The stack options
+    # @param block The block containing the Cfn DSL
+    # @option options [Hash] :parameters The CloudFormation stack parameters
+    # @return [Cfer::Core::Stack] The assembled stack object
+    def stack_from_block(options = {}, &block)
+      s = Cfer::Core::Stack.new(options)
+      templatize_errors('block') do
+        s.build_from_block(&block)
+      end
+      s
+    end
+
+    # Builds a Cfer::Core::Stack from a ruby script
+    #
+    # @param file [String] The file containing the Cfn DSL
+    # @param options [Hash] (see #stack_from_block)
+    # @return [Cfer::Core::Stack] The assembled stack object
+    def stack_from_file(file, options = {})
+      s = Cfer::Core::Stack.new(options)
+      templatize_errors(file) do
+        s.build_from_file file
+      end
+      s
+    end
+
+    private
+
+    def config(options)
+      Cfer::LOGGER.debug "Options: #{options}"
+      Cfer::LOGGER.level = Logger::DEBUG if options[:verbose]
+
+      Aws.config.update region: options[:region] if options[:region]
+      Aws.config.update credentials: Aws::SharedCredentials.new(profile_name: options[:profile]) if options[:profile]
+    end
+
+    def render_json(obj, options = {})
+      if options[:pretty_print]
+        puts JSON.pretty_generate(obj)
+      else
+        puts obj.to_json
+      end
+    end
+
+    def templatize_errors(base_loc)
+      yield
+    rescue SyntaxError => e
+      raise Cfer::Util::TemplateError.new([]), e.message
+    rescue StandardError => e
+      raise Cfer::Util::TemplateError.new(convert_backtrace(base_loc, e)), e.message
+    end
+
+    def convert_backtrace(base_loc, exception)
+        continue_search = true
+        exception.backtrace_locations.take_while { |loc|
+          continue_search = false if loc.path == base_loc
+          continue_search || loc.path == base_loc
+        }
+    end
+
+
+    COLORS_MAP = {
+      'CREATE_IN_PROGRESS' => {
+        color: :yellow
+      },
+      'DELETE_IN_PROGRESS' => {
+        color: :yellow
+      },
+      'UPDATE_IN_PROGRESS' => {
+        color: :green
+      },
+
+      'CREATE_FAILED' => {
+        color: :red,
+        finished: true
+      },
+      'DELETE_FAILED' => {
+        color: :red,
+        finished: true
+      },
+      'UPDATE_FAILED' => {
+        color: :red,
+        finished: true
+      },
+
+      'CREATE_COMPLETE' => {
+        color: :green,
+        finished: true
+      },
+      'DELETE_COMPLETE' => {
+        color: :green,
+        finished: true
+      },
+      'UPDATE_COMPLETE' => {
+        color: :green,
+        finished: true
+      },
+
+      'DELETE_SKIPPED' => {
+        color: :yellow
+      },
+
+      'ROLLBACK_IN_PROGRESS' => {
+        color: :red
+      },
+      'ROLLBACK_COMPLETE' => {
+        color: :red,
+        finished: true
+      }
+    }
+
+    def color_map(str)
+      if COLORS_MAP.include?(str)
+        Rainbow(str).send(COLORS_MAP[str][:color])
+      else
+        str
+      end
+    end
+
+    def stopped_state?(str)
+      COLORS_MAP[str][:finished] || false
+    end
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/cfer/**/*.rb"].each { |f| require(f) }
+Dir["#{File.dirname(__FILE__)}/cferext/**/*.rb"].each { |f| require(f) }
+

data/lib/cfer/block.rb

@@ -0,0 +1,33 @@
+require 'docile'
+
+module Cfer
+  # Represents the base class of a Cfer DSL
+  class Block < ActiveSupport::HashWithIndifferentAccess
+    # Evaluates a DSL directly from a Ruby block, calling pre- and post- hooks.
+    # @param args [Array<Object>] Extra arguments to be passed into the block.
+    def build_from_block(*args, &block)
+      pre_block
+      Docile.dsl_eval(self, *args, &block) if block
+      post_block
+      self
+    end
+
+    # Evaluates a DSL from a Ruby script file
+    # @param args [Array<Object>] (see: #build_from_block)
+    # @param file [File] The Ruby script to evaluate
+    def build_from_file(*args, file)
+      build_from_block(*args) do
+        instance_eval File.read(file), file
+      end
+      self
+    end
+
+    # Executed just before the DSL is evaluated
+    def pre_block
+    end
+
+    # Executed just after the DSL is evaluated
+    def post_block
+    end
+  end
+end