cfdef 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0909b1b9f166833357a105d0cb0fc21ce99eb9d1
+  data.tar.gz: 75fad2e020db895d135a3b7220b1439029c94ed5
+SHA512:
+  metadata.gz: d3b09a739c589ff187b124e299280e4cda0b9242955c8dda3768dfead4c173287140d15936831793ab509ea7274202f177e86f7ab17ea89f77f035f4c63c14bb
+  data.tar.gz: 53034fad297c334a37523d1bef9ce4bf77ff077e1edf68fb06ee3a2f048ce4fc0baf3c6246c34d216eaa03b527036a586450b74c8efe686c4ff58138b26834e0

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+CFfile
+*.cf

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.4
+before_install: gem install bundler -v 1.11.2

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 winebarrel
+
+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,187 @@
+# Cfdef
+
+Repol is a tool to manage CloudFront.
+
+It defines the state of CloudFront using DSL, and updates CloudFront according to DSL.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cfdef'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cfdef
+
+## Usage
+
+```sh
+export AWS_ACCESS_KEY_ID='...'
+export AWS_SECRET_ACCESS_KEY='...'
+cfdef -e -o Cffile  # export CloudFront
+vi CFfile
+cfdef -a --dry-run
+cfdef -a            # apply `CFfile`
+```
+
+## Help
+
+```
+Usage: cfdef [options]
+    -k, --access-key ACCESS_KEY
+    -s, --secret-key SECRET_KEY
+    -r, --region REGION
+        --profile PROFILE
+        --credentials-path PATH
+    -a, --apply
+    -f, --file FILE
+        --dry-run
+    -e, --export
+    -o, --output FILE
+        --split
+        --target-origin ID_RGX
+        --no-color
+        --debug
+```
+
+## CFfile example
+
+```ruby
+require 'other/cffile'
+
+distribution "EXAMPLEID" do
+  aliases do
+    quantity 0
+  end
+  origins do
+    quantity 2
+    items [
+      _{
+        id "Custom-ehxample.cpm"
+        domain_name "example.cpm"
+        origin_path ""
+        custom_headers do
+          quantity 0
+        end
+        custom_origin_config do
+          http_port 80
+          https_port 443
+          origin_protocol_policy "http-only"
+          origin_ssl_protocols do
+            quantity 3
+            items "TLSv1", "TLSv1.1", "TLSv1.2"
+          end
+        end
+      },
+      _{
+        id "S3-example"
+        domain_name "example.s3.amazonaws.com"
+        origin_path ""
+        custom_headers do
+          quantity 0
+        end
+        s3_origin_config do
+          origin_access_identity ""
+        end
+      }
+    ]
+  end
+  default_cache_behavior do
+    target_origin_id "S3-example"
+    forwarded_values do
+      query_string false
+      cookies do
+        forward "none"
+      end
+      headers do
+        quantity 0
+      end
+    end
+    trusted_signers do
+      enabled false
+      quantity 0
+    end
+    viewer_protocol_policy "allow-all"
+    min_ttl 0
+    allowed_methods do
+      quantity 2
+      items "GET", "HEAD"
+      cached_methods do
+        quantity 2
+        items "GET", "HEAD"
+      end
+    end
+    smooth_streaming false
+    default_ttl 86400
+    max_ttl 31536000
+    compress false
+  end
+  cache_behaviors do
+    quantity 0
+  end
+  custom_error_responses do
+    quantity 0
+  end
+  comment ""
+  price_class "PriceClass_All"
+  enabled true
+  viewer_certificate do
+    cloud_front_default_certificate true
+    minimum_protocol_version "SSLv3"
+    certificate_source "cloudfront"
+  end
+  restrictions do
+    geo_restriction do
+      restriction_type "none"
+      quantity 0
+    end
+  end
+  web_acl_id ""
+end
+```
+
+## Create Distribution
+
+```sh
+$ cat CFfile
+distribution do # without ID
+  ...
+end
+
+$ cfdef -a
+```
+
+Identify Distribution using Origin IDs if there is no Distribution ID.
+
+## Delete Distribution
+
+```sh
+$ cat CFfile
+distribution "EXAMPLEID" do
+  ...
+  enable false
+  ...
+end
+
+$ cfdef -a
+...
+
+$ cat CFfile
+# comment out
+#distribution "EXAMPLEID" do
+#  ...
+#end
+
+$ cfdef -a
+```
+
+## ToDo
+
+* Support Streaming Distribution

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/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cfdef"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cfdef.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cfdef/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cfdef'
+  spec.version       = Cfdef::VERSION
+  spec.authors       = ['winebarrel']
+  spec.email         = ['sgwr_dts@yahoo.co.jp']
+
+  spec.summary       = %q{Cfdef is a tool to manage CloudFront.}
+  spec.description   = %q{Cfdef is a tool to manage CloudFront.}
+  spec.homepage      = 'https://github.com/winebarrel/cfdef'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'aws-sdk', '~> 2.3.0'
+  spec.add_dependency 'diffy'
+  spec.add_dependency 'dslh', '>= 0.3.3'
+  spec.add_dependency 'term-ansicolor'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/exe/cfdef

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'cfdef'
+require 'optparse'
+
+Version = Cfdef::VERSION
+
+DEFAULT_FILENAME = 'CFfile'
+
+MAGIC_COMMENT = <<-EOS
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+EOS
+
+def parse_options(argv)
+  options = {
+    file: DEFAULT_FILENAME,
+    output: '-',
+    dry_run: false,
+    color: true,
+    aws: {},
+  }
+
+  opt = OptionParser.new
+  opt.on('-k', '--access-key ACCESS_KEY') {|v| options[:aws][:access_key_id]     = v }
+  opt.on('-s', '--secret-key SECRET_KEY') {|v| options[:aws][:secret_access_key] = v }
+  opt.on('-r', '--region REGION')         {|v| options[:aws][:region]            = v }
+
+  opt.on('', '--profile PROFILE') do |v|
+    options[:aws][:credentials] ||= {}
+    options[:aws][:credentials][:profile_name] = v
+  end
+
+  opt.on('', '--credentials-path PATH') do |v|
+    options[:aws][:credentials] ||= {}
+    options[:aws][:credentials][:path] = v
+  end
+
+  opt.on('-a', '--apply')                {    options[:mode]    = :apply        }
+  opt.on('-f', '--file FILE')            {|v| options[:file]    = v             }
+  opt.on(''  , '--dry-run')              {    options[:dry_run] = true          }
+  opt.on('-e', '--export')               {    options[:mode]    = :export       }
+  opt.on('-o', '--output FILE')          {|v| options[:output]  = v             }
+  opt.on(''  , '--split')                {    options[:split]   = :true         }
+  opt.on(''  , '--target-origin ID_RGX') {|v| options[:target]  = Regexp.new(v) }
+  opt.on(''  , '--no-color')             {    options[:color]   = false         }
+  opt.on(''  , '--debug')                {    options[:debug]   = true          }
+
+  opt.parse!(argv)
+
+  unless options[:mode]
+    puts opt.help
+    exit 1
+  end
+
+  if options[:aws][:credentials]
+    credentials = Aws::SharedCredentials.new(options[:aws][:credentials])
+    options[:aws][:credentials] = credentials
+  end
+
+  Aws.config.update(options[:aws])
+  String.colorize = options[:color]
+
+  if options[:debug]
+    Cfdef::Logger.instance.set_debug(options[:debug])
+
+    Aws.config.update(
+      :http_wire_trace => true,
+      :logger => Cfdef::Logger.instance
+    )
+  end
+
+  options
+rescue => e
+  $stderr.puts("[ERROR] #{e.message}")
+  exit 1
+end
+
+def main(argv)
+  options = parse_options(argv)
+  client = Cfdef::Client.new(options)
+  logger = Cfdef::Logger.instance
+
+  case options[:mode]
+  when :export
+    # TODO:
+    exported = client.export
+    output = options[:output]
+
+    if options[:split]
+      logger.info('Export CloudFront')
+
+      output = DEFAULT_FILENAME if output == '-'
+      dir = File.dirname(output)
+      FileUtils.mkdir_p(dir)
+      requires = []
+
+      # TODO: support streaming_distributions
+      exported.fetch(:distributions).each do |dist_id, distribution|
+        next unless distribution
+
+        filename = "#{dist_id}.cf"
+        requires << filename
+        cf_file = File.join(dir, filename)
+
+        logger.info("  write `#{cf_file}`")
+
+        dsl = Cfdef::DSL.convert({distributions: {dist_id => distribution}}, options)
+
+        open(cf_file, 'wb') do |f|
+          f.puts MAGIC_COMMENT
+          f.puts dsl
+        end
+      end
+
+      logger.info("  write `#{output}`")
+
+      open(output, 'wb') do |f|
+        f.puts MAGIC_COMMENT
+
+        requires.each do |cf_file|
+          f.puts "require '#{cf_file}'"
+        end
+      end
+    else
+      dsl = Cfdef::DSL.convert(exported, options)
+
+      if output == '-'
+        logger.info('# Export CloudFront')
+        puts dsl
+      else
+        logger.info("Export CloudFront to `#{output}`")
+
+        open(output, 'wb') do |f|
+          f.puts MAGIC_COMMENT
+          f.puts dsl
+        end
+      end
+    end
+  when :apply
+    file = options[:file]
+
+    unless File.exist?(file)
+      raise "No CFfile found (looking for: #{file})"
+    end
+
+    message = "Apply `#{file}` to CloudFront"
+    message << ' (dry-run)' if options[:dry_run]
+    logger.info(message)
+
+    updated = client.apply(file)
+
+    logger.info('No change'.intense_blue) unless updated
+  else
+    raise "Unknown mode: #{options[:mode]}"
+  end
+rescue => e
+  if options[:debug]
+    raise e
+  else
+    $stderr.puts("[ERROR] #{e.message}".red)
+    exit 1
+  end
+end
+
+main(ARGV)

