kumogata 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 28f500bbe000bfcca855c3e8d44d60f2fbba233d
+  data.tar.gz: 378508af2ad72d1911de56ed05f25a9672fa7b22
+SHA512:
+  metadata.gz: 4ddbe3c73b965c5d95a1439a15ab9da7d4862b6f1bdbe3b36aa0cc6fede3d3f61a801278fd14ff6ded443dc4dd9e2effa5f901989002f5af9b8c163bb98bd7d4
+  data.tar.gz: 8eff8eb5fd29490c27a8521fa03bc961ef7eff06ec3162dea3b055cf43cb87298443baddac8ce57f30a5091bf36b140712abe5514d39c4356cfe0518eb95ce7e

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+packer_cache
+test.rb
+result.json

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--colour

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kumogata.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Genki Sugawara
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,127 @@
+# Kumogata
+
+Kumogata is a tool for AWS CroudFormation.
+
+[![Gem Version](https://badge.fury.io/rb/kumogata.png?201403021953)](http://badge.fury.io/rb/kumogata)
+[![Build Status](https://drone.io/github.com/winebarrel/kumogata/status.png?201403021953)](https://drone.io/github.com/winebarrel/kumogata/latest)
+
+It can define a template in Ruby DSL, such as:
+
+```ruby
+Parameters do
+  InstanceType do
+    Default "t1.micro"
+    Description "Instance Type"
+    Type "String"
+  end
+end
+
+Resources do
+  myEC2Instance do
+    Type "AWS::EC2::Instance"
+    Properties do
+      ImageId "ami-XXXXXXXX"
+      InstanceType { Ref "InstanceType" }
+      KeyName "your_key_name"
+
+      UserData _user_data(<<-EOS)
+        #!/bin/bash
+        yum install -y httpd
+        service httpd start
+      EOS
+    end
+  end
+end
+
+Outputs do
+  AZ do
+    Value do
+      Fn__GetAtt "myEC2Instance", "AvailabilityZone"
+    end
+  end
+end
+```
+
+## Installation
+
+    $ gem install kumogata
+
+## Usage
+
+```
+Usage: kumogata <command> [args] [options]
+
+Commands:
+  create   PATH_OR_URL [STACK_NAME]  Create resources as specified in the template
+  validate PATH_OR_URL               Validate a specified template
+  convert  PATH_OR_URL               Convert a template format
+  update   PATH_OR_URL STACK_NAME    Update a stack as specified in the template
+  delete   STACK_NAME                Delete a specified stack
+  list     [STACK_NAME]              List summary information for stacks
+
+Options:
+    -k, --access-key ACCESS_KEY
+    -s, --secret-key SECRET_KEY
+    -r, --region REGION
+        --skip-replace-underscore
+        --skip-delete-stack
+    -p, --parameters KEY_VALUES
+        --capabilities CAPABILITIES
+        --disable-rollback
+        --notify SNS_TOPICS
+        --timeout MINUTES
+        --result-log PATH
+        --force
+        --no-color
+        --debug
+```
+
+### Create resources
+
+    $ kumogata creat template.rb
+
+If you want to save the stack, please specify the stack name:
+
+    $ kumogata creat template.rb any_stack_name
+
+If you want to pass parameters, please use `-p` option:
+
+    $ kumogata creat template.rb -p "InstanceType=m1.large,KeyName=any_other_key"
+
+
+**Notice**
+
+**The stack will be delete if you do not specify the stack name explicitly.**
+(And only the resources will remain)
+
+I think the stack that manage resources is not required in many case...
+
+### Convert JSON to Ruby
+
+JSON template can be converted to Ruby template.
+
+    $ kumogata convert https://s3.amazonaws.com/cloudformation-templates-us-east-1/Drupal_Single_Instance.template
+
+* Data that cannot be converted will be converted to Array and Hash
+* `::` is converted to `__`
+  * `Fn::GetAtt` => `Fn__GetAtt`
+* `_{ ... }` is convered to Hash
+  * `SecurityGroups [_{Ref "WebServerSecurityGroup"}]` => `{"SecurityGroups": [{"Ref": "WebServerSecurityGroup"}]}`
+* `_user_data()` creates Base64-encoded UserData
+* `_path()` creates Hash that has a key of path
+  * `_path("/etc/passwd-s3fs") { content "..." }` => `{"/etc/passwd-s3fs": {"content": "..."}}`
+
+## Demo
+
+* Create resources
+  * https://asciinema.org/a/7979
+* Convert a template
+  * https://asciinema.org/a/7980
+
+## Contributing
+
+1. Fork it ( http://github.com/winebarrel/kumogata/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/bin/kumogata

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("#{File.dirname __FILE__}/../lib")
+require 'rubygems'
+require 'kumogata'
+
+options = nil
+
+begin
+  parsed = Kumogata::ArgumentParser.parse! {|parser, cmd, args, opts|
+    if (opts.access_key_id? and not opts.secret_access_key?) or
+       (not opts.access_key_id? and opts.secret_access_key?)
+      puts parser.help
+      exit 1
+    end
+  }
+
+  command, arguments, options = parsed
+
+  aws_opts = {}
+
+  [:access_key_id, :secret_access_key, :region].each do |key|
+    aws_opts[key] = options[key] if options[key]
+  end
+
+  AWS.config(aws_opts) unless aws_opts.empty?
+
+  String.colorize = options.color?
+
+  if options.debug?
+    Kumogata.logger.set_debug(true)
+
+    AWS.config({
+      :http_wire_trace => true,
+      :logger => Kumogata.logger,
+    })
+  end
+
+  out = Kumogata::Client.new(options).send(command, *arguments)
+  puts out if out
+rescue => e
+  $stderr.puts("[ERROR] #{e.message}".red)
+
+  if options and options.debug?
+    raise e
+  end
+
+  exit 1
+end

data/kumogata.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kumogata/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kumogata'
+  spec.version       = Kumogata::VERSION
+  spec.authors       = ['Genki Sugawara']
+  spec.email         = ['sgwr_dts@yahoo.co.jp']
+  spec.summary       = %q{A tool for AWS CroudFormation.}
+  spec.description   = %q{A tool for AWS CroudFormation. It can define a template in Ruby DSL.}
+  spec.homepage      = 'https://github.com/winebarrel/kumogata'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'aws-sdk'
+  spec.add_dependency 'dslh', '>= 0.2.1'
+  spec.add_dependency 'hashie'
+  spec.add_dependency 'highline'
+  spec.add_dependency 'json'
+  spec.add_dependency 'term-ansicolor'
+  spec.add_dependency 'uuidtools'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '>= 2.11.0'
+end

data/lib/kumogata/argument_parser.rb

@@ -0,0 +1,142 @@
+Version = Kumogata::VERSION
+
+class Kumogata::ArgumentParser
+  DEFAULT_OPTIONS = {
+    :replace_underscore => true,
+    :delete_stack => true,
+    :result_log => File.join(Dir.pwd, 'result.json'),
+    :color => true,
+    :debug => false,
+  }
+
+  COMMANDS = {
+    :create => {
+      :description => 'Create resources as specified in the template',
+      :arguments   => [:path_or_url, :stack_name?]
+    },
+    :validate => {
+      :description => 'Validate a specified template',
+      :arguments   => [:path_or_url]
+    },
+    :convert => {
+      :description => 'Convert a template format',
+      :arguments   => [:path_or_url]
+    },
+    :update => {
+      :description => 'Update a stack as specified in the template',
+      :arguments   => [:path_or_url, :stack_name]
+    },
+    :delete => {
+      :description => 'Deletes a specified stack',
+      :arguments   => [:stack_name]
+    },
+    :list => {
+      :description => 'List summary information for stacks',
+      :arguments   => [:stack_name?]
+    },
+  }
+
+  class << self
+    def parse!(&block)
+      self.new.parse!(&block)
+    end
+  end # of class methods
+
+  def parse!
+    command = nil
+    arguments = nil
+    options = {}
+
+    ARGV.options do |opt|
+      update_usage(opt)
+
+      begin
+        opt.on('-k', '--access-key ACCESS_KEY')            {|v| options[:access_key_id]      = v     }
+        opt.on('-s', '--secret-key SECRET_KEY')            {|v| options[:secret_access_key]  = v     }
+        opt.on('-r', '--region REGION')                    {|v| options[:region]             = v     }
+        opt.on(''  , '--skip-replace-underscore')          {    options[:replace_underscore] = false }
+        opt.on(''  , '--skip-delete-stack')                {    options[:delete_stack]       = false }
+        opt.on('-p', '--parameters KEY_VALUES', Array)     {|v| options[:parameters]         = v     }
+        opt.on(''  , '--capabilities CAPABILITIES', Array) {|v| options[:capabilities]       = v     }
+        opt.on(''  , '--disable-rollback')                 {    options[:disable_rollback]   = true  }
+        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(''  , '--force')                            {    options[:force]              = true  }
+        opt.on(''  , '--no-color')                         {    options[:color]              = false }
+        opt.on(''  , '--debug')                            {    options[:debug]              = true  }
+        opt.parse!
+
+        unless (command = ARGV.shift)
+          puts opt.help
+          exit 1
+        end
+
+        command = command.to_sym
+
+        unless COMMANDS.has_key?(command)
+          raise "Unknown command: #{command}"
+        end
+
+        arguments = ARGV.dup
+        validate_arguments(command, arguments)
+
+        options = DEFAULT_OPTIONS.merge(options)
+        options = Hashie::Mash.new(options)
+
+        if block_given?
+          yield(opt, command, arguments, options)
+        end
+      rescue => e
+        $stderr.puts("#{e.message}")
+        exit 1
+      end
+    end
+
+    [command, arguments, options]
+  end
+
+  private
+
+  def update_usage(opt)
+    opt.banner = "Usage: kumogata <command> [args] [options]"
+    opt.separator ''
+    opt.separator 'Commands:'
+
+    cmd_max = COMMANDS.keys.map {|i| i.to_s.length }.max
+
+    cmd_arg_descs = COMMANDS.map {|command, attributes|
+      arguments = attributes[:arguments]
+      description = attributes[:description]
+
+      [
+        '%-*s %s' % [cmd_max, command, arguments_to_message(arguments)],
+        description,
+      ]
+    }
+
+    cmd_arg_max = cmd_arg_descs.map {|i| i[0].length }.max
+
+    opt.separator(cmd_arg_descs.map {|cmd_arg, desc|
+      '  %-*s  %-s' % [cmd_arg_max, cmd_arg, desc]
+    }.join("\n"))
+
+    opt.separator ''
+    opt.separator 'Options:'
+  end
+
+  def validate_arguments(command, arguments)
+    expected = COMMANDS[command][:arguments] || []
+
+    min = expected.count {|i| i.to_s !~ /\?\Z/ }
+    max = expected.length
+
+    if arguments.length < min or max < arguments.length
+      raise "Usage: kumogata #{command} #{arguments_to_message(expected)} [options]"
+    end
+  end
+
+  def arguments_to_message(arguments)
+    arguments.map {|i| i.to_s.sub(/(.+)\?\Z/) { "[#{$1}]" }.upcase }.join(' ')
+  end
+end