radiosonde 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75143e75e9fad051bdae8993ad6d67d583b3873f
+  data.tar.gz: d0c7c4e7fee046cd4d644702aab4b406200f126c
+SHA512:
+  metadata.gz: b1bf53f56c20e10b82bed5cbf3926335acaaa1603a5ddf0de7cf2dfbcfb2fa82f048bc3050663054f5c68c776e42cfbf193502246a1e0f7ceb70316b72238f5c
+  data.tar.gz: a0fc622cfc46c04b57b63771d07010ea98e50bbb005e2387482b6dcaf1d4ad46090a02cb6ec9b8435a947350736b6c55f2afdbbe5e74069f2c351c9739ae26be

data/.gitignore

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

data/.rspec

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in radiosonde.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,72 @@
+# Radiosonde
+
+Radiosonde is a tool to manage CloudWatch Alarm.
+
+It defines the state of CloudWatch Alarm using DSL, and updates CloudWatch Alarm according to DSL.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'radiosonde'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install radiosonde
+
+## Usage
+
+```sh
+export AWS_ACCESS_KEY_ID='...'
+export AWS_SECRET_ACCESS_KEY='...'
+export AWS_REGION='us-east-1'
+radiosonde -e -o Alarmfile  # export CloudWatch Alarm
+vi Alarmfile
+radiosonde -a --dry-run
+radiosonde -a               # apply `Alarmfile` to CloudWatch
+```
+
+## Help
+
+```
+Usage: radiosonde [options]
+    -p, --profile PROFILE_NAME
+    -k, --access-key ACCESS_KEY
+    -s, --secret-key SECRET_KEY
+    -r, --region REGION
+    -a, --apply
+    -f, --file FILE
+        --dry-run
+    -e, --export
+    -o, --output FILE
+        --no-color
+        --debug
+```
+
+## Alarmfile example
+
+```ruby
+require 'other/alarmfile'
+
+alarm "alarm1" do
+  namespace "AWS/EC2"
+  metric_name "CPUUtilization"
+  dimensions "InstanceId"=>"i-XXXXXXXX"
+  period 300
+  statistic :average
+  threshold ">=", 50.0
+  evaluation_periods 1
+  actions_enabled true
+  alarm_actions []
+  ok_actions []
+  insufficient_data_actions ["arn:aws:sns:us-east-1:123456789012:my_topic"]
+end
+
+alarm "alarm2" do
+  ...
+end
+```

data/Rakefile

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

data/bin/radiosonde

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("#{File.dirname __FILE__}/../lib")
+require 'rubygems'
+require 'radiosonde'
+require 'optparse'
+
+Version = Radiosonde::VERSION
+DEFAULT_FILENAME = 'Alarmfile'
+
+mode = nil
+file = DEFAULT_FILENAME
+output_file = '-'
+
+options = {
+  :dry_run => false,
+  :color   => true,
+  :debug   => false,
+}
+
+ARGV.options do |opt|
+  begin
+    access_key = nil
+    secret_key = nil
+    region = nil
+    profile_name = nil
+
+    opt.on('-p', '--profile PROFILE_NAME')  {|v| profile_name      = v       }
+    opt.on('-k', '--access-key ACCESS_KEY') {|v| access_key        = v       }
+    opt.on('-s', '--secret-key SECRET_KEY') {|v| secret_key        = v       }
+    opt.on('-r', '--region REGION')         {|v| region            = v       }
+    opt.on('-a', '--apply')                 {    mode              = :apply  }
+    opt.on('-f', '--file FILE')             {|v| file              = v       }
+    opt.on('',   '--dry-run')               {    options[:dry_run] = true    }
+    opt.on('-e', '--export')                {    mode              = :export }
+    opt.on('-o', '--output FILE')           {|v| output_file       = v       }
+    opt.on(''  , '--no-color')              {    options[:color]   = false   }
+    opt.on(''  , '--debug')                 {    options[:debug]   = true    }
+    opt.parse!
+
+    aws_opts = {}
+
+    if access_key and secret_key
+      aws_opts = {
+        :access_key_id     => access_key,
+        :secret_access_key => secret_key,
+      }
+    elsif profile_name
+      provider = AWS::Core::CredentialProviders::SharedCredentialFileProvider.new(
+        :profile_name => profile_name
+      )
+      aws_opts[:credential_provider] = provider
+    elsif (access_key and !secret_key) or (!access_key and secret_key) or mode.nil?
+      puts opt.help
+      exit 1
+    end
+
+    aws_opts[:region] = region if region
+    AWS.config(aws_opts)
+  rescue => e
+    $stderr.puts("[ERROR] #{e.message}")
+    exit 1
+  end
+end
+
+String.colorize = options[:color]
+
+if options[:debug]
+  AWS.config({
+    :http_wire_trace => true,
+    :logger => Radiosonde::Logger.instance,
+  })
+end
+
+begin
+  logger = Radiosonde::Logger.instance
+  logger.set_debug(options[:debug])
+  client = Radiosonde::Client.new(options)
+
+  case mode
+  when :export
+    if output_file == '-'
+      logger.info('# Export Alarm')
+      puts client.export(options)
+    else
+      logger.info("Export Alarm to `#{output_file}`")
+      open(output_file, 'wb') {|f| f.puts client.export(options) }
+    end
+  when :apply
+    unless File.exist?(file)
+      raise "No Alarmfile found (looking for: #{file})"
+    end
+
+    msg = "Apply `#{file}` to CloudWatch"
+    msg << ' (dry-run)' if options[:dry_run]
+    logger.info(msg)
+
+    updated = client.apply(file)
+
+    logger.info('No change'.intense_blue) unless updated
+  else
+    raise 'must not happen'
+  end
+rescue => e
+  if options[:debug]
+    raise e
+  else
+    $stderr.puts("[ERROR] #{e.message}".red)
+    exit 1
+  end
+end

