cfer-provisioning 0.1.0 → 0.2.0.pre.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0aa1b48f4bffa706855d32177faaa55a4476736b
-  data.tar.gz: 0ada7fd8a30530eaafe67a570f82a04f41fa45df
+  metadata.gz: 407c0fc6b3f6927a53f759f123c43d6ff9824a61
+  data.tar.gz: 762144fd8522c9c29ff09e5fb3678dceeed3c826
 SHA512:
-  metadata.gz: f61e01d00c87ea8b1d416e923e67703461ad1acb15818d5677d9d4d54bfd52435f8c7e23c4ccb22f9dee431ccb4cb1f0f6fe3c9ab1e3f509df2f5879e8caa8af
-  data.tar.gz: 9513daf68578dc9356eb928cde89944cb3fcdd5b73d2393df47f6016f436a21f30362063ebaea92d867db7264ecef9cb7a74d8064b0d99cfb49002d57fa25949
+  metadata.gz: ba2d1791fe5e28fdf3bb1f2c21419129320400ff0a76283fb28c7bce3fa8345792bd2b40f9596967962f791e4c4446d913d9a365db388d8ecb194b409946f72b
+  data.tar.gz: f4dd4137445217bf4737b1255229fc3dd9b05dbd198f635124a8e93ade1c4e3b9104d639ba69c7fcfc87fc9730d290f02f52f4f16bdc3e7570233ceba7c5b7b4

data/cfer-provisioning.gemspec

@@ -21,8 +21,9 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", '~> 3.4'
-  spec.add_development_dependency "serverspec", '~> 2.34'
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "serverspec"
 
-  spec.add_runtime_dependency 'cfer', '~> 0.4'
+  spec.add_runtime_dependency 'cfer'
+  spec.add_runtime_dependency 'erubis', '~> 2.7.0'
 end

data/lib/cfer/cfizer.rb

@@ -0,0 +1,47 @@
+module Cfer
+  DEFAULT_CAPTURE_REGEXP = /C\{(?<directive>.*?)\}/
+
+  class Cfizer
+    begin
+      include Cfer::Core::Functions
+    rescue NameError => _
+      # we need to fall back to the old Cfer setup
+      include Cfer::Core
+      include Cfer::Cfn
+    end
+
+    def cfize(directive)
+      instance_eval directive
+    end
+  end
+
+  def self.cfize(text, capture_regexp: nil)
+    raise "'text' must be a string." unless text.is_a?(String)
+
+    capture_regexp ||= DEFAULT_CAPTURE_REGEXP
+
+    raise "'capture_regexp' must be a Regexp." unless capture_regexp.is_a?(Regexp)
+    raise "'capture_regexp' must include a 'contents' named 'directive'." \
+      unless capture_regexp.named_captures.key?('directive')
+
+    working = []
+    until(working[-2] == "" && working[-1] == "") do
+      if (working.size == 0)
+        working = text.partition(capture_regexp)
+      else
+        working[-1] = working[-1].partition(capture_regexp)
+        working = working.flatten
+      end
+    end
+
+    cfizer = Cfizer.new
+    Cfizer::Fn.join("", working.map do |token|
+      match = capture_regexp.match(token)
+      if (match.nil?)
+        token
+      else
+        cfizer.cfize(match['directive'])
+      end
+    end.reject { |t| t == ""})
+  end
+end

data/lib/cfer/provisioning/cfn-bootstrap.bash.erb

@@ -0,0 +1,30 @@
+#! /bin/bash -xe
+
+function error_exit
+{
+<% unless @options[:signal].nil? %>
+  /usr/local/bin/cfn-signal -s 'false' \
+    --resource '<%= @options[:signal] %>' \
+    --stack 'C{AWS.stack_name}' \
+    --region 'C{AWS.region}'
+<% end %>
+
+  exit 1
+}
+
+/usr/local/bin/cfn-init \
+  --resource '<%= @resource_name %>' \
+  --stack 'C{AWS.stack_name}' \
+  --region 'C{AWS.region}' \
+  --configsets '<%= @options[:cfn_init_config_set].join(",") %>' || error_exit 'cfn-init failed to start'
+
+<% unless @options[:cfn_hup_config_set].nil? -%>
+  /usr/local/bin/cfn-hup || error_exit 'cfn-hup failed to start'
+<% end -%>
+
+<% unless @options[:signal].nil? -%>
+  /usr/local/bin/cfn-signal -s 'true' \
+    --resource '<%= @options[:signal] %>' \
+    --stack 'C{AWS.stack_name}' \
+    --region 'C{AWS.region}'
+<% end -%>

