kumogata 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3669d15c552f8d437460408ae184ac2c51c43539
-  data.tar.gz: 18f24d8608b34c615721d5a30797a2cf93c37d6d
+  metadata.gz: 479281b139e795bc62314dd9a9347981eb6ac01e
+  data.tar.gz: 2e8cec1bd6ea499537779a43c3418b674e334ae4
 SHA512:
-  metadata.gz: f78de3b3a5a42554653cf55c6df6c1b1852d84de7bdef037f8f747ea507f98094556f4e0e7c74ee36f9864915d74386bcc049c1c4d6f452a075523913969be0f
-  data.tar.gz: b485fb1416ba26d4f2e9a5e0e10a591e7be47f9e6c730f1098ab7bdce2d2042d655c465eecc7bd951cbfc6fafecbfa6ab1727153e1a5a95ee613920075db8941
+  metadata.gz: b1fe62841c65d7c06be78f6a28646b6695db44e50088ac64fea693a2b1e21a8c27de4c1f584a0cb5c944844b562965da17f3b350f0d5e4ba01381089d08ebd9a
+  data.tar.gz: cb8bb2af5382cfacf4aa90912c98654fe74434f5159a5fcb954538cb77d94c649109a98c6827abe993ea11fe971b9c2a2c4edfd0baf3f4cd196efbd869ff7ee7

data/.gitignore

@@ -18,3 +18,4 @@ tmp
 packer_cache
 test.rb
 result.json
+command_result.json

data/README.md