data/lib/radiosonde/client.rb

@@ -0,0 +1,66 @@
+class Radiosonde::Client
+  include Radiosonde::Logger::Helper
+  include Radiosonde::Utils
+
+  def initialize(options = {})
+    @options = options
+    @cloud_watch = AWS::CloudWatch.new
+  end
+
+  def export(opts = {})
+    exported = nil
+
+    AWS.memoize do
+      exported = Radiosonde::Exporter.export(@cloud_watch, @options.merge(opts))
+    end
+
+    Radiosonde::DSL.convert(exported, @options.merge(opts))
+  end
+
+  def apply(file)
+    AWS.memoize { walk(file) }
+  end
+
+  private
+
+  def walk(file)
+    dsl = load_file(file)
+    dsl_alarms = collect_to_hash(dsl.alarms, :alarm_name)
+    aws = Radiosonde::Wrapper.wrap(@cloud_watch, @options)
+    aws_alarms = collect_to_hash(aws.alarms, :alarm_name)
+
+    dsl_alarms.each do |alarm_name, dsl_alarm|
+      aws_alarm = aws_alarms.delete(alarm_name)
+
+      if aws_alarm
+        walk_alarm(dsl_alarm, aws_alarm)
+      else
+        aws.alarms.create(alarm_name, dsl_alarm)
+      end
+    end
+
+    aws_alarms.each do |alarm_name, aws_alarm|
+      aws_alarm.delete
+    end
+
+    @cloud_watch.modified?
+  end
+
+  def walk_alarm(dsl_alarm, aws_alarm)
+    unless aws_alarm.eql?(dsl_alarm)
+      aws_alarm.update(dsl_alarm)
+    end
+  end
+
+  def load_file(file)
+    if file.kind_of?(String)
+      open(file) do |f|
+        Radiosonde::DSL.parse(f.read, file)
+      end
+    elsif file.respond_to?(:read)
+      Radiosonde::DSL.parse(file.read, file.path)
+    else
+      raise TypeError, "can't convert #{file} into File"
+    end
+  end
+end

data/lib/radiosonde/dsl/comparison_operator.rb

@@ -0,0 +1,22 @@
+class Radiosonde::DSL::ComparisonOperator
+  ALIASES = {
+    'GreaterThanOrEqualToThreshold' => '>=',
+    'GreaterThanThreshold'          => '>',
+    'LessThanThreshold'             => '<',
+    'LessThanOrEqualToThreshold'    => '<=',
+  }
+
+  class << self
+    def conv_to_alias(operator)
+      ALIASES[operator] || operator
+    end
+
+    def valid?(operator)
+      ALIASES.keys.include?(operator) or ALIASES.values.include?(operator)
+    end
+
+    def normalize(operator)
+      (ALIASES.respond_to?(:key) ? ALIASES.key(operator) : ALIASES.index(operator)) || operator
+    end
+  end # of class methods
+end