data/lib/cfer/provisioning/cfn-bootstrap.rb

@@ -1,4 +1,7 @@
+require 'erubis'
+
 module Cfer::Provisioning
+  DEFAULT_HUP_INTERVAL_IN_MINUTES = 1
 
   def cfn_metadata
     self[:Metadata] ||= {}
@@ -11,83 +14,11 @@ module Cfer::Provisioning
 
   def cfn_init_setup(options = {})
     cfn_metadata['AWS::CloudFormation::Init'] = {}
-
-    script = [ "#!/bin/bash -xe\n" ]
-
-    script.concat [
-      "command -v cfn-init 2>&1 || {\n",
-    ]
-      script.concat case options[:flavor]
-        when :redhat, :centos, :amazon
-          [
-            "rpm -Uvh https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-latest.amzn1.noarch.rpm\n"
-          ]
-        when :ubuntu, :debian, nil
-          [
-            "apt-get update --fix-missing\n",
-            "apt-get install -y python-pip\n",
-            "pip install setuptools\n",
-            "easy_install https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-latest.tar.gz\n",
-          ]
-      end
-    script.concat [
-      "}\n"
-    ]
-
-    script.concat [
-      "# Helper function\n",
-      "function error_exit\n",
-      "{\n",
-    ]
-
-    if options[:signal]
-      script.concat [
-        "/usr/local/bin/cfn-signal",
-          " -s false",
-          " --resource '", options[:signal], "'",
-          " --stack ", Cfer::Cfn::AWS::stack_name,
-          " --region ", Cfer::Cfn::AWS::region,
-          "\n"
-        ]
-    end
-
-    script.concat [
-      "  exit 1\n",
-      "}\n"
-    ]
-
-
-    script.concat [
-      "/usr/local/bin/cfn-init",
-        " --configsets '", Cfer::Core::Fn::join(',', options[:cfn_init_config_set]) || raise('Please specify a `cfn_init_config_set`'), "'",
-        " --stack ", Cfer::Cfn::AWS::stack_name,
-        " --resource ", @name,
-        " --region ", Cfer::Cfn::AWS::region,
-        " || error_exit 'Failed to run cfn-init'\n"
-    ]
+    cfn_init_set_cloud_init(options)
 
     if options[:cfn_hup_config_set]
       cfn_hup(options)
-
-      script.concat [
-        "/usr/local/bin/cfn-hup || error_exit 'Failed to start cfn-hup'\n"
-      ]
-    end
-
-    if options[:signal]
-      script.concat [
-        "/usr/local/bin/cfn-signal",
-          " -s true",
-          " --resource '", options[:signal], "'",
-          " --stack ", Cfer::Cfn::AWS::stack_name,
-          " --region ", Cfer::Cfn::AWS::region,
-          "\n"
-        ]
     end
-
-    user_data Cfer::Core::Fn::base64(
-      Cfer::Core::Fn::join('', script)
-    )
   end
 
   def config_set(name)
@@ -152,44 +83,69 @@ module Cfer::Provisioning
 
   def cfn_hup(options)
     resource_name = @name
-    target_config_set = options[:cfn_hup_config_set] || raise('Please specify a `cfn_hup_config_set`')
+    target_config_set = options[:cfn_hup_config_set] ||
+      raise('Please specify a `cfn_hup_config_set`')
 
     cfn_init_config_set :cfn_hup, [ :cfn_hup ]
 
     cfn_init_config(:cfn_hup) do
       if options[:access_key] && options[:secret_key]
-        file '/etc/cfn/cfn-credentials', content: Cfer::Core::Fn::join('', [
-          "AWSAccessKeyId=", options[:access_key], "\n",
-          "AWSSecretKey=", options[:secret_key], "\n"
-        ]),
-        mode: '000400',
-        owner: 'root',
-        group: 'root'
+        key_content = <<-FILE.strip_heredoc
+          AWSAccessKeyId=#{options[:access_key]}
+          AWSSecretKey=#{options[:secret_key]}
+        FILE
+
+        file '/etc/cfn/cfn-credentials', content: key_content,
+          mode: '000400', owner: 'root', group: 'root'
       end
 
