kumogata 0.1.0

data/lib/kumogata/client.rb

@@ -0,0 +1,324 @@
+class Kumogata::Client
+  def initialize(options)
+    @options = options
+    @options = Hashie::Mash.new(@options) unless @options.kind_of?(Hashie::Mash)
+    @cloud_formation = AWS::CloudFormation.new
+  end
+
+  def create(path_or_url, stack_name = nil)
+    @options.delete_stack = false if stack_name
+    template = open_template(path_or_url)
+
+    if @options.delete_stack?
+      template['Resources'].each do |k, v|
+        v['DeletionPolicy'] = 'Retain'
+      end
+    end
+
+    create_stack(template, stack_name)
+    nil
+  end
+
+  def validate(path_or_url)
+    template = open_template(path_or_url)
+    validate_template(template)
+    nil
+  end
+
+  def convert(path_or_url)
+    template = open_template(path_or_url)
+
+    if ruby_template?(path_or_url)
+      JSON.pretty_generate(template)
+    else
+      devaluate_template(template).chomp
+    end
+  end
+
+  def update(path_or_url, stack_name)
+    template = open(path_or_url) do |f|
+      evaluate_template(f)
+    end
+
+    update_stack(template, stack_name)
+    nil
+  end
+
+  def delete(stack_name)
+    if @options.force? or agree("Aare you sure you want to delete `#{stack_name}`? ".yellow)
+      delete_stack(stack_name)
+    end
+
+    nil
+  end
+
+  def list(stack_name = nil)
+    stacks = describe_stacks(stack_name)
+    JSON.pretty_generate(stacks)
+  end
+
+  private ###########################################################
+
+  def open_template(path_or_url)
+    open(path_or_url) do |f|
+      if ruby_template?(path_or_url)
+        evaluate_template(f)
+      else
+        JSON.parse(f.read)
+      end
+    end
+  end
+
+  def ruby_template?(path_or_url)
+    File.extname(path_or_url) == '.rb'
+  end
+
+  def evaluate_template(template)
+    key_converter = proc do |key|
+      key = key.to_s
+      key.gsub!('__', '::') if @options.replace_underscore?
+      key
+    end
+
+    value_converter = proc do |v|
+      case v
+      when Hash, Array
+        v
+      else
+        v.to_s
+      end
+    end
+
+    Dslh.eval(template.read, {
+      :key_conv   => key_converter,
+      :value_conv => value_converter,
+      :scope_hook => method(:define_template_func),
+      :filename   => template.path,
+    })
+  end
+
+  def devaluate_template(template)
+    exclude_key = proc do |k|
+      k = k.to_s.gsub('::', '__')
+      k !~ /\A[_a-z]\w+\Z/i and k !~ %r|\A/\S*\Z|
+    end
+
+    key_conv = proc do |k|
+      k = k.to_s
+
+      if k =~ %r|\A/\S*\Z|
+        proc do |v, nested|
+          if nested
+            "_path(#{k.inspect}) #{v}"
+          else
+            "_path #{k.inspect}, #{v}"
+          end
+        end
+      else
+        k.gsub('::', '__')
+      end
+    end
+
+    Dslh.deval(template, :key_conv => key_conv, :exclude_key => exclude_key)
+  end
+
+  def define_template_func(scope)
+    scope.instance_eval do
+      def _user_data(data)
+        data.strip_lines.encode64
+      end
+
+      def _path(path, value = nil, &block)
+        if block
+          value = Dslh::ScopeBlock.nest(binding, 'block')
+        end
+
+        @__hash__[path] = value
+      end
+    end
+  end
+
+  def describe_stacks(stack_name)
+    AWS.memoize do
+      stacks = @cloud_formation.stacks
+      stacks = stacks.select {|i| i.name == stack_name } if stack_name
+
+      stacks.map do |stack|
+        {
+          'StackName'    => stack.name,
+          'CreationTime' => stack.creation_time,
+          'StackStatus'  => stack.status,
+          'Description'  => stack.description,
+        }
+      end
+    end
+  end
+
+  def create_stack(template, stack_name)
+    stack_name = stack_name || 'kumogata-' + UUIDTools::UUID.timestamp_create
+
+    Kumogata.logger.info("Creating stack: #{stack_name}".cyan)
+    stack = @cloud_formation.stacks.create(stack_name, template.to_json, build_create_options)
+
+    unless while_in_progress(stack, 'CREATE_COMPLETE')
+      errmsgs = ['Create failed']
+      errmsgs << stack_name
+      errmsgs << sstack.tatus_reason if stack.status_reason
+      raise errmsgs.join(': ')
+    end
+
+    outputs = outputs_for(stack)
+    summaries = resource_summaries_for(stack)
+
+    if @options.delete_stack?
+      delete_stack(stack_name)
+    end
+
+    output_result(stack_name, outputs, summaries)
+  end
+
+  def update_stack(template, stack_name)
+    stack = @cloud_formation.stacks[stack_name]
+    stack.status
+    stack.update(build_update_options(template.to_json))
+
+    Kumogata.logger.info("Updating stack: #{stack_name}".green)
+
+    unless while_in_progress(stack, 'UPDATE_COMPLETE')
+      errmsgs = ['Update failed']
+      errmsgs << stack_name
+      errmsgs << sstack.tatus_reason if stack.status_reason
+      raise errmsgs.join(': ')
+    end
+
+    outputs = outputs_for(stack)
+    summaries = resource_summaries_for(stack)
+    output_result(stack_name, outputs, summaries)
+  end
+
+  def delete_stack(stack_name)
+    stack = @cloud_formation.stacks[stack_name]
+    stack.status
+
+    Kumogata.logger.info("Deleting stack: #{stack_name}".red)
+    stack.delete
+
+    completed = false
+
+    begin
+      completed = while_in_progress(stack, 'DELETE_COMPLETE')
+    rescue AWS::CloudFormation::Errors::ValidationError
+      # Handle `Stack does not exist`
+      completed = true
+      Kumogata.logger.info('Successfully')
+    end
+
+    unless completed
+      errmsgs = ['Delete failed']
+      errmsgs << stack_name
+      errmsgs << sstack.tatus_reason if stack.status_reason
+      raise errmsgs.join(': ')
+    end
+  end
+
+  def while_in_progress(stack, complete_status)
+    while stack.status =~ /_IN_PROGRESS\Z/
+      print '.'.intense_black unless @options.debug?
+      sleep 1
+    end
+
+    completed = (stack.status == complete_status)
+    Kumogata.logger.info(completed ? 'Successfully' : 'Failed')
+    return completed
+  end
+
+  def build_create_options
+    opts = {}
+    add_parameters(opts)
+
+    [:capabilities, :disable_rollback, :notify, :timeout].each do |k|
+      opts[k] = @options[k] if @options[k]
+    end
+
+    return opts
+  end
+
+  def build_update_options(template)
+    opts = {:template => template}
+    add_parameters(opts)
+    return opts
+  end
+
+  def add_parameters(hash)
+    if @options.parameters?
+      parameters = {}
+
+      @options.parameters.each do |i|
+        key, value = i.split('=', 2)
+        parameters[key] = value
+      end
+
+      hash[:parameters] = parameters
+    end
+  end
+
+  def validate_template(template)
+    result = @cloud_formation.validate_template(template.to_json)
+
+    if result[:code]
+      raise result.values_at(:code, :message).join(': ')
+    end
+
+    Kumogata.logger.info('Template validated successfully'.green)
+  end
+
+  def outputs_for(stack)
+    outputs_hash = {}
+
+    stack.outputs.each do |output|
+      outputs_hash[output.key] = output.value
+    end
+
+    return outputs_hash
+  end
+
+  def resource_summaries_for(stack)
+    stack.resource_summaries.map do |summary|
+      summary_hash = {}
+
+      [
+        :logical_resource_id,
+        :physical_resource_id,
+        :resource_type,
+        :resource_status,
+        :resource_status_reason,
+        :last_updated_timestamp
+      ].each do |k|
+        summary_hash[k.to_s.camelcase] = summary[k]
+      end
+
+      summary_hash
+    end
+  end
+
+  def output_result(stack_name, outputs, summaries)
+    puts <<-EOS
+
+Outputs:
+#{JSON.pretty_generate(outputs)}
+
+Stack Resource Summaries:
+#{JSON.pretty_generate(summaries)}
+
+(Save to `#{@options.result_log}`)
+    EOS
+
+    open(@options.result_log, 'wb') do |f|
+      f.puts JSON.pretty_generate({
+        'StackName' => stack_name,
+        'Outputs' => outputs,
+        'StackResourceSummaries' => summaries,
+      })
+    end
+  end
+end