data/lib/cfdef.rb

@@ -0,0 +1,22 @@
+require 'aws-sdk'
+require 'diffy'
+require 'dslh'
+require 'json'
+require 'logger'
+require 'pp'
+require 'securerandom'
+require 'singleton'
+require 'term/ansicolor'
+
+require 'cfdef/version'
+require 'cfdef/ext/hash_ext'
+require 'cfdef/ext/string_ext'
+require 'cfdef/logger'
+require 'cfdef/utils'
+
+require 'cfdef/client'
+require 'cfdef/driver'
+require 'cfdef/dsl'
+require 'cfdef/dsl/context'
+require 'cfdef/dsl/converter'
+require 'cfdef/exporter'

data/lib/cfdef/client.rb

@@ -0,0 +1,101 @@
+class Cfdef::Client
+  include Cfdef::Utils::Helper
+  include Cfdef::Logger::Helper
+
+  def initialize(options = {})
+    @options = options
+    @client = @options[:client] || Aws::CloudFront::Client.new
+    @driver = Cfdef::Driver.new(@client, @options)
+    @exporter = Cfdef::Exporter.new(@client, @options)
+  end
+
+  def export
+    @exporter.export
+  end
+
+  def apply(file)
+    walk(file)
+  end
+
+  private
+
+  def walk(file)
+    expected = load_file(file)
+    actual = @exporter.export
+
+    updated = walk_distributions(
+      expected.fetch(:distributions),
+      actual.fetch(:distributions))
+
+    # TODO:
+    #updated = walk_streaming_distributions(
+    #  expected.fetch(:streaming_distributions),
+    #  actual.fetch(:streaming_distributions)) || updated
+
+    if @options[:dry_run]
+      false
+    else
+      updated
+    end
+  end
+
+  def walk_distributions(expected, actual)
+    updated = false
+
+    expected.each do |dist_id,  expected_distribution|
+      origin_ids = expected_distribution.fetch(:origins).fetch(:items).map {|i| i[:id] }.sort
+      next unless origin_ids.any?{|i| matched?(i) }
+
+      if dist_id.is_a?(Array)
+        actual_dist_id, actual_distribution = actual.find do |_, dist|
+          actual_origin_ids = dist.fetch(:origins).fetch(:items).map {|i| i[:id] }.sort
+          actual_origin_ids == dist_id
+        end
+
+        if actual_dist_id
+          actual.delete(actual_dist_id)
+          dist_id = actual_dist_id
+        end
+      else
+        actual_distribution = actual.delete(dist_id)
+      end
+
+      if actual_distribution
+        updated = walk_distribution(dist_id, expected_distribution, actual_distribution) || updated
+      else
+        @driver.create_distribution(dist_id, expected_distribution)
+        updated = true
+      end
+    end
+
+    actual.each do |dist_id, _|
+      @driver.delete_distribution(dist_id)
+      updated = true
+    end
+
+    updated
+  end
+
+  def walk_distribution(dist_id, expected, actual)
+    updated = false
+
+    if expected != actual
+      @driver.update_distribution(dist_id, expected, actual)
+      updated = true
+    end
+
+    updated
+  end
+
+  def load_file(file)
+    if file.kind_of?(String)
+      open(file) do |f|
+        Cfdef::DSL.parse(f.read, file)
+      end
+    elsif file.respond_to?(:read)
+      Cfdef::DSL.parse(file.read, file.path)
+    else
+      raise TypeError, "can't convert #{file} into File"
+    end
+  end
+end