-      file '/etc/cfn/cfn-hup.conf', content: Cfer::Core::Fn::join('', [
-        "[main]\n",
-        "stack=", Cfer::Cfn::AWS::stack_name, "\n",
-        "region=", Cfer::Cfn::AWS::region, "\n",
-        "interval=", options[:interval] || 1, "\n"
-      ]),
-      mode: '000400',
-      owner: 'root',
-      group: 'root'
-
-      file '/etc/cfn/hooks.d/cfn-init-reload.conf', content: Cfer::Core::Fn::join('', [
-        "[cfn-auto-reloader-hook]\n",
-        "triggers=post.update\n",
-        "path=Resources.#{resource_name}.Metadata\n",
-        "action=/usr/local/bin/cfn-init",
-          " -c '", Cfer::Core::Fn::join(',', target_config_set), "'",
-          " -s ", Cfer::Cfn::AWS::stack_name,
-          " --region ", Cfer::Cfn::AWS::region,
-          " -r #{resource_name}",
-          "\n",
-        "runas=root\n"
-      ])
+      hup_conf_content = <<-FILE.strip_heredoc
+        [main]
+        stack=C{AWS.stack_name}
+        region=C{AWS.region}
+        interval=#{DEFAULT_HUP_INTERVAL_IN_MINUTES}
+      FILE
+      file '/etc/cfn/cfn-hup.conf', content: Cfer.cfize(hup_conf_content),
+        mode: '000400', owner: 'root', group: 'root'
+
+      cfn_init_reload_content = <<-FILE.strip_heredoc
+        [cfn-auto-reloader-hook]
+        triggers=post.update
+        path=Resources.#{resource_name}.Metadata
+        runas=root
+        action=/usr/local/bin/cfn-init -r #{resource_name} --region C{AWS.region} -s C{AWS.stack_name} -c '#{target_config_set.join(",")}'
+      FILE
+
+      file '/etc/cfn/hooks.d/cfn-init-reload.conf',
+        content: Cfer.cfize(cfn_init_reload_content),
+        mode: '000400', owner: 'root', group: 'root'
     end
   end
+
+  def cfn_init_set_cloud_init(options)
+    cloud_init_bootcmds << "mkdir -p /usr/local/bin"
+
+    case options[:flavor]
+    when :redhat, :centos, :amazon
+      cloud_init_bootcmds <<
+        'rpm -Uvh https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-latest.amzn1.noarch.rpm'
+    when :debian, :ubuntu, nil
+      [
+        'apt-get update --fix-missing',
+        'apt-get install -y python-pip',
+        'pip install setuptools',
+        'easy_install https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-latest.tar.gz'
+      ].each { |line| cloud_init_bootcmds << line }
+    end
+
+    cfn_script_eruby = Erubis::Eruby.new(IO.read("#{__dir__}/cfn-bootstrap.bash.erb"))
+
+    cloud_init_write_files << {
+      path: '/usr/local/bin/cfn-bootstrap.bash',
+      content: cfn_script_eruby.evaluate(resource_name: @name, options: options)
+    }
+
+    cloud_init_runcmds << "bash /usr/local/bin/cfn-bootstrap.bash"
+  end
 end
 

data/lib/cfer/provisioning/chef.rb

@@ -1,98 +1,144 @@
 module Cfer::Provisioning
+  def install_chef_solo_with_cloud_init(options = {})
+    # we can't use the cloud-init `chef` module because it expects a server/validator.
+
+    cloud_init_bootcmds <<
+      "command -v chef-client || " \
+        "curl https://www.opscode.com/chef/install.sh | " \
+          "bash -s -- -v #{options[:version] || 'latest'}"
+    cloud_init_bootcmds << "mkdir -p /etc/chef/ohai/hints"
+    cloud_init_bootcmds << "touch /etc/chef/ohai/hints/ec2.json"
+    cloud_init_bootcmds << "mkdir -p '#{options[:cookbook_path]}'"
+    cloud_init_bootcmds << "mkdir -p '#{options[:data_bag_path]}'"
+  end
 