data/lib/kumogata/ext/string_ext.rb

@@ -0,0 +1,41 @@
+require 'term/ansicolor'
+
+class String
+  @@colorize = false
+
+  class << self
+    def colorize=(value)
+      @@colorize = value
+    end
+
+    def colorize
+      @@colorize
+    end
+  end # of class methods
+
+  Term::ANSIColor::Attribute.named_attributes.map do |attribute|
+    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def #{attribute.name}
+        if @@colorize
+          Term::ANSIColor.send(#{attribute.name.inspect}, self)
+        else
+          self
+        end
+      end
+    EOS
+  end
+
+  def camelcase
+    self.split(/[-_]/).map {|str|
+      str[0, 1].upcase + str[1..-1].downcase
+    }.join
+  end
+
+  def encode64
+    Base64.encode64(self).delete("\n")
+  end
+
+  def strip_lines
+    self.strip.split("\n").map {|i| i.strip }.join("\n")
+  end
+end

data/lib/kumogata/logger.rb

@@ -0,0 +1,23 @@
+module Kumogata
+  def self.logger
+    Kumogata::Logger.instance
+  end
+
+  class Logger < ::Logger
+    include Singleton
+
+    def initialize
+      super($stdout)
+
+      self.formatter = proc do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+
+      self.level = Logger::INFO
+    end
+
+    def set_debug(value)
+      self.level = value ? Logger::DEBUG : Logger::INFO
+    end
+  end
+end

data/lib/kumogata/version.rb

@@ -0,0 +1,3 @@
+module Kumogata
+  VERSION = '0.1.0'
+end

data/lib/kumogata.rb

@@ -0,0 +1,19 @@
+module Kumogata; end
+require 'kumogata/version'
+
+require 'aws-sdk'
+require 'base64'
+require 'dslh'
+require 'hashie'
+require 'highline/import'
+require 'json'
+require 'logger'
+require 'open-uri'
+require 'optparse'
+require 'singleton'
+require 'uuidtools'
+
+require 'kumogata/argument_parser'
+require 'kumogata/client'
+require 'kumogata/ext/string_ext'
+require 'kumogata/logger'

data/packer/CentOS-6.4-x86_64-with_Updates-Asia_Pacific.json

@@ -0,0 +1,26 @@
+{
+  "variables": {
+    "aws_access_key": "{{env `AWS_ACCESS_KEY_ID`}}",
+    "aws_secret_key": "{{env `AWS_SECRET_ACCESS_KEY`}}"
+  },
+  "builders": [{
+    "type": "amazon-ebs",
+    "ami_name": "CentOS-6.4-x86_64-with_Updates-{{timestamp}}",
+    "access_key": "{{user `aws_access_key`}}",
+    "secret_key": "{{user `aws_secret_key`}}",
+    "region": "ap-northeast-1",
+    "source_ami": "ami-31e86030",
+    "instance_type": "t1.micro",
+    "ssh_username": "root",
+    "ssh_timeout": "3m"
+  }],
+  "provisioners": [{
+    "type": "shell",
+    "inline": [
+      "yum install -y http://ftp.iij.ad.jp/pub/linux/fedora/epel/6/i386/epel-release-6-8.noarch.rpm",
+      "yum install -y cloud-init",
+      "yum install -y https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-latest.amzn1.noarch.rpm",
+      "rm -rf /root/.ssh"
+    ]
+  }]
+}

data/packer/Ubuntu-12.04.4-LTS-x86_64-ebs-Asia_Pacific.json

@@ -0,0 +1,28 @@
+{
+  "variables": {
+    "aws_access_key": "{{env `AWS_ACCESS_KEY_ID`}}",
+    "aws_secret_key": "{{env `AWS_SECRET_ACCESS_KEY`}}"
+  },
+  "builders": [{
+    "type": "amazon-ebs",
+    "ami_name": "Ubuntu-12.04.4-LTS-x86_64-ebs-{{timestamp}}",
+    "access_key": "{{user `aws_access_key`}}",
+    "secret_key": "{{user `aws_secret_key`}}",
+    "region": "ap-northeast-1",
+    "source_ami": "ami-f381f5f2",
+    "instance_type": "t1.micro",
+    "ssh_username": "ubuntu",
+    "ssh_timeout": "3m"
+  }],
+  "provisioners": [{
+    "type": "shell",
+    "inline": [
+      "sudo apt-get -y install python-setuptools",
+      "wget -P /tmp https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-latest.tar.gz",
+      "sudo mkdir -p /tmp/aws-cfn-bootstrap-latest",
+      "sudo tar xvfz /tmp/aws-cfn-bootstrap-latest.tar.gz --strip-components=1 -C /tmp/aws-cfn-bootstrap-latest",
+      "sudo easy_install /tmp/aws-cfn-bootstrap-latest/",
+      "sudo rm -rf /tmp/aws-cfn-bootstrap-latest"
+    ]
+  }]
+}

data/spec/kumogata_convert_spec.rb

@@ -0,0 +1,96 @@
+describe 'Kumogata::Client#convert' do
+  it 'convert Ruby template to JSON template' do
+    template = <<-EOS
+Resources do
+  myEC2Instance do
+    Type "AWS::EC2::Instance"
+    Properties do
+      ImageId "ami-XXXXXXXX"
+      InstanceType "t1.micro"
+    end
+  end
+end
+
+Outputs do
+  AZ do
+    Value do
+      Fn__GetAtt "myEC2Instance", "AvailabilityZone"
+    end
+  end
+end
+    EOS
+
+    json_template = run_client(:convert, :template => template)
+
+    expect(json_template).to eq((<<-EOS).chomp)
+{
+  "Resources": {
+    "myEC2Instance": {
+      "Type": "AWS::EC2::Instance",
+      "Properties": {
+        "ImageId": "ami-XXXXXXXX",
+        "InstanceType": "t1.micro"
+      }
+    }
+  },
+  "Outputs": {
+    "AZ": {
+      "Value": {
+        "Fn::GetAtt": [
+          "myEC2Instance",
+          "AvailabilityZone"
+        ]
+      }
+    }
+  }
+}
+    EOS
+  end
+
+  it 'convert Ruby template to JSON template' do
+    template = <<-EOS
+{
+  "Resources": {
+    "myEC2Instance": {
+      "Type": "AWS::EC2::Instance",
+      "Properties": {
+        "ImageId": "ami-07f68106",
+        "InstanceType": "t1.micro"
+      }
+    }
+  },
+  "Outputs": {
+    "AZ": {
+      "Value": {
+        "Fn::GetAtt": [
+          "myEC2Instance",
+          "AvailabilityZone"
+        ]
+      }
+    }
+  }
+}
+    EOS
+
+    ruby_template = run_client(:convert, :template => template, :template_ext => '.template')
+
+    expect(ruby_template).to eq((<<-EOS).chomp)
+Resources do
+  myEC2Instance do
+    Type "AWS::EC2::Instance"
+    Properties do
+      ImageId "ami-07f68106"
+      InstanceType "t1.micro"
+    end
+  end
+end
+Outputs do
+  AZ do
+    Value do
+      Fn__GetAtt "myEC2Instance", "AvailabilityZone"
+    end
+  end
+end
+    EOS
+  end
+end