data/lib/cfdef/driver.rb

@@ -0,0 +1,76 @@
+class Cfdef::Driver
+  include Cfdef::Utils::Helper
+  include Cfdef::Logger::Helper
+
+  def initialize(client, options = {})
+    @client = client
+    @options = options
+  end
+
+  def create_distribution(dist_id, distribution)
+    log(:info, "Create Distribution `#{dist_id}`", color: :cyan)
+
+    unless @options[:dry_run]
+      caller_reference = "#{dist_id} #{SecureRandom.uuid}"
+
+      params = {
+        distribution_config: {
+          caller_reference: caller_reference,
+        }.merge(distribution),
+      }
+
+      @client.create_distribution(params)
+    end
+  end
+
+  def delete_distribution(dist_id)
+    log(:info, "Delete Distribution `#{dist_id}`", color: :red)
+
+    unless @options[:dry_run]
+      etag = @client.get_distribution(id: dist_id).etag
+
+      params = {
+        id: dist_id,
+        if_match: etag,
+      }
+
+      @client.delete_distribution(params)
+    end
+  end
+
+  def update_distribution(dist_id, distribution, old_distribution)
+    log(:info, "Update Distribution `#{dist_id}`", color: :green)
+    log(:info, diff(old_distribution, distribution, color: @options[:color]), color: false)
+
+    unless @options[:dry_run]
+      resp = @client.get_distribution(id: dist_id)
+      etag = resp.etag
+      caller_reference = resp.distribution.distribution_config.caller_reference
+
+      dist_conf = {
+        caller_reference: caller_reference,
+      }.merge(distribution)
+
+      unless dist_conf[:default_root_object]
+        dist_conf[:default_root_object] = ""
+      end
+
+      unless dist_conf[:logging]
+        dist_conf[:logging] = {
+          enabled: false,
+          include_cookies: false,
+          bucket: '',
+          prefix: '',
+        }
+      end
+
+      params = {
+        distribution_config: dist_conf,
+        id: dist_id,
+        if_match: etag,
+      }
+
+      @client.update_distribution(params)
+    end
+  end
+end