-  def install_chef(options = {})
-    setup_set = [ :install_chef ]
-    cfn_init_config :install_chef do
-      command :install_chef, "curl https://www.opscode.com/chef/install.sh | bash -s -- -v #{options[:version] || 'latest'}"
-      command :make_ohai_hints, 'mkdir -p /etc/chef/ohai/hints && touch /etc/chef/ohai/hints/ec2.json'
-      command :make_chefdir, 'mkdir -p /var/chef/cookbooks && mkdir -p /var/chef/data_bags'
-    end
-
-    if options[:berksfile]
-      cfn_init_config :install_berkshelf do
-        file '/var/chef/berkshelf.sh', content: <<-EOF.strip_heredoc
-          export BERKSHELF_PATH=/var/chef/berkshelf
-
-          # Some cookbooks have UTF-8, and cfn-init uses US-ASCII because of reasons
-          export LANG=en_US.UTF-8
-          export RUBYOPTS="-E utf-8"
-
-          # Berkshelf seems a bit unreliable, so retry these commands a couple times.
-          if [ -e Berksfile.lock ]
-          then
-            for i in {1..3}; do /opt/chef/embedded/bin/berks update && break || sleep 15; done
-          fi
-          for i in {1..3}; do /opt/chef/embedded/bin/berks vendor /var/chef/cookbooks -b /var/chef/Berksfile && break || sleep 15; done
-        EOF
-        command :install_berkshelf, '/opt/chef/embedded/bin/gem install berkshelf --no-ri --no-rdoc'
-        command :install_git, 'apt-get install -y git'
-      end
-      setup_set.append :install_berkshelf
-    end
+  def install_berkshelf(options)
+    cloud_init_packages << 'git'
+
+    cloud_init_bootcmds << '/opt/chef/embedded/bin/gem install berkshelf --no-ri --no-rdoc'
+
+    berks_content = <<-EOF.strip_heredoc
+        # may be run before HOME is established (fixes RbReadLine bug)
+        export HOME=/root
+        export BERKSHELF_PATH=/var/chef/berkshelf
+
+        # Some cookbooks have UTF-8, and cfn-init uses US-ASCII because of reasons
+        export LANG=en_US.UTF-8
+        export RUBYOPTS="-E utf-8"
+
+        # Berkshelf seems a bit unreliable, so retry these commands a couple times.
+        if [ -e Berksfile.lock ]
+        then
+          for i in {1..3}; do
+            /opt/chef/embedded/bin/berks update && break || sleep 15
+          done
+        fi
+        for i in {1..3}; do
+          /opt/chef/embedded/bin/berks vendor '#{options[:cookbook_path]}' \
+            -b /var/chef/Berksfile && break || sleep 15
+        done
+      EOF
+
+    cloud_init_write_files << {
+      path: '/var/chef/berkshelf.sh',
+      content: berks_content,
+      permissions: '0500'
+    }
+  end
 
-    if options[:berksfile]
-      cfn_init_config :run_berkshelf do
-        file '/var/chef/Berksfile', content: options[:berksfile].strip_heredoc
-        command :run_berkshelf, 'bash -l /var/chef/berkshelf.sh', cwd: '/var/chef'
-      end
+  def emit_berksfile(options)
+    cfn_init_config :emit_berksfile do
+      file '/var/chef/Berksfile', content: Cfer.cfize(options[:berksfile].strip_heredoc),
+        mode: '000500', owner: 'root', group: 'root'
     end
-
-    cfn_init_config_set :install_chef, setup_set
   end
 
-  def set_chef_json(json = {})
-    self[:Metadata]['CferExt::Provisioning::Chef'] = json || {}
+  def run_berkshelf(options)
+    cfn_init_config :run_berkshelf do
+      command :run_berkshelf, '/var/chef/berkshelf.sh', cwd: '/var/chef'
+    end
   end
 
   def build_write_json_cmd(chef_solo_json_path)
-    Cfer::Core::Fn.join('', [
-      "mkdir -p #{File.dirname(chef_solo_json_path)} && cfn-get-metadata --region ",
-        Cfer::Cfn::AWS.region,
-        ' -s ', Cfer::Cfn::AWS.stack_name, ' -r ', @name,
-        " | python -c 'import sys; import json; print " \
-          "json.dumps(json.loads(sys.stdin.read()).get(" \
-          '"CferExt::Provisioning::Chef",  {}), sort_keys=True, indent=2)',
-        "' > #{chef_solo_json_path}"
-    ])
+    python_json_dump = [
+      'import sys; import json;',
+      'print json.dumps(json.loads(sys.stdin.read())',
+      '.get("CferExt::Provisioning::Chef", {}), sort_keys=True, indent=2)'
+    ].join('')
+
+    cmd = <<-BASH.strip_heredoc
+      mkdir -p '#{File.dirname(chef_solo_json_path)}' &&
+        cfn-get-metadata --region 'C{AWS.region}' \
+                         -s 'C{AWS.stack_name}' \
+                         -r #{@name} |
+        python -c '#{python_json_dump}' > #{chef_solo_json_path}
+    BASH
+
+    Cfer.cfize(cmd)
   end
 
   def chef_solo(options = {})
     raise "Chef already configured on this resource" if @chef
     @chef = true
 