@@ -5,8 +5,8 @@
 
 Kumogata is a tool for [AWS CloudFormation](https://aws.amazon.com/cloudformation/).
 
-[![Gem Version](https://badge.fury.io/rb/kumogata.png?201403100300)](http://badge.fury.io/rb/kumogata)
-[![Build Status](https://drone.io/github.com/winebarrel/kumogata/status.png?201403100300)](https://drone.io/github.com/winebarrel/kumogata/latest)
+[![Gem Version](https://badge.fury.io/rb/kumogata.png?201403110046)](http://badge.fury.io/rb/kumogata)
+[![Build Status](https://drone.io/github.com/winebarrel/kumogata/status.png?201403110046)](https://drone.io/github.com/winebarrel/kumogata/latest)
 
 It can define a template in Ruby DSL, such as:
 
@@ -92,6 +92,7 @@ Options:
         --notify SNS_TOPICS
         --timeout MINUTES
         --result-log PATH
+        --command-result-log PATH
         --force
     -w, --ignore-all-space
         --no-color
@@ -274,6 +275,60 @@ Resources do
 end # Resources
 ```
 
+## Post command
+
+You can run shell/ssh commands after building servers using `_post()`.
+
+* Template
+```ruby
+Parameters do
+  ...
+end
+
+Resources do
+  ...
+end
+
+Outputs do
+  MyPublicIp do
+    Value { Fn__GetAtt name, "PublicIp" }
+  end
+end
+
+_post do
+  my_shell_command do
+    command <<-EOS
+      echo <%= Key "MyPublicIp" %>
+    EOS
+  end
+  my_ssh_command do
+    ssh do
+      host { Key "MyPublicIp" } # or '<%= Key "MyPublicIp" %>'
+      user "ec2-user"
+    end
+    command <<-EOS
+      hostname
+    EOS
+  end
+end
+```
+
+* Execution result
+```
+...
+Command: my_shell_command
+Status: 0
+---
+1> 54.199.251.30
+
+Command: my_ssh_command
+Status: 0
+---
+1> ip-10-0-129-20
+
+(Save to `/foo/bar/command_result.json`)
+```
+
 ## Demo
 
 * Create resources
@@ -282,6 +337,8 @@ end # Resources
   * https://asciinema.org/a/7980
 * Create a stack while outputting the event log
   * https://asciinema.org/a/8075
+* Create a stack and run post commands
+  * https://asciinema.org/a/8088
 
 ## Contributing
 

data/kumogata.gemspec

@@ -21,10 +21,11 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'aws-sdk'
   spec.add_dependency 'coderay'
   spec.add_dependency 'diffy'
-  spec.add_dependency 'dslh', '>= 0.2.4'
+  spec.add_dependency 'dslh', '>= 0.2.5'
   spec.add_dependency 'hashie'
   spec.add_dependency 'highline'
   spec.add_dependency 'json'
+  spec.add_dependency 'net-ssh'
   spec.add_dependency 'term-ansicolor'
   spec.add_dependency 'uuidtools'
   spec.add_development_dependency 'bundler'

data/lib/kumogata/argument_parser.rb

@@ -6,6 +6,7 @@ class Kumogata::ArgumentParser
     :replace_underscore => true,
     :delete_stack => true,
     :result_log => File.join(Dir.pwd, 'result.json'),
+    :command_result_log => File.join(Dir.pwd, 'command_result.json'),
     :color => true,
     :debug => false,
   }
@@ -91,6 +92,7 @@ class Kumogata::ArgumentParser
         opt.on(''  , '--notify SNS_TOPICS', Array)              {|v| options[:notify]                        = v     }
         opt.on(''  , '--timeout MINUTES', Integer)              {|v| options[:timeout]                       = v     }
         opt.on(''  , '--result-log PATH')                       {|v| options[:result_log]                    = v     }
+        opt.on(''  , '--command-result-log PATH')               {|v| options[:command]                       = v     }
         opt.on(''  , '--force')                                 {    options[:force]                         = true  }
         opt.on('-w', '--ignore-all-space')                      {    options[:ignore_all_space]              = true  }
         opt.on(''  , '--no-color')                              {    options[:color]                         = false }

data/lib/kumogata/client.rb

@@ -3,6 +3,7 @@ class Kumogata::Client
     @options = options
     @options = Hashie::Mash.new(@options) unless @options.kind_of?(Hashie::Mash)
     @cloud_formation = AWS::CloudFormation.new
+    @post_processing = Kumogata::PostProcessing.new(@options)
   end
 
   def create(path_or_url, stack_name = nil)
@@ -12,7 +13,10 @@ class Kumogata::Client
     template = open_template(path_or_url)
     update_deletion_policy(template)
     add_encryption_password(template)
-    create_stack(template, stack_name)
+
+    outputs = create_stack(template, stack_name)
+    @post_processing.run(:create, outputs)
+
     nil
   end
 
@@ -41,7 +45,10 @@ class Kumogata::Client
     end
 
     add_encryption_password(template)
-    update_stack(template, stack_name)
+
+    outputs = update_stack(template, stack_name)
+    @post_processing.run(:update, outputs)
+
     nil
   end
 
@@ -141,7 +148,7 @@ class Kumogata::Client
       end
     end
 
-    Dslh.eval(template.read, {
+    template = Dslh.eval(template.read, {
       :key_conv   => key_converter,
       :value_conv => value_converter,
       :scope_hook => proc {|scope|
@@ -149,6 +156,16 @@ class Kumogata::Client
       },
       :filename   => template.path,
     })
+
+    @post_processing.fetch!(template)
+
+    return template
+  end
+
+  def evaluate_after_trigger(template)
+    triggers = template.delete('_after')
+    return {} unless triggers
+
   end
 
   def devaluate_template(template)
@@ -203,6 +220,15 @@ class Kumogata::Client
 
         @__hash__[path] = value
       end
+
+      def _post(options = {}, &block)
+        commands = Dslh::ScopeBlock.nest(binding, 'block')
+
+        @__hash__[:_post] = {
+          :options  => options,
+          :commands => commands,
+        }
+      end
     EOS
   end
 
@@ -237,6 +263,8 @@ class Kumogata::Client
     end
 
     output_result(stack_name, outputs, summaries)
+
+    return outputs
   end
 
   def update_stack(template, stack_name)
@@ -257,6 +285,8 @@ class Kumogata::Client
     outputs = outputs_for(stack)
     summaries = resource_summaries_for(stack)
     output_result(stack_name, outputs, summaries)
+
+    return outputs
   end
 
   def delete_stack(stack_name)
@@ -332,6 +362,8 @@ class Kumogata::Client
   end
 
   def while_in_progress(stack, complete_status, event_log)
+    # XXX: Status does not change if you have been memoized.
+    #      Should be forcibly disabled memoization?
     while stack.status =~ /_IN_PROGRESS\Z/
       print_event_log(stack, event_log)
       sleep 1

data/lib/kumogata/ext/string_ext.rb

@@ -1,5 +1,3 @@
-require 'term/ansicolor'
-
 class String
   @@colorize = false
 
@@ -151,7 +149,7 @@ class String
 
     data = data.flatten.select {|i| not i.nil? }.map {|i|
       if i.kind_of?(String)
-        StringIO.new(i).to_a
+        i.lines.to_a
       else
         i
       end

data/lib/kumogata/post_processing.rb

@@ -0,0 +1,221 @@
+class Kumogata::PostProcessing
+  TRIGGER_TIMING = [:create, :update]
+
+  def initialize(options)
+    @options = options
+    @commands = {}
+
+    @command_options = {
+      :undent    => true,
+      :trim_mode => nil,
+    }
+  end
+
+  def fetch!(template)
+    _post = template.delete(:_post)
+    return unless _post
+
+    options = _post[:options] || {}
+    @command_options.merge(options)
+
+    _post.fetch(:commands).each do |name, attrs|
+      timing = [(attrs['after'] || TRIGGER_TIMING)].flatten.map {|i| i.to_sym }
+      validate_timing(name, timing)
+
+      command = attrs['command']
+      next unless command
+
+      @commands[name] = {
+        :after   => timing,
+        :command => command,
+      }
+
+      if (ssh = attrs['ssh'])
+        validate_ssh(name, ssh)
+        @commands[name][:ssh] = ssh
+      end
+    end
+  end
+
+  def run(timing, outputs)
+    results = []
+
+    @commands.each do |name, attrs|
+      next unless attrs[:after].include?(timing)
+
+      out, err, status = run_command(attrs, outputs)
+      results << print_command_result(name, out, err, status)
+    end
+
+    save_command_results(results) unless results.empty?
+  end
+
+  private
+
+  def validate_timing(name, timing)
+    timing.each do |t|
+      unless TRIGGER_TIMING.include?(t)
+        raise "Unknown post processing timing #{timing.inspect} in #{name}"
+      end
+    end
+  end
+
+  def validate_ssh(name, ssh)
+    host, user, options = ssh.values_at('host', 'user', 'options')
+
+    unless host and user
+      raise "`host` and `user` is required for post processing ssh in #{name}"
+    end
+
+    if host.kind_of?(Hash)
+      if host.keys != ['Key']
+        raise "Invalid post processing ssh host #{host.inspect} in #{name}"
+      end
+
+      host_key, host_value = host.first
+      ssh['host'] = "<%= #{host_key} #{host_value.to_s.inspect} %>"
+    else
+      ssh['host'] = host.to_s
+    end
+
+    if user.kind_of?(Hash)
+      if user.keys != ['Key']
+        raise "Invalid post processing ssh user #{user.inspect} in #{name}"
+      end
+
+      user_key, user_value = user.first
+      ssh['user'] = "<%= #{user_key} #{user_value.to_s.inspect} %>"
+    else
+      ssh['user'] = user.to_s
+    end
+
+    if options and not options.kind_of?(Hash)
+      raise "Invalid post processing ssh options #{user.inspect} in #{name}"
+    end
+  end
+
+  def run_command(attrs, outputs)
+    command, ssh = attrs.values_at(:command, :ssh)
+
+    if ssh
+      run_ssh_command(ssh, command, outputs)
+    else
+      run_shell_command(command, outputs)
+    end
+  end
+
+  def run_ssh_command(ssh, command, outputs)
+    host, user, options = ssh.values_at('host', 'user', 'options')
+    host = evaluate_command_template(host, outputs)
+    user = evaluate_command_template(user, outputs)
+    args = [host, user]
+    args << ssh['options'] if ssh['options']
+
+    command = evaluate_command_template(command, outputs)
+
+    begin
+      Net::SSH.start(*args) {|ssh| ssh_exec!(ssh, command) }
+    rescue Net::SSH::HostKeyMismatch => e
+      e.remember_host!
+      retry
+    end
+  end
+
+  def ssh_exec!(ssh, command)
+    stdout_data = ''
+    stderr_data = ''
+    exit_code = nil
+    #exit_signal = nil
+
+    ssh.open_channel do |channel|
+      channel.exec(command) do |ch, success|
+        unless success
+          raise "Couldn't execute command #{command.inspect} (ssh.channel.exec)"
+        end
+
+        channel.on_data do |ch, data|
+          stdout_data << data
+        end
+
+        channel.on_extended_data do |ch, type, data|
+          stderr_data << data
+        end
+
+        channel.on_request('exit-status') do |ch, data|
+          exit_code = data.read_long
+        end
+
+        #channel.on_request('exit-signal') do |ch, data|
+        #  exit_signal = data.read_long
+        #end
+      end
+    end
+
+    ssh.loop
+
+    #[stdout_data, stderr_data, exit_code, exit_signal]
+    [stdout_data, stderr_data, exit_code]
+  end
+
+  def run_shell_command(command, outputs)
+    command = evaluate_command_template(command, outputs)
+    Open3.capture3(command)
+  end
+
+  def evaluate_command_template(command, outputs)
+    command = command.undent if @command_options[:undent]
+    trim_mode = @command_options[:trim_mode]
+
+    scope = Object.new
+    scope.instance_variable_set(:@__outputs__, outputs)
+
+    scope.instance_eval(<<-EOS)
+      def Key(name)
+        @__outputs__[name]
+      end
+
+      ERB.new(#{command.inspect}, nil, #{trim_mode.inspect}).result(binding)
+    EOS
+  end
+
+  def print_command_result(name, out, err, status)
+    status = status.to_i
+    dspout = (out || '').lines.map {|i| "1> ".intense_green + i }.join.chomp
+    dsperr = (err || '').lines.map {|i| "2> ".intense_red + i }.join.chomp
+
+    puts <<-EOS
+
+Command: #{name.intense_blue}
+Status: #{status.zero? ? status : status.to_s.red}#{
+  dspout.empty? ? '' : ("\n---\n" + dspout)
+}#{
+  dsperr.empty? ? '' : ("\n---\n" + dsperr)
+}
+    EOS
+
+    {name => {
+      'ExitStatus' => status,
+      'StdOut' => out.force_encoding('UTF-8'),
+      'StdErr' => err.force_encoding('UTF-8'),
+    }}
+  end
+
+  def save_command_results(results)
+    puts <<-EOS
+
+(Save to `#{@options.command_result_log}`)
+    EOS
+
+    open(@options.command_result_log, 'wb') do |f|
+      f.puts JSON.pretty_generate(results)
+    end
+  end
+
+  def validate_stack_name(stack_name)
+    return unless stack_name
+
+    unless /\A[a-zA-Z][-a-zA-Z0-9]*\Z/i =~ stack_name
+      raise "1 validation error detected: Value '#{stack_name}' at 'stackName' failed to satisfy constraint: Member must satisfy regular expression pattern: [a-zA-Z][-a-zA-Z0-9]*"
+    end
+  end
+end

data/lib/kumogata/version.rb

@@ -1,3 +1,3 @@
 module Kumogata
-  VERSION = '0.3.9'
+  VERSION = '0.3.10'
 end

data/lib/kumogata.rb

@@ -10,11 +10,13 @@ require 'hashie'
 require 'highline/import'
 require 'json'
 require 'logger'
+require 'net/ssh'
 require 'open-uri'
+require 'open3'
 require 'optparse'
 require 'singleton'
-require 'stringio'
 require 'strscan'
+require 'term/ansicolor'
 require 'uuidtools'
 
 require 'kumogata/argument_parser'
@@ -24,4 +26,5 @@ require 'kumogata/ext/coderay_ext'
 require 'kumogata/ext/json_ext'
 require 'kumogata/ext/string_ext'
 require 'kumogata/logger'
+require 'kumogata/post_processing'
 require 'kumogata/utils'

data/spec/kumogata_create_spec.rb

@@ -59,6 +59,404 @@ end
     end
   end
 
+  it 'create a stack from Ruby template and run command' do
+    template = <<-TEMPLATE
+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
+
+  Region do
+    Value do
+      Ref "AWS::Region"
+    end
+  end
+end
+
+_post do
+  command_a do
+    command <<-EOS
+      echo <%= Key "AZ" %>
+      echo <%= Key "Region" %>
+    EOS
+  end
+  command_b do
+    command <<-EOS
+      echo <%= Key "Region" %>
+      echo <%= Key "AZ" %>
+    EOS
+  end
+end
+    TEMPLATE
+
+    run_client(:create, :template => template) do |client, cf|
+      json = eval_template(template, :update_deletion_policy => true).to_json
+      client.should_receive(:print_event_log).twice
+      client.should_receive(:create_event_log).once
+
+      output1 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'AZ' }
+        obj.should_receive(:value) { 'ap-northeast-1b' }
+      end
+
+      output2 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'Region' }
+        obj.should_receive(:value) { 'ap-northeast-1' }
+      end
+
+      resource_summary = make_double('resource_summary') do |obj|
+        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
+        obj.should_receive(:[]).with(:resource_status_reason) { nil }
+        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+      end
+
+      stack = make_double('stack') do |obj|
+        obj.should_receive(:status).and_return(
+            'CREATE_COMPLETE', 'CREATE_COMPLETE',
+            'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
+        obj.should_receive(:outputs) { [output1, output2] }
+        obj.should_receive(:resource_summaries) { [resource_summary] }
+        obj.should_receive(:delete)
+      end
+
+      stacks = make_double('stacks') do |obj|
+        obj.should_receive(:create)
+           .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
+        obj.should_receive(:[])
+           .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
+      end
+
+      cf.should_receive(:stacks).twice { stacks }
+
+      process_status1 = double('process_status1')
+      process_status2 = double('process_status2')
+
+      Open3.should_receive(:capture3).with("echo ap-northeast-1b\necho ap-northeast-1\n")
+           .and_return(["ap-northeast-1b\nap-northeast-1\n", "", process_status1])
+      Open3.should_receive(:capture3).with("echo ap-northeast-1\necho ap-northeast-1b\n")
+           .and_return(["ap-northeast-1\nap-northeast-1b\n", "", process_status2])
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:print_command_result)
+            .with('command_a', "ap-northeast-1b\nap-northeast-1\n", "", process_status1)
+            .and_return('command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\necho ap-northeast-1\n", 'StdErr' => ""})
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:print_command_result)
+            .with('command_b', "ap-northeast-1\nap-northeast-1b\n", "", process_status2)
+            .and_return('command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\necho ap-northeast-1b\n", 'StdErr' => ""})
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:save_command_results)
+            .with([{'command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\necho ap-northeast-1\n", 'StdErr' => ""}},
+                   {'command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\necho ap-northeast-1b\n", 'StdErr' => ""}}])
+    end
+  end
+
+  it 'create a stack from Ruby template and run ssh command' do
+    template = <<-TEMPLATE
+Resources do
+  myEC2Instance do
+    Type "AWS::EC2::Instance"
+    Properties do
+      ImageId "ami-XXXXXXXX"
+      InstanceType "t1.micro"
+    end
+  end
+end
+
+Outputs do
+  PublicIp do
+    Value do
+      Fn__GetAtt "myEC2Instance", "PublicIp"
+    end
+  end
+end
+
+_post do
+  ssh_command do
+    ssh do
+      host { Key "PublicIp" }
+      user "ec2-user"
+    end
+    command <<-EOS
+      ls
+    EOS
+  end
+end
+    TEMPLATE
+
+    run_client(:create, :template => template) do |client, cf|
+      json = eval_template(template, :update_deletion_policy => true).to_json
+      client.should_receive(:print_event_log).twice
+      client.should_receive(:create_event_log).once
+
+      output = make_double('output') do |obj|
+        obj.should_receive(:key) { 'PublicIp' }
+        obj.should_receive(:value) { '127.0.0.1' }
+      end
+
+      resource_summary = make_double('resource_summary') do |obj|
+        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
+        obj.should_receive(:[]).with(:resource_status_reason) { nil }
+        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+      end
+
+      stack = make_double('stack') do |obj|
+        obj.should_receive(:status).and_return(
+            'CREATE_COMPLETE', 'CREATE_COMPLETE',
+            'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
+        obj.should_receive(:outputs) { [output] }
+        obj.should_receive(:resource_summaries) { [resource_summary] }
+        obj.should_receive(:delete)
+      end
+
+      stacks = make_double('stacks') do |obj|
+        obj.should_receive(:create)
+           .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
+        obj.should_receive(:[])
+           .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
+      end
+
+      cf.should_receive(:stacks).twice { stacks }
+
+      Net::SSH.should_receive(:start).with("127.0.0.1", "ec2-user")
+           .and_return(["file1\nfile2\n", "", 0])
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:print_command_result)
+            .with('ssh_command', "file1\nfile2\n", "", 0)
+            .and_return('ssh_command' => {'ExitStatus' => 0, 'StdOut' => "file1\nfile2\n", 'StdErr' => ""})
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:save_command_results)
+            .with([{'ssh_command' => {'ExitStatus' => 0, 'StdOut' => "file1\nfile2\n", 'StdErr' => ""}}])
+    end
+  end
+
+  it 'create a stack from Ruby template and run command (specifies timing)' do
+    template = <<-TEMPLATE
+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
+
+  Region do
+    Value do
+      Ref "AWS::Region"
+    end
+  end
+end
+
+_post do
+  command_a do
+    after :create
+    command <<-EOS
+      echo <%= Key "AZ" %>
+      echo <%= Key "Region" %>
+    EOS
+  end
+  command_b do
+    after :create, :update
+    command <<-EOS
+      echo <%= Key "Region" %>
+      echo <%= Key "AZ" %>
+    EOS
+  end
+end
+    TEMPLATE
+
+    run_client(:create, :template => template) do |client, cf|
+      json = eval_template(template, :update_deletion_policy => true).to_json
+      client.should_receive(:print_event_log).twice
+      client.should_receive(:create_event_log).once
+
+      output1 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'AZ' }
+        obj.should_receive(:value) { 'ap-northeast-1b' }
+      end
+
+      output2 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'Region' }
+        obj.should_receive(:value) { 'ap-northeast-1' }
+      end
+
+      resource_summary = make_double('resource_summary') do |obj|
+        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
+        obj.should_receive(:[]).with(:resource_status_reason) { nil }
+        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+      end
+
+      stack = make_double('stack') do |obj|
+        obj.should_receive(:status).and_return(
+            'CREATE_COMPLETE', 'CREATE_COMPLETE',
+            'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
+        obj.should_receive(:outputs) { [output1, output2] }
+        obj.should_receive(:resource_summaries) { [resource_summary] }
+        obj.should_receive(:delete)
+      end
+
+      stacks = make_double('stacks') do |obj|
+        obj.should_receive(:create)
+           .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
+        obj.should_receive(:[])
+           .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
+      end
+
+      cf.should_receive(:stacks).twice { stacks }
+
+      process_status1 = double('process_status1')
+      process_status2 = double('process_status2')
+
+      Open3.should_receive(:capture3).with("echo ap-northeast-1b\necho ap-northeast-1\n")
+           .and_return(["ap-northeast-1b\nap-northeast-1\n", "", process_status1])
+      Open3.should_receive(:capture3).with("echo ap-northeast-1\necho ap-northeast-1b\n")
+           .and_return(["ap-northeast-1\nap-northeast-1b\n", "", process_status2])
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:print_command_result)
+            .with('command_a', "ap-northeast-1b\nap-northeast-1\n", "", process_status1)
+            .and_return('command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\necho ap-northeast-1\n", 'StdErr' => ""})
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:print_command_result)
+            .with('command_b', "ap-northeast-1\nap-northeast-1b\n", "", process_status2)
+            .and_return('command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\necho ap-northeast-1b\n", 'StdErr' => ""})
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:save_command_results)
+            .with([{'command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\necho ap-northeast-1\n", 'StdErr' => ""}},
+                   {'command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\necho ap-northeast-1b\n", 'StdErr' => ""}}])
+    end
+  end
+
+  it 'create a stack from Ruby template and run command (update timing)' do
+    template = <<-TEMPLATE
+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
+
+  Region do
+    Value do
+      Ref "AWS::Region"
+    end
+  end
+end
+
+_post do
+  command_a do
+    after :update
+    command <<-EOS
+      echo <%= Key "AZ" %>
+      echo <%= Key "Region" %>
+    EOS
+  end
+  command_b do
+    after :update
+    command <<-EOS
+      echo <%= Key "Region" %>
+      echo <%= Key "AZ" %>
+    EOS
+  end
+end
+    TEMPLATE
+
+    run_client(:create, :template => template) do |client, cf|
+      json = eval_template(template, :update_deletion_policy => true).to_json
+      client.should_receive(:print_event_log).twice
+      client.should_receive(:create_event_log).once
+
+      output1 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'AZ' }
+        obj.should_receive(:value) { 'ap-northeast-1b' }
+      end
+
+      output2 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'Region' }
+        obj.should_receive(:value) { 'ap-northeast-1' }
+      end
+
+      resource_summary = make_double('resource_summary') do |obj|
+        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
+        obj.should_receive(:[]).with(:resource_status_reason) { nil }
+        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+      end
+
+      stack = make_double('stack') do |obj|
+        obj.should_receive(:status).and_return(
+            'CREATE_COMPLETE', 'CREATE_COMPLETE',
+            'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
+        obj.should_receive(:outputs) { [output1, output2] }
+        obj.should_receive(:resource_summaries) { [resource_summary] }
+        obj.should_receive(:delete)
+      end
+
+      stacks = make_double('stacks') do |obj|
+        obj.should_receive(:create)
+           .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
+        obj.should_receive(:[])
+           .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
+      end
+
+      cf.should_receive(:stacks).twice { stacks }
+
+      Open3.should_not_receive(:capture3)
+
+      client.instance_variable_get(:@post_processing)
+            .should_not_receive(:print_command_result)
+
+      client.instance_variable_get(:@post_processing)
+            .should_not_receive(:save_command_results)
+    end
+  end
+
   it 'create a stack from Ruby template (include DeletionPolicy)' do
     template = <<-EOS
 Resources do

data/spec/kumogata_update_spec.rb

@@ -56,6 +56,395 @@ end
     end
   end
 
+  it 'update a stack from Ruby template and run command' do
+    template = <<-TEMPLATE
+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
+
+  Region do
+    Value do
+      Ref "AWS::Region"
+    end
+  end
+end
+
+_post do
+  command_a do
+    command <<-EOS
+      echo <%= Key "AZ" %>
+      echo <%= Key "Region" %>
+    EOS
+  end
+  command_b do
+    command <<-EOS
+      echo <%= Key "Region" %>
+      echo <%= Key "AZ" %>
+    EOS
+  end
+end
+    TEMPLATE
+
+    run_client(:update, :arguments => ['MyStack'], :template => template) do |client, cf|
+      json = eval_template(template).to_json
+      client.should_receive(:print_event_log).once
+      client.should_receive(:create_event_log).once
+
+      output1 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'AZ' }
+        obj.should_receive(:value) { 'ap-northeast-1b' }
+      end
+
+      output2 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'Region' }
+        obj.should_receive(:value) { 'ap-northeast-1' }
+      end
+
+      resource_summary = make_double('resource_summary') do |obj|
+        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        obj.should_receive(:[]).with(:resource_status_reason) { nil }
+        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+      end
+
+      stack = make_double('stack') do |obj|
+        obj.should_receive(:update).with(:template => json)
+        obj.should_receive(:status).and_return(
+            'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
+        obj.should_receive(:outputs) { [output1, output2] }
+        obj.should_receive(:resource_summaries) { [resource_summary] }
+      end
+
+      stacks = make_double('stacks') do |obj|
+        obj.should_receive(:[])
+           .with('MyStack') { stack }
+      end
+
+      cf.should_receive(:stacks) { stacks }
+
+      process_status1 = double('process_status1')
+      process_status2 = double('process_status2')
+
+      Open3.should_receive(:capture3).with("echo ap-northeast-1b\necho ap-northeast-1\n")
+           .and_return(["ap-northeast-1b\nap-northeast-1\n", "", process_status1])
+      Open3.should_receive(:capture3).with("echo ap-northeast-1\necho ap-northeast-1b\n")
+           .and_return(["ap-northeast-1\nap-northeast-1b\n", "", process_status2])
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:print_command_result)
+            .with('command_a', "ap-northeast-1b\nap-northeast-1\n", "", process_status1)
+            .and_return('command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\necho ap-northeast-1\n", 'StdErr' => ""})
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:print_command_result)
+            .with('command_b', "ap-northeast-1\nap-northeast-1b\n", "", process_status2)
+            .and_return('command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\necho ap-northeast-1b\n", 'StdErr' => ""})
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:save_command_results)
+            .with([{'command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\necho ap-northeast-1\n", 'StdErr' => ""}},
+                   {'command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\necho ap-northeast-1b\n", 'StdErr' => ""}}])
+    end
+  end
+
+  it 'update a stack from Ruby template and run ssh command' do
+    template = <<-TEMPLATE
+Resources do
+  myEC2Instance do
+    Type "AWS::EC2::Instance"
+    Properties do
+      ImageId "ami-XXXXXXXX"
+      InstanceType "t1.micro"
+    end
+  end
+end
+
+Outputs do
+  PublicIp do
+    Value do
+      Fn__GetAtt "myEC2Instance", "PublicIp"
+    end
+  end
+end
+
+_post do
+  ssh_command do
+    ssh do
+      host { Key "PublicIp" }
+      user "ec2-user"
+    end
+    command <<-EOS
+      ls
+    EOS
+  end
+end
+    TEMPLATE
+
+    run_client(:update, :arguments => ['MyStack'], :template => template) do |client, cf|
+      json = eval_template(template).to_json
+      client.should_receive(:print_event_log).once
+      client.should_receive(:create_event_log).once
+
+      output = make_double('output') do |obj|
+        obj.should_receive(:key) { 'PublicIp' }
+        obj.should_receive(:value) { '127.0.0.1' }
+      end
+
+      resource_summary = make_double('resource_summary') do |obj|
+        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        obj.should_receive(:[]).with(:resource_status_reason) { nil }
+        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+      end
+
+      stack = make_double('stack') do |obj|
+        obj.should_receive(:update).with(:template => json)
+        obj.should_receive(:status).and_return(
+            'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
+        obj.should_receive(:outputs) { [output] }
+        obj.should_receive(:resource_summaries) { [resource_summary] }
+      end
+
+      stacks = make_double('stacks') do |obj|
+        obj.should_receive(:[])
+           .with('MyStack') { stack }
+      end
+
+      cf.should_receive(:stacks) { stacks }
+
+      Net::SSH.should_receive(:start).with("127.0.0.1", "ec2-user")
+           .and_return(["file1\nfile2\n", "", 0])
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:print_command_result)
+            .with('ssh_command', "file1\nfile2\n", "", 0)
+            .and_return('ssh_command' => {'ExitStatus' => 0, 'StdOut' => "file1\nfile2\n", 'StdErr' => ""})
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:save_command_results)
+            .with([{'ssh_command' => {'ExitStatus' => 0, 'StdOut' => "file1\nfile2\n", 'StdErr' => ""}}])
+    end
+  end
+
+  it 'update a stack from Ruby template and run command (specifies timing)' do
+    template = <<-TEMPLATE
+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
+
+  Region do
+    Value do
+      Ref "AWS::Region"
+    end
+  end
+end
+
+_post do
+  command_a do
+    after :update
+    command <<-EOS
+      echo <%= Key "AZ" %>
+      echo <%= Key "Region" %>
+    EOS
+  end
+  command_b do
+    after :create, :update
+    command <<-EOS
+      echo <%= Key "Region" %>
+      echo <%= Key "AZ" %>
+    EOS
+  end
+end
+    TEMPLATE
+
+    run_client(:update, :arguments => ['MyStack'], :template => template) do |client, cf|
+      json = eval_template(template).to_json
+      client.should_receive(:print_event_log).once
+      client.should_receive(:create_event_log).once
+
+      output1 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'AZ' }
+        obj.should_receive(:value) { 'ap-northeast-1b' }
+      end
+
+      output2 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'Region' }
+        obj.should_receive(:value) { 'ap-northeast-1' }
+      end
+
+      resource_summary = make_double('resource_summary') do |obj|
+        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        obj.should_receive(:[]).with(:resource_status_reason) { nil }
+        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+      end
+
+      stack = make_double('stack') do |obj|
+        obj.should_receive(:update).with(:template => json)
+        obj.should_receive(:status).and_return(
+            'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
+        obj.should_receive(:outputs) { [output1, output2] }
+        obj.should_receive(:resource_summaries) { [resource_summary] }
+      end
+
+      stacks = make_double('stacks') do |obj|
+        obj.should_receive(:[])
+           .with('MyStack') { stack }
+      end
+
+      cf.should_receive(:stacks) { stacks }
+
+      process_status1 = double('process_status1')
+      process_status2 = double('process_status2')
+
+      Open3.should_receive(:capture3).with("echo ap-northeast-1b\necho ap-northeast-1\n")
+           .and_return(["ap-northeast-1b\nap-northeast-1\n", "", process_status1])
+      Open3.should_receive(:capture3).with("echo ap-northeast-1\necho ap-northeast-1b\n")
+           .and_return(["ap-northeast-1\nap-northeast-1b\n", "", process_status2])
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:print_command_result)
+            .with('command_a', "ap-northeast-1b\nap-northeast-1\n", "", process_status1)
+            .and_return('command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\necho ap-northeast-1\n", 'StdErr' => ""})
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:print_command_result)
+            .with('command_b', "ap-northeast-1\nap-northeast-1b\n", "", process_status2)
+            .and_return('command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\necho ap-northeast-1b\n", 'StdErr' => ""})
+
+      client.instance_variable_get(:@post_processing)
+            .should_receive(:save_command_results)
+            .with([{'command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\necho ap-northeast-1\n", 'StdErr' => ""}},
+                   {'command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\necho ap-northeast-1b\n", 'StdErr' => ""}}])
+    end
+  end
+
+  it 'update a stack from Ruby template and run command (create timing)' do
+    template = <<-TEMPLATE
+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
+
+  Region do
+    Value do
+      Ref "AWS::Region"
+    end
+  end
+end
+
+_post do
+  command_a do
+    after :create
+    command <<-EOS
+      echo <%= Key "AZ" %>
+      echo <%= Key "Region" %>
+    EOS
+  end
+  command_b do
+    after :create
+    command <<-EOS
+      echo <%= Key "Region" %>
+      echo <%= Key "AZ" %>
+    EOS
+  end
+end
+    TEMPLATE
+
+    run_client(:update, :arguments => ['MyStack'], :template => template) do |client, cf|
+      json = eval_template(template).to_json
+      client.should_receive(:print_event_log).once
+      client.should_receive(:create_event_log).once
+
+      output1 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'AZ' }
+        obj.should_receive(:value) { 'ap-northeast-1b' }
+      end
+
+      output2 = make_double('output') do |obj|
+        obj.should_receive(:key) { 'Region' }
+        obj.should_receive(:value) { 'ap-northeast-1' }
+      end
+
+      resource_summary = make_double('resource_summary') do |obj|
+        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        obj.should_receive(:[]).with(:resource_status_reason) { nil }
+        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+      end
+
+      stack = make_double('stack') do |obj|
+        obj.should_receive(:update).with(:template => json)
+        obj.should_receive(:status).and_return(
+            'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
+        obj.should_receive(:outputs) { [output1, output2] }
+        obj.should_receive(:resource_summaries) { [resource_summary] }
+      end
+
+      stacks = make_double('stacks') do |obj|
+        obj.should_receive(:[])
+           .with('MyStack') { stack }
+      end
+
+      cf.should_receive(:stacks) { stacks }
+
+      process_status1 = double('process_status1')
+      process_status2 = double('process_status2')
+
+      Open3.should_not_receive(:capture3)
+
+      client.instance_variable_get(:@post_processing)
+            .should_not_receive(:print_command_result)
+
+      client.instance_variable_get(:@post_processing)
+            .should_not_receive(:save_command_results)
+    end
+  end
+
   it 'update a stack from Ruby template with parameters' do
     template = <<-EOS
 Parameters do

data/spec/spec_helper.rb

@@ -39,6 +39,7 @@ def run_client(command, options = {})
   kumogata_arguments = options[:arguments] || []
   kumogata_options = Kumogata::ArgumentParser::DEFAULT_OPTIONS.merge(options[:options] || {})
   kumogata_options[:result_log] = '/dev/null'
+  kumogata_options[:command_result_log] = '/dev/null'
   template_ext = options[:template_ext] || '.rb'
 
   client = Kumogata::Client.new(kumogata_options)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kumogata
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.3.10
 platform: ruby
 authors:
 - Genki Sugawara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-09 00:00:00.000000000 Z
+date: 2014-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.2.4
+        version: 0.2.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.2.4
+        version: 0.2.5
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +108,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  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: term-ansicolor
   requirement: !ruby/object:Gem::Requirement
@@ -202,6 +216,7 @@ files:
 - lib/kumogata/ext/json_ext.rb
 - lib/kumogata/ext/string_ext.rb
 - lib/kumogata/logger.rb
+- lib/kumogata/post_processing.rb
 - lib/kumogata/utils.rb
 - lib/kumogata/version.rb
 - packer/CentOS-6.4-x86_64-with_Updates-Asia_Pacific.json