data/lib/cfdef/dsl.rb

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

data/lib/cfdef/dsl/context.rb

@@ -0,0 +1,58 @@
+class Cfdef::DSL::Context
+  def self.eval(dsl, path, options = {})
+    self.new(path, options) {
+      eval(dsl, binding, path)
+    }
+  end
+
+  def result
+    @result.sort_array!
+  end
+
+  def initialize(path, options = {}, &block)
+    @path = path
+    @options = options
+
+    @result = {
+      distributions: {},
+      # TODO:
+      #streaming_distributions: {},
+    }
+
+    instance_eval(&block)
+  end
+
+  private
+
+  def require(file)
+    cf_file = (file =~ %r|\A/|) ? file : File.expand_path(File.join(File.dirname(@path), file))
+
+    if File.exist?(cf_file)
+      instance_eval(File.read(cf_file), cf_file)
+    elsif File.exist?(cf_file + '.rb')
+      instance_eval(File.read(cf_file + '.rb'), cf_file + '.rb')
+    else
+      Kernel.require(file)
+    end
+  end
+
+  def distribution(dist_id = nil, &block)
+    dist_conf = Dslh.eval(key_conv: :to_sym.to_proc, &block)
+
+    if dist_id
+      dist_id = dist_id.to_s
+    else
+      dist_id = dist_conf.fetch(:origins).fetch(:items).map {|i| i[:id].to_s }.sort
+    end
+
+    if @result[dist_id]
+      raise "Distribution `#{dist_id}` is already defined"
+    end
+
+    @result[:distributions][dist_id] = dist_conf
+  end
+
+  # TODO:
+  #def streaming_distributions
+  #end
+end

data/lib/cfdef/dsl/converter.rb

@@ -0,0 +1,41 @@
+class Cfdef::DSL::Converter
+  include Cfdef::Utils::Helper
+
+  def self.convert(exported, options = {})
+    self.new(exported, options).convert
+  end
+
+  def initialize(exported, options = {})
+    @exported = exported
+    @options = options
+  end
+
+  def convert
+    output_distributions(@exported.fetch(:distributions))
+
+    # TODO:
+    #output_streaming_distributions(@exported.fetch(:streaming_distributions))
+  end
+
+  private
+
+  def output_distributions(distributions_by_id)
+    distributions = []
+
+    distributions_by_id.sort_by(&:first).each do |dist_id, distribution|
+      distributions << output_distribution(dist_id, distribution)
+    end
+
+    distributions.join("\n")
+  end
+
+  def output_distribution(dist_id, distribution)
+    dist_conf = Dslh.deval(distribution, initial_depth: 1).strip
+
+    <<-EOS
+distribution #{dist_id.inspect} do
+  #{dist_conf}
+end
+    EOS
+  end
+end

data/lib/cfdef/exporter.rb

@@ -0,0 +1,41 @@
+class Cfdef::Exporter
+  include Cfdef::Utils::Helper
+
+  def initialize(client, options = {})
+    @client = client
+    @options = options
+  end
+
+  def export
+    {
+      distributions: export_distributions,
+      # TODO:
+      #streaming_distributions: export_streaming_distributions,
+    }.sort_array!
+  end
+
+  private
+
+  def export_distributions
+    result = {}
+
+    distributions = @client.list_distributions.flat_map(&:distribution_list).flat_map(&:items).map(&:to_h)
+
+    distributions.each do |distribution|
+      distribution_id = distribution.fetch(:id)
+      origin_ids = distribution.fetch(:origins).fetch(:items).map {|i| i[:id] }.sort
+      next unless origin_ids.any?{|i| matched?(i) }
+      result[distribution_id] = remove_status!(distribution)
+    end
+
+    result
+  end
+
+  def remove_status!(distribution)
+    [:id, :status, :last_modified_time, :domain_name].each do |key|
+      distribution.delete(key)
+    end
+
+    distribution
+  end
+end

data/lib/cfdef/ext/hash_ext.rb

@@ -0,0 +1,33 @@
+module Cfdef::Ext
+  module HashExt
+    def sort_array!
+      keys.each do |key|
+        value = self[key]
+        self[key] = sort_array0(value)
+      end
+
+      self
+    end
+
+    private
+
+    def sort_array0(value)
+      case value
+      when Hash
+        new_value = {}
+
+        value.each do |k, v|
+          new_value[k] = sort_array0(v)
+        end
+
+        new_value
+      when Array
+        value.map {|v| sort_array0(v) }.sort_by(&:to_s)
+      else
+        value
+      end
+    end
+  end
+end
+
+Hash.include(Cfdef::Ext::HashExt)

data/lib/cfdef/ext/string_ext.rb

@@ -0,0 +1,28 @@
+module Cfdef::Ext
+  module StringExt
+    module ClassMethods
+      def colorize=(value)
+        @colorize = value
+      end
+
+      def colorize
+        @colorize
+      end
+    end # ClassMethods
+
+    Term::ANSIColor::Attribute.named_attributes.each do |attribute|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def #{attribute.name}
+          if String.colorize
+            Term::ANSIColor.send(#{attribute.name.inspect}, self)
+          else
+            self
+          end
+        end
+      EOS
+    end
+  end
+end
+
+String.include(Cfdef::Ext::StringExt)
+String.extend(Cfdef::Ext::StringExt::ClassMethods)

data/lib/cfdef/logger.rb

@@ -0,0 +1,28 @@
+class Cfdef::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, log_options = {})
+      global_option = @options || {}
+      message = "[#{level.to_s.upcase}] #{message}" unless level == :info
+      message << ' (dry-run)' if global_option[:dry_run]
+      message = message.send(log_options[:color]) if log_options[:color]
+      logger = global_option[:logger] || Cfdef::Logger.instance
+      logger.send(level, message)
+    end
+  end
+end

data/lib/cfdef/utils.rb

@@ -0,0 +1,23 @@
+class Cfdef::Utils
+  module Helper
+    def matched?(name)
+      if @options[:target]
+        @options[:target] =~ name
+      else
+        true
+      end
+    end
+
+    def diff(obj1, obj2, options = {})
+      diffy = Diffy::Diff.new(
+        obj1.pretty_inspect,
+        obj2.pretty_inspect,
+        :diff => '-u'
+      )
+
+      out = diffy.to_s(options[:color] ? :color : :text).gsub(/\s+\z/m, '')
+      out.gsub!(/^/, options[:indent]) if options[:indent]
+      out
+    end
+  end
+end

data/lib/cfdef/version.rb

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

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: cfdef
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- winebarrel
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: diffy
+  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: dslh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Cfdef is a tool to manage CloudFront.
+email:
+- sgwr_dts@yahoo.co.jp
+executables:
+- cfdef
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- cfdef.gemspec
+- exe/cfdef
+- lib/cfdef.rb
+- lib/cfdef/client.rb
+- lib/cfdef/driver.rb
+- lib/cfdef/dsl.rb
+- lib/cfdef/dsl/context.rb
+- lib/cfdef/dsl/converter.rb
+- lib/cfdef/exporter.rb
+- lib/cfdef/ext/hash_ext.rb
+- lib/cfdef/ext/string_ext.rb
+- lib/cfdef/logger.rb
+- lib/cfdef/utils.rb
+- lib/cfdef/version.rb
+homepage: https://github.com/winebarrel/cfdef
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Cfdef is a tool to manage CloudFront.
+test_files: []