-    chef_solo_config_path = options[:config_path] || '/etc/chef/solo.rb'
-    chef_solo_json_path = options[:json_path] || '/etc/chef/config.json'
+    must_install_berkshelf = !options[:berksfile].nil? || options[:force_berkshelf_install]
+
+    options[:config_path] ||= '/etc/chef/solo.rb'
+    options[:json_path] ||= '/etc/chef/node.json'
+    options[:cookbook_path] ||= '/var/chef/cookbooks'
+    options[:data_bag_path] ||= '/var/chef/data_bags'
+    options[:log_path] ||= '/var/log/chef-solo.log'
+
+    install_chef_solo_with_cloud_init(options) unless options[:no_install]
 
-    chef_cookbook_path = options[:cookbook_path] || '/var/chef/cookbooks'
-    chef_log_path = options[:log_path] || '/var/log/chef-client.log'
+    if must_install_berkshelf
+      install_berkshelf(options) if must_install_berkshelf # places cloud-init runners
+    end
 
-    install_chef(options) unless options[:no_install]
+    run_set = []
 
-    set_chef_json(options[:json])
-    write_json_cmd = build_write_json_cmd(chef_solo_json_path)
+    unless options[:berksfile].nil?
+      emit_berksfile(options)
+      run_set << :emit_berksfile
+    end
 
+    unless options[:berksfile].nil? || options[:no_run_berkshelf]
+      run_berkshelf(options)
+      run_set << :run_berkshelf
+    end
+
+    cfn_metadata['CferExt::Provisioning::Chef'] = options[:json] || {}
     cfn_init_config :write_chef_json do
-      command :write_chef_json, write_json_cmd
+      command :write_chef_json, build_write_json_cmd(options[:json_path])
     end
+    run_set << :write_chef_json
+
+    cfn_init_config :run_chef_solo do
+      solo_rb = <<-RB.strip_heredoc
+        cookbook_path '#{options[:cookbook_path]}'
+        log_location '#{options[:log_path]}'
 
-    cfn_init_config :run_chef do
-      file chef_solo_config_path, content: options[:solo_rb] || Cfer::Core::Fn.join("\n", [
-          "cookbook_path '#{chef_cookbook_path}'",
-          "log_location '#{chef_log_path}'",
-          ""
-        ]),
-        owner: 'root',
-        group: 'root'
+        json_attribs '#{options[:json_path]}'
+      RB
 
-      chef_cmd = "chef-solo -c '#{chef_solo_config_path}' -j '#{chef_solo_json_path}'"
-      chef_cmd << " -o '#{options[:run_list].join(',')}'" if options[:run_list]
+      file options[:config_path], content: options[:solo_rb] || solo_rb,
+        mode: '000400', owner: 'root', group: 'root'
 
-      command :run_chef, chef_cmd
+      run_list = options[:run_list] || []
+
+      chef_cmd = "chef-solo -c '#{options[:config_path]}' -j '#{options[:json_path]}'"
+      chef_cmd << " -o '#{options[:run_list].join(',')}'" unless options[:run_list].empty?
+
+      file '/usr/local/bin/run-chef-solo.bash', content: chef_cmd,
+        mode: '000500', owner: 'root', group: 'root'
+
+      command :run_chef, 'bash /usr/local/bin/run-chef-solo.bash'
     end
+    run_set << :run_chef_solo
 
-    run_set = [ :write_chef_json, :run_chef ]
-    run_set.prepend :run_berkshelf if options[:berkshelf]
-    cfn_init_config_set :run_chef, run_set
+    cfn_init_config_set :run_chef_solo, run_set
   end
+
+  private
 end
 

data/lib/cfer/provisioning/cloud-init.rb