data/lib/radiosonde/dsl/context/alarm.rb

@@ -0,0 +1,124 @@
+class Radiosonde::DSL::Context::Alarm
+  include Radiosonde::DSL::Validator
+
+  def initialize(name, &block)
+    @error_identifier = "Alarm `#{name}`"
+    @result = OpenStruct.new(
+      :alarm_name => name,
+      :alarm_actions => [],
+      :ok_actions => [],
+      :insufficient_data_actions => []
+    )
+    instance_eval(&block)
+  end
+
+  def result
+    [
+      :metric_name,
+      :period,
+      :statistic,
+      :threshold,
+      :comparison_operator,
+      :actions_enabled,
+    ].each do |name|
+      _required(name, @result[name])
+    end
+
+    @result
+  end
+
+  private
+
+  def description(value)
+    _call_once(:alarm_description)
+    @result.alarm_description = value.nil? ? nil : value.to_s
+  end
+
+  def namespace(value)
+    _call_once(:namespace)
+    @result.namespace = value.nil? ? nil : value.to_s
+  end
+
+  def metric_name(value)
+    _call_once(:metric_name)
+    _required(:metric_name, value)
+    @result.metric_name = value.to_s
+  end
+
+  def dimensions(value)
+    _call_once(:dimensions)
+    _expected_type(value, Hash, Array)
+
+    if value.kind_of?(Hash)
+      value = value.map do |name, value|
+        {:name => name, :value => value}
+      end
+    end
+
+    @result.dimensions = value
+  end
+
+  def period(value)
+    _call_once(:period)
+    @result.period = value.to_i
+  end
+
+  def statistic(value)
+    _call_once(:statistic)
+    _validate("Invalid value: #{value}") do
+      Radiosonde::DSL::Statistic.valid?(value)
+    end
+
+    @result.statistic = Radiosonde::DSL::Statistic.normalize(value)
+  end
+
+  def threshold(operator, value)
+    _call_once(:threshold)
+    _required(:threshold, value)
+    operator = operator.to_s
+    _validate("Invalid operator: #{operator}") do
+      Radiosonde::DSL::ComparisonOperator.valid?(operator)
+    end
+
+    @result.threshold = value.to_f
+    @result.comparison_operator = Radiosonde::DSL::ComparisonOperator.normalize(operator)
+  end
+
+  def evaluation_periods(value)
+    _call_once(:evaluation_periods)
+    @result.evaluation_periods = value.to_i
+  end
+
+  def unit(value)
+    _call_once(:unit)
+    _validate("Invalid value: #{value}") do
+      Radiosonde::DSL::Unit.valid?(value)
+    end
+
+    @result.unit = Radiosonde::DSL::Unit.normalize(value)
+  end
+
+  def actions_enabled(value)
+    _call_once(:actions_enabled)
+    _expected_type(value, TrueClass, FalseClass)
+    @result.actions_enabled = value
+  end
+
+  def alarm_actions(*actions)
+    _call_once(:alarm_actions)
+    _expected_type(actions, Array)
+    @result.alarm_actions = [(actions || [])].flatten
+  end
+
+  def ok_actions(*actions)
+    _call_once(:ok_actions)
+    _expected_type(actions, Array)
+    @result.ok_actions = [(actions || [])].flatten
+  end
+
+  def insufficient_data_actions(*actions)
+    _call_once(:insufficient_data_actions)
+    _expected_type(actions, Array)
+    @result.insufficient_data_actions = [(actions || [])].flatten
+  end
+end

data/lib/radiosonde/dsl/context.rb

@@ -0,0 +1,45 @@
+class Radiosonde::DSL::Context
+  include Radiosonde::DSL::Validator
+
+  class << self
+    def eval(dsl, path, opts = {})
+      self.new(path, opts) {
+        eval(dsl, binding, path)
+      }
+    end
+  end # of class methods
+
+  attr_reader :result
+
+  def initialize(path, options = {}, &block)
+    @path = path
+    @options = options
+    @result = OpenStruct.new(:alarms => [])
+    @alarm_names = []
+    instance_eval(&block)
+  end
+
+  private
+
+  def require(file)
+    alarmfile = File.expand_path(File.join(File.dirname(@path), file))
+
+    if File.exist?(alarmfile)
+      instance_eval(File.read(alarmfile), alarmfile)
+    elsif File.exist?(alarmfile + '.rb')
+      instance_eval(File.read(alarmfile + '.rb'), alarmfile + '.rb')
+    else
+      Kernel.require(file)
+    end
+  end
+
+  def alarm(name, &block)
+    _required(:alarm_name, name)
+    _validate("Alarm `#{name}` is already defined") do
+      not @alarm_names.include?(name)
+    end
+
+    @result.alarms << Radiosonde::DSL::Context::Alarm.new(name, &block).result
+    @alarm_names << name
+  end
+end

data/lib/radiosonde/dsl/converter.rb

@@ -0,0 +1,119 @@
+class Radiosonde::DSL::Converter
+  class << self
+    def convert(exported, opts = {})
+      self.new(exported, opts).convert
+    end
+  end # of class methods
+
+  def initialize(exported, options = {})
+    @exported = exported
+    @options = options
+  end
+
+  def convert
+    @exported.each.map {|alarm_name, alarm_attrs|
+      output_alarm(alarm_name, alarm_attrs)
+    }.join("\n")
+  end
+
+  private
+
+  def output_alarm(name, attrs)
+    name = name.inspect
+    description = attrs[:description]
+    description = "description #{description.inspect}\n  " if description
+    namespace = attrs[:namespace].inspect
+    metric_name = attrs[:metric_name].inspect
+    dimensions = format_dimensions(attrs)
+    dimensions = "dimensions #{dimensions}\n  " if dimensions
+    period = attrs[:period].inspect
+    statistic = Radiosonde::DSL::Statistic.conv_to_alias(attrs[:statistic]).inspect
+    threshold = format_threshold(attrs)
+    evaluation_periods = attrs[:evaluation_periods].inspect
+    actions_enabled = attrs[:actions_enabled].inspect
+    alarm_actions = attrs[:alarm_actions].inspect
+    ok_actions = attrs[:ok_actions].inspect
+    insufficient_data_actions = attrs[:insufficient_data_actions].inspect
+
+    if unit = attrs[:unit]
+      unit = Radiosonde::DSL::Unit.conv_to_alias(unit).inspect
+      unit = "unit #{unit}"
+    end
+
+    <<-EOS
+alarm #{name} do
+  #{description
+  }namespace #{namespace}
+  metric_name #{metric_name}
+  #{dimensions
+  }period #{period}
+  statistic #{statistic}
+  threshold #{threshold}
+  evaluation_periods #{evaluation_periods}
+  #{unit
+  }actions_enabled #{actions_enabled}
+  alarm_actions #{alarm_actions}
+  ok_actions #{ok_actions}
+  insufficient_data_actions #{insufficient_data_actions}
+end
+    EOS
+  end
+
+  def format_dimensions(attrs)
+    dimensions = attrs[:dimensions] || []
+    return nil if dimensions.empty?
+    names = dimensions.map {|i| i[:name] }
+
+    if duplicated?(names)
+      dimensions.inspect
+    else
+      dimension_hash = {}
+
+      dimensions.each do |dimension|
+        name = dimension[:name]
+        value = dimension[:value]
+        dimension_hash[name] = value
+      end
+
+      unbrace(dimension_hash.inspect)
+    end
+  end
+
+  def format_threshold(attrs)
+    threshold = attrs[:threshold]
+    operator = attrs[:comparison_operator]
+    operator = Radiosonde::DSL::ComparisonOperator.conv_to_alias(operator)
+
+    [
+      operator.inspect,
+      threshold.inspect,
+    ].join(', ')
+  end
+
+  def output_actions(attrs, opts = {})
+    prefix = opts[:prefix]
+    enabled = attrs[:actions_enabled].inspect
+    alarm_actions = attrs[:alarm_actions].inspect
+    ok_actions = attrs[:ok_actions].inspect
+    insufficient_data_actions = attrs[:insufficient_data_actions].inspect
+
+    [
+      'actions {',
+      "  :enabled => #{enabled},",
+      "  :alarm => #{alarm_actions},",
+      "  :ok => #{ok_actions},",
+      "  :insufficient => #{insufficient_data_actions},",
+      '}',
+    ].join("\n#{prefix}")
+  end
+
+  private
+
+  def unbrace(str)
+    str.sub(/\A\s*\{/, '').sub(/\}\s*\z/, '')
+  end
+
+  def duplicated?(list)
+    list.length != list.uniq.length
+  end
+end

data/lib/radiosonde/dsl/statistic.rb

@@ -0,0 +1,23 @@
+class Radiosonde::DSL::Statistic
+  ALIASES = {
+    'SampleCount' => :sample_count,
+    'Average'     => :average,
+    'Sum'         => :sum,
+    'Minimum'     => :minimum,
+    'Maximum'     => :maximum,
+  }
+
+  class << self
+    def conv_to_alias(statistic)
+      ALIASES[statistic] || statistic
+    end
+
+    def valid?(statistic)
+      ALIASES.keys.include?(statistic) or ALIASES.values.include?(statistic)
+    end
+
+    def normalize(statistic)
+      (ALIASES.respond_to?(:key) ? ALIASES.key(statistic) : ALIASES.index(statistic)) || statistic
+    end
+  end # of class methods
+end

data/lib/radiosonde/dsl/unit.rb

@@ -0,0 +1,44 @@
+class Radiosonde::DSL::Unit
+  ALIASES = {
+    'Seconds'          => :seconds,
+    'Microseconds'     => :microseconds,
+    'Milliseconds'     => :milliseconds,
+    'Bytes'            => :bytes,
+    'Kilobytes'        => :kilobytes,
+    'Megabytes'        => :megabytes,
+    'Gigabytes'        => :gigabytes,
+    'Terabytes'        => :terabytes,
+    'Bits'             => :bits,
+    'Kilobits'         => :kilobits,
+    'Megabits'         => :megabits,
+    'Gigabits'         => :gigabits,
+    'Terabits'         => :terabits,
+    'Percent'          => :percent,
+    'Count'            => :count,
+    'Bytes/Second'     => :bytes_per_second,
+    'Kilobytes/Second' => :kilobytes_per_second,
+    'Megabytes/Second' => :megabytes_per_second,
+    'Gigabytes/Second' => :gigabytes_per_second,
+    'Terabytes/Second' => :terabytes_per_second,
+    'Bits/Second'      => :bits_per_second,
+    'Kilobits/Second'  => :kilobits_per_second,
+    'Megabits/Second'  => :megabits_per_second,
+    'Gigabits/Second'  => :gigabits_per_second,
+    'Terabits/Second'  => :terabits_per_second,
+    'Count/Second'     => :count_per_second,
+    'None'             => :none,
+  }
+  class << self
+    def conv_to_alias(unit)
+      ALIASES[unit] || unit
+    end
+
+    def valid?(unit)
+      ALIASES.keys.include?(unit) or ALIASES.values.include?(unit)
+    end
+
+    def normalize(unit)
+      (ALIASES.respond_to?(:key) ? ALIASES.key(unit) : ALIASES.index(unit)) || unit
+    end
+  end # of class methods
+end

data/lib/radiosonde/dsl/validator.rb

@@ -0,0 +1,46 @@
+module Radiosonde::DSL::Validator
+  def _required(name, value)
+    invalid = false
+
+    if value
+      case value
+      when String
+        invalid = value.strip.empty?
+      when Array, Hash
+        invalid = value.empty?
+      end
+    elsif value.nil?
+      invalid = true
+    end
+
+    raise _identify("`#{name}` is required") if invalid
+  end
+
+  def _call_once(method_name)
+    @called ||= []
+
+    if @called.include?(method_name)
+      raise _identify("`#{method_name}` is already defined")
+    end
+
+    @called << method_name
+  end
+
+  def _expected_type(value, *types)
+    unless types.any? {|t| value.kind_of?(t) }
+      raise _identify("Invalid type: #{value}")
+    end
+  end
+
+  def _validate(errmsg)
+    raise _identify(errmsg) unless yield
+  end
+
+  def _identify(errmsg)
+    if @error_identifier
+      errmsg = "#{@error_identifier}: #{errmsg}"
+    end
+
+    return errmsg
+  end
+end

data/lib/radiosonde/dsl.rb

@@ -0,0 +1,11 @@
+class Radiosonde::DSL
+  class << self
+    def convert(exported, opts = {})
+      Radiosonde::DSL::Converter.convert(exported, opts)
+    end
+
+    def parse(dsl, path, opts = {})
+      Radiosonde::DSL::Context.eval(dsl, path, opts).result
+    end
+  end # of class methods
+end

data/lib/radiosonde/exporter.rb

@@ -0,0 +1,60 @@
+class Radiosonde::Exporter
+  class << self
+    def export(clowd_watch, opts = {})
+      self.new(clowd_watch, opts).export
+    end
+  end # of class methods
+
+  def initialize(clowd_watch, options = {})
+    @clowd_watch = clowd_watch
+    @options = options
+  end
+
+  def export
+    result = {}
+
+    @clowd_watch.alarms.each do |alarm|
+      export_alarm(alarm, result)
+    end
+
+    return result
+  end
+
+  private
+
+  def export_alarm(alarm, result)
+    alarm_attrs = {
+      :description => alarm.alarm_description,
+      :metric_name => alarm.metric_name,
+      :namespace => alarm.namespace,
+      :dimensions => alarm.dimensions,
+      :period => alarm.period,
+      :statistic => alarm.statistic,
+      :threshold => alarm.threshold,
+      :comparison_operator => alarm.comparison_operator,
+      :evaluation_periods => alarm.evaluation_periods,
+      :actions_enabled => alarm.actions_enabled,
+      :alarm_actions => alarm.alarm_actions,
+      :ok_actions => alarm.ok_actions,
+      :insufficient_data_actions => alarm.insufficient_data_actions,
+      :unit => alarm.unit,
+    }
+
+    if @options[:with_status]
+      alarm_attrs[:status] = export_alarm_status(alarm)
+    end
+
+    result[alarm.alarm_name] = alarm_attrs
+  end
+
+  def export_alarm_status(alarm)
+    {
+      :alarm_arn => alarm.alarm_arn,
+      :state_value => alarm.state_value,
+      :state_reason => alarm.state_reason,
+      :state_reason_data => alarm.state_reason_data ? JSON.parse(alarm.state_reason_data) : nil,
+      :state_updated_timestamp => alarm.state_updated_timestamp,
+      :alarm_configuration_updated_timestamp => alarm.alarm_configuration_updated_timestamp,
+    }
+  end
+end

data/lib/radiosonde/ext/cloud_watch_ext.rb

@@ -0,0 +1,9 @@
+class AWS::CloudWatch
+  def modify!
+    @modified = true
+  end
+
+  def modified?
+    !!@modified
+  end
+end

data/lib/radiosonde/ext/string_ext.rb

@@ -0,0 +1,25 @@
+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
+end

data/lib/radiosonde/logger.rb

@@ -0,0 +1,27 @@
+class Radiosonde::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
+
+  module Helper
+    def log(level, message, color, log_id = nil)
+      message = "[#{level.to_s.upcase}] #{message}" unless level == :info
+      message << ": #{log_id}" if log_id
+      message << ' (dry-run)' if @options && @options[:dry_run]
+      logger = (@options && @options[:logger]) || Radiosonde::Logger.instance
+      logger.send(level, message.send(color))
+    end
+  end
+end

data/lib/radiosonde/utils.rb

@@ -0,0 +1,25 @@
+module Radiosonde::Utils
+  def collect_to_hash(collection, *key_attrs)
+    opts = key_attrs.last.kind_of?(Hash) ? key_attrs.pop : {}
+    hash = {}
+
+    collection.each do |item|
+      if block_given?
+        key = yield(item)
+      else
+        key = key_attrs.map {|k| item.send(k) }
+        key = key.first if key_attrs.length == 1
+      end
+
+      if opts[:has_many]
+        hash[key] ||= []
+        hash[key] << item
+      else
+        hash[key] = item
+      end
+    end
+
+    return hash
+  end
+  module_function :collect_to_hash
+end

data/lib/radiosonde/version.rb

@@ -0,0 +1,3 @@
+module Radiosonde
+  VERSION = '0.0.1'
+end

data/lib/radiosonde/wrapper/alarm.rb

@@ -0,0 +1,109 @@
+class Radiosonde::Wrapper::Alarm
+  extend Forwardable
+  include Radiosonde::Logger::Helper
+
+  ATTRIBUTES_WITHOUT_NAME  = [
+    :alarm_description,
+    :namespace,
+    :metric_name,
+    :dimensions,
+    :period,
+    :statistic,
+    :threshold,
+    :comparison_operator,
+    :evaluation_periods,
+    :actions_enabled,
+    :unit,
+    :alarm_actions,
+    :ok_actions,
+    :insufficient_data_actions,
+    :actions_enabled,
+  ]
+
+  ATTRIBUTES = [:alarm_name] + ATTRIBUTES_WITHOUT_NAME
+
+  DEFAULT_VALUES = {
+    :dimensions => []
+  }
+
+  ATTRIBUTES.each do |name|
+    def_delegator :@alarm, name
+  end
+
+  class << self
+    def normalize_attrs(attrs)
+      normalized = {}
+
+      Radiosonde::Wrapper::Alarm::ATTRIBUTES_WITHOUT_NAME.each do |name|
+        unless (value = attrs[name]).nil?
+          normalized[name] = value
+        end
+      end
+
+      return normalized
+    end
+  end # of class methods
+
+  def initialize(clowd_watch, alarm, options = {})
+    @clowd_watch = clowd_watch
+    @alarm = alarm
+    @options = options
+  end
+
+  def eql?(dsl)
+    diff(dsl).empty?
+  end
+
+  def update(dsl)
+    delta = diff(dsl)
+    log(:info, 'Update Alarm', :green, "#{self.alarm_name} > #{format_delta(delta)}")
+
+    unless @options[:dry_run]
+      opts = self.class.normalize_attrs(dsl)
+      @alarm.update(opts)
+      @clowd_watch.modify!
+    end
+  end
+
+  def delete
+    log(:info, 'Delete Alarm', :red, self.alarm_name)
+
+    unless @options[:dry_run]
+      @alarm.delete
+      @clowd_watch.modify!
+    end
+  end
+
+  private
+
+  def diff(dsl)
+    delta = {}
+
+    ATTRIBUTES.each do |name|
+      self_value = self.send(name)
+      dsl_value = dsl[name]
+
+      if normalize(name, self_value) != normalize(name, dsl_value)
+        delta[name] = {:old => self_value, :new => dsl_value}
+      end
+    end
+
+    return delta
+  end
+
+  def format_delta(delta)
+    delta.map {|name, values|
+      "#{name}(#{values[:old]}=>#{values[:new]})"
+    }.join(', ')
+  end
+
+  def normalize(name, value)
+    if [Array, Hash].any? {|c| value.kind_of?(c) }
+      value.sort
+    elsif DEFAULT_VALUES.has_key?(name) and value.nil?
+      DEFAULT_VALUES[name]
+    else
+      value
+    end
+  end
+end

data/lib/radiosonde/wrapper/alarm_collection.rb

@@ -0,0 +1,29 @@
+class Radiosonde::Wrapper::AlarmCollection
+  include Radiosonde::Logger::Helper
+
+  def initialize(clowd_watch, alarms, options = {})
+    @clowd_watch = clowd_watch
+    @alarms = alarms
+    @options = options
+  end
+
+  def each
+    @alarms.each do |alarm|
+      yield(Radiosonde::Wrapper::Alarm.new(@clowd_watch, alarm, @options))
+    end
+  end
+
+  def create(name, dsl)
+    log(:info, 'Create Alarm', :cyan, name)
+    opts = Radiosonde::Wrapper::Alarm.normalize_attrs(dsl)
+
+    if @options[:dry_run]
+      alarm = OpenStruct.new(opts.merge(:alarm_name => name))
+    else
+      alarm = @alarms.create(name, opts)
+      @clowd_watch.modify!
+    end
+
+    Radiosonde::Wrapper::Alarm.new(@clowd_watch, alarm, @options)
+  end
+end

data/lib/radiosonde/wrapper/cloud_watch.rb

@@ -0,0 +1,14 @@
+class Radiosonde::Wrapper::CloudWatch
+  def initialize(clowd_watch, options = {})
+    @clowd_watch = clowd_watch
+    @options = options
+  end
+
+  def alarms
+    Radiosonde::Wrapper::AlarmCollection.new(@clowd_watch, @clowd_watch.alarms, @options)
+  end
+
+  def modified?
+    @clowd_watch.modified?
+  end
+end

data/lib/radiosonde/wrapper.rb

@@ -0,0 +1,7 @@
+class Radiosonde::Wrapper
+  class << self
+    def wrap(cw, opts = {})
+      Radiosonde::Wrapper::CloudWatch.new(cw, opts)
+    end
+  end # of class methods
+end

data/lib/radiosonde.rb

@@ -0,0 +1,29 @@
+module Radiosonde; end
+
+require 'forwardable'
+require 'json'
+require 'logger'
+require 'ostruct'
+require 'singleton'
+
+require 'aws-sdk'
+require 'term/ansicolor'
+
+require 'radiosonde/logger'
+require 'radiosonde/utils'
+require 'radiosonde/client'
+require 'radiosonde/dsl'
+require 'radiosonde/dsl/validator'
+require 'radiosonde/dsl/comparison_operator'
+require 'radiosonde/dsl/context'
+require 'radiosonde/dsl/context/alarm'
+require 'radiosonde/dsl/converter'
+require 'radiosonde/dsl/statistic'
+require 'radiosonde/exporter'
+require 'radiosonde/ext/cloud_watch_ext'
+require 'radiosonde/ext/string_ext'
+require 'radiosonde/version'
+require 'radiosonde/wrapper'
+require 'radiosonde/wrapper/alarm'
+require 'radiosonde/wrapper/alarm_collection'
+require 'radiosonde/wrapper/cloud_watch'

data/radiosonde.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'radiosonde/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'radiosonde'
+  spec.version       = Radiosonde::VERSION
+  spec.authors       = ['Genki Sugawara']
+  spec.email         = ['sgwr_dts@yahoo.co.jp']
+  spec.description   = "Radiosonde is a tool to manage CloudWatch Alarm. It defines the state of CloudWatch Alarm using DSL, and updates CloudWatch Alarm according to DSL."
+  spec.summary       = "Radiosonde is a tool to manage CloudWatch Alarm."
+  spec.homepage      = ''
+  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', '>= 1.50.0'
+  spec.add_dependency "json"
+  spec.add_dependency "term-ansicolor"
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '>= 3.0.0'
+end

data/spec/radiosonde_spec.rb

@@ -0,0 +1,5 @@
+describe Radiosonde do
+  it do
+    expect(1).to eq(1)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'radiosonde'

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: radiosonde
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Genki Sugawara
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.50.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.50.0
+- !ruby/object:Gem::Dependency
+  name: json
+  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
+    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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Radiosonde is a tool to manage CloudWatch Alarm. It defines the state
+  of CloudWatch Alarm using DSL, and updates CloudWatch Alarm according to DSL.
+email:
+- sgwr_dts@yahoo.co.jp
+executables:
+- radiosonde
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/radiosonde
+- lib/radiosonde.rb
+- lib/radiosonde/client.rb
+- lib/radiosonde/dsl.rb
+- lib/radiosonde/dsl/comparison_operator.rb
+- lib/radiosonde/dsl/context.rb
+- lib/radiosonde/dsl/context/alarm.rb
+- lib/radiosonde/dsl/converter.rb
+- lib/radiosonde/dsl/statistic.rb
+- lib/radiosonde/dsl/unit.rb
+- lib/radiosonde/dsl/validator.rb
+- lib/radiosonde/exporter.rb
+- lib/radiosonde/ext/cloud_watch_ext.rb
+- lib/radiosonde/ext/string_ext.rb
+- lib/radiosonde/logger.rb
+- lib/radiosonde/utils.rb
+- lib/radiosonde/version.rb
+- lib/radiosonde/wrapper.rb
+- lib/radiosonde/wrapper/alarm.rb
+- lib/radiosonde/wrapper/alarm_collection.rb
+- lib/radiosonde/wrapper/cloud_watch.rb
+- radiosonde.gemspec
+- spec/radiosonde_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Radiosonde is a tool to manage CloudWatch Alarm.
+test_files:
+- spec/radiosonde_spec.rb
+- spec/spec_helper.rb