@@ -0,0 +1,75 @@
+require 'yaml'
+
+module Cfer::Provisioning
+  def cloud_init
+    unless self.key?(:CloudInit)
+      self[:CloudInit] = {
+        bootcmd: [],
+        runcmd: [],
+        packages: [],
+        ssh_authorized_keys: [],
+        write_files: [
+          {
+            path: '/etc/cfn-resource-name',
+            permissions: '0444',
+            content: @name.to_s
+          },
+          {
+            path: '/etc/cfn-stack-name',
+            permissions: '0444',
+            content: 'C{AWS.stack_name}'
+          },
+          {
+            path: '/etc/cfn-region',
+            permissions: '0444',
+            content: 'C{AWS.region}'
+          }
+        ],
+        output: {}
+      }
+    end
+
+    self[:CloudInit]
+  end
+
+  def cloud_init_bootcmds
+    cloud_init[:bootcmd]
+  end
+
+  def cloud_init_runcmds
+    cloud_init[:runcmd]
+  end
+
+  def cloud_init_outputs
+    cloud_init[:output]
+  end
+
+  def cloud_init_packages
+    cloud_init[:packages]
+  end
+
+  def cloud_init_write_files
+    cloud_init[:write_files]
+  end
+
+  def cloud_init_ssh_authorized_keys
+    cloud_init[:ssh_authorized_keys]
+  end
+
+  def cloud_init_finalize!
+    cloud_init_outputs[:all] ||= "| tee -a /var/log/cloud-init-output.log"
+
+    user_data Cfer::Core::Fn.base64( cloud_init_to_user_data(self[:CloudInit]) )
+    self.delete :CloudInit
+  end
+
+  private
+  def cloud_init_to_user_data(cloud_init)
+
+    Cfer.cfize([
+      '#cloud-config',
+      YAML.dump(cloud_init.to_hash_recursive.deep_stringify_keys).gsub(/^---$/, "")
+    ].join("\n"))
+  end
+
+end

data/lib/cfer/provisioning/extensions.rb

@@ -0,0 +1,33 @@
+class Hash
+  def to_hash_recursive
+    result = self.to_hash
+
+    result.each do |key, value|
+      case value
+      when Hash
+        result[key] = value.to_hash_recursive
+      when Array
+        result[key] = value.to_hash_recursive
+      end
+    end
+
+    result
+  end
+end
+
+class Array
+  def to_hash_recursive
+    result = self
+
+    result.each_with_index do |value,i|
+      case value
+      when Hash
+        result[i] = value.to_hash_recursive
+      when Array
+        result[i] = value.to_hash_recursive
+      end
+    end
+
+    result
+  end
+end

data/lib/cfer/provisioning/version.rb

@@ -1,5 +1,5 @@
 module Cfer
   module Provisioning
-    VERSION = "0.1.0"
+    VERSION = "0.2.0-alpha1"
   end
 end

data/lib/cfer/provisioning.rb

@@ -1,4 +1,5 @@
 require "cfer/provisioning/version"
+require "cfer/cfizer"
 require 'cfer'
 
 require 'base64'
@@ -9,6 +10,9 @@ module Cfer
   end
 end
 
+require 'cfer/provisioning/extensions'
+
+require 'cfer/provisioning/cloud-init'
 require 'cfer/provisioning/cfn-bootstrap'
 require 'cfer/provisioning/chef'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cfer-provisioning
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0.pre.alpha1
 platform: ruby
 authors:
 - Sean Edwards
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-11 00:00:00.000000000 Z
+date: 2016-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -42,44 +42,58 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: serverspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.34'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.34'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: cfer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: erubis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 2.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 2.7.0
 description: Provisioning tools for Cfer
 email:
 - stedwards87+git@gmail.com
@@ -96,9 +110,13 @@ files:
 - README.md
 - Rakefile
 - cfer-provisioning.gemspec
+- lib/cfer/cfizer.rb
 - lib/cfer/provisioning.rb
+- lib/cfer/provisioning/cfn-bootstrap.bash.erb
 - lib/cfer/provisioning/cfn-bootstrap.rb
 - lib/cfer/provisioning/chef.rb
+- lib/cfer/provisioning/cloud-init.rb
+- lib/cfer/provisioning/extensions.rb
 - lib/cfer/provisioning/version.rb
 - parameters.yaml.example
 homepage: https://github.com/seanedwards/cfer-provisioning
@@ -116,9 +134,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1
@@ -126,4 +144,3 @@ signing_key:
 specification_version: 4
 summary: Provisioning tools for Cfer
 test_files: []
-has_rdoc: