rapis 0.1.0

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 "rapis"
+
+# 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/exe/rapis

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'rapis/cli'
+Version = Rapis::VERSION
+
+Rapis::Cli.start(ARGV)

data/lib/rapis.rb

@@ -0,0 +1,7 @@
+require "rapis/version"
+require "rapis/actions"
+require "rapis/cli"
+require "rapis/client"
+require "rapis/converter"
+require "rapis/logger"
+require "rapis/utils"

data/lib/rapis/actions.rb

@@ -0,0 +1,102 @@
+require 'yaml'
+require 'json'
+require 'rapis/client'
+require 'rapis/converter'
+require 'rapis/logger'
+require 'rapis/utils'
+
+module Rapis
+  class Actions
+    include Rapis::Logger::Helper
+
+    def initialize
+      @client = Rapis::Client.new
+      @converter = Rapis::Converter.new
+    end
+
+    def create(name, options)
+      ret = @client.create(name, options['description'])
+      info("API id: #{ret.id}")
+      info("API name: #{ret.name}")
+      info("API description: #{ret.description}")
+      ret.warnings.each {|w| warn("WARNING: #{w}") } unless ret.warnings.nil?
+    end
+
+    def convert(options)
+      output = @converter.to_h(File.read(options['file']))
+      case options['format']
+      when 'json'
+        output = JSON.pretty_generate(output)
+        Rapis::Utils.print_json(output)
+      when 'yaml'
+        output = YAML.dump(output)
+        Rapis::Utils.print_yaml(output)
+      else
+        raise "\"#{options['format']}\" format is not supported."
+      end
+      File.write(options['output'], output) unless options['output'].empty?
+    end
+
+    def list(options)
+      @client.get_apis.each do |a|
+        if options['verbose']
+          api = Rapis::Utils.struct_to_hash(a)
+          api['stages'] = []
+        else
+          a_key = "#{a.id} (#{a.name})"
+          api = {a_key => []}
+        end
+
+        @client.get_stages(a.id).each do |s|
+          if options['verbose']
+            api['stages'] << Rapis::Utils.struct_to_hash(s)
+          else
+            api[a_key] = s.stage_name
+          end
+        end
+        Rapis::Utils.print_yaml(YAML.dump(api))
+      end
+    end
+
+    def export(options)
+      dsl = @converter.to_dsl(
+        @client.export_api(options['rest_api'], options['stage'])
+      )
+      Rapis::Utils.print_ruby(dsl)
+      File.write(options['file'], dsl) if options['write']
+    end
+
+    def diff(options)
+      puts Rapis::Utils.diff(
+        @client.export_api(options['rest_api'], options['stage']),
+        @converter.to_h(File.read(options['file']))
+      )
+    end
+
+    def apply(options)
+      ret = @client.put_api(
+        options['rest_api'],
+        @converter.to_h(File.read(options['file']))
+      )
+      info("Applied the REST API configuration to \"#{ret.id}\" (#{ret.name})")
+      ret.warnings.each {|w| warn("WARNING: #{w}") } unless ret.warnings.nil?
+    end
+
+    def deploy(options)
+      args = {}
+      args[:rest_api_id] = options['rest_api']
+      args[:stage_name] = options['stage']
+      args[:description] = options['description'] unless options['description'].empty?
+      args[:stage_description] = options['stage_description'] unless options['description'].empty?
+      args[:cache_cluster_enabled] = (options['cache'].to_f > 0.0)
+      args[:cache_cluster_size] = options['cache'] if args[:cache_cluster_enabled]
+      args[:variables] = options['variables'] unless options['variables'].empty?
+
+      ret = @client.deploy(args)
+      summary = YAML.dump(Rapis::Utils.struct_to_hash(ret.api_summary))
+      info("Deployment id: #{ret.id}")
+      info("Deployment description: #{ret.description}")
+      info("API summary :\n#{summary}")
+    end
+  end
+end

data/lib/rapis/cli.rb

@@ -0,0 +1,64 @@
+require 'thor'
+require 'rapis/actions'
+
+module Rapis
+  class Cli < Thor
+    class_option :file, aliases: '-f', desc: 'Configuration file', type: :string, default: 'Apifile'
+
+    def initialize(*args)
+      @actions = Rapis::Actions.new
+      super(*args)
+    end
+
+    desc "create", "Create REST API"
+    option :description, aliases: '-d', desc: 'Description', type: :string, default: ''
+    def create(name)
+      @actions.create(name, options)
+    end
+
+    desc "convert", "Convert the REST API configuration to the specified format"
+    option :format, aliases: '-F', desc: 'Output format # accepts json, yaml', type: :string, required: true
+    option :output, aliases: '-o', desc: 'Output path', type: :string, default: ''
+    def convert
+      @actions.convert(options)
+    end
+
+    desc "list", "List the REST APIs and the stages"
+    option :verbose, aliases: '-V', desc: 'Verbose mode', type: :boolean, default: false
+    def list
+      @actions.list(options)
+    end
+
+    desc "export", "Export the configuration as Ruby DSL"
+    option :rest_api, aliases: '-r', desc: 'The id of the REST API', type: :string, required: true
+    option :stage, aliases: '-s', desc: 'The name of the stage', type: :string, required: true
+    option :write, aliases: '-w', desc: 'Write the configuration to the file', type: :boolean, default: false
+    def export
+      @actions.export(options)
+    end
+
+    desc "diff", "Diff the local configuration and the remote configuration"
+    option :rest_api, aliases: '-r', desc: 'The id of the REST API', type: :string, required: true
+    option :stage, aliases: '-s', desc: 'The name of the stage', type: :string, required: true
+    def diff
+      @actions.diff(options)
+    end
+
+    desc "apply", "Apply the REST API configuration"
+    option :rest_api, aliases: '-r', desc: 'The id of the REST API', type: :string, required: true
+    def apply
+      @actions.apply(options)
+    end
+
+    desc "deploy", "Deploy the current REST API configuration to the stage"
+    option :rest_api, aliases: '-r', desc: 'The id of the REST API', type: :string, required: true
+    option :stage, aliases: '-s', desc: 'The name of the stage', type: :string, required: true
+    option :description, aliases: '-d', desc: 'The description for the deployment', type: :string, default: ''
+    option :stage_description, aliases: '-D', desc: 'The description of the stage', type: :string, default: ''
+    option :cache, aliases: '-c', desc: 'Size of the cache cluster # accepts 0.5, 1.6, 6.1, 13.5, 28.4, 58.2, 118, 237', type: :string, default: '0.0'
+    option :variables, aliases: '-v', desc: 'A map that defines the stage variables', type: :hash, default: {}
+    def deploy
+      @actions.deploy(options)
+    end
+  end
+end

data/lib/rapis/client.rb

@@ -0,0 +1,58 @@
+require 'aws-sdk'
+require 'base64'
+require 'json'
+require 'rapis/utils'
+
+module Rapis
+  class Client
+
+    def initialize
+      @api = Aws::APIGateway::Client.new
+    end
+
+    def create(name, desc)
+      @api.create_rest_api({
+        name: name,
+        description: desc
+      })
+    end
+
+    def get_apis(pos=nil)
+      opt = {}
+      opt[:limit] = 500
+      opt[:position] = pos unless pos.nil?
+
+      ret = @api.get_rest_apis(opt)
+      ret.items.concat(get_apis(ret.posision)) unless ret.position.nil?
+      ret.items
+    end
+
+    def get_stages(api_id, pos=nil)
+      @api.get_stages({rest_api_id: api_id}).item
+    end
+
+    def export_api(api_id, stage_name)
+      ret = @api.get_export({
+        rest_api_id: api_id,
+        stage_name: stage_name,
+        export_type: 'swagger',
+        parameters: { extensions: 'integrations' }
+      })
+
+      JSON.load(ret.body.read)
+    end
+
+    def put_api(api_id, data)
+      @api.put_rest_api({
+        rest_api_id: api_id,
+        mode: 'overwrite',
+        parameters: { extensions: 'integrations' },
+        body: JSON.dump(data)
+      })
+    end
+
+    def deploy(args)
+      @api.create_deployment(args)
+    end
+  end
+end

data/lib/rapis/converter.rb

@@ -0,0 +1,124 @@
+require 'dslh'
+require 'rapis/utils'
+require 'pp'
+
+CHANGE_SETS = {
+  'x-amazon-apigateway-integration' => 'amazon_apigateway_integration',
+  '$ref' => 'ref'
+}
+
+module Rapis
+  class Converter
+    def to_dsl(hash)
+      exclude_key = proc do |k|
+        if ['in'].include?(k)
+          true
+        elsif (k.include?('/') and not k =~ /^\//)
+          true
+        elsif ['-', '.'].any? {|i| k.include?(i) } and k != 'x-amazon-apigateway-integration'
+          true
+        else
+          false
+        end
+      end
+
+      key_conv = proc do |k|
+        k = k.to_s
+        if k =~ /^\//
+          proc do |v, nested|
+            if nested
+              "path #{k.inspect} #{v}"
+            else
+              "path #{k.inspect}, #{v}"
+            end
+          end
+        elsif k =~ /^\d{3}$/
+          proc do |v, nested|
+            if nested
+              "code #{k} #{v}"
+            else
+              "code #{k}, #{v}"
+            end
+          end
+        else
+          CHANGE_SETS.each { |f,t| k = k.gsub(f,t) }
+          k
+        end
+      end
+
+      value_conv = proc do |v|
+        if v.kind_of?(String) and v =~ /\A(?:0|[1-9]\d*)\Z/
+          v.to_i
+        else
+          v
+        end
+      end
+
+      dsl = Dslh.deval(
+        hash,
+        exclude_key: exclude_key,
+        key_conv: key_conv,
+        value_conv: value_conv)
+      dsl.gsub!(/^/, '  ').strip!
+<<-EOS
+rest_api do
+  #{dsl}
+end
+EOS
+    end
+
+    def to_h(dsl)
+      instance_eval(dsl)
+      @apis
+    end
+
+    private
+
+    def rest_api(value = nil, &block)
+      exclude_key = proc do |k|
+        false
+      end
+
+      key_conv = proc do |k|
+        k = k.to_s
+        CHANGE_SETS.each { |f,t| k = k.gsub(t,f) }
+        k
+      end
+
+      value_conv = proc do |v|
+        case v
+        when Hash, Array
+          v
+        else
+          v.to_s
+        end
+      end
+
+      @apis = Dslh.eval(
+        exclude_key: exclude_key,
+        key_conv: key_conv,
+        value_conv: value_conv,
+        allow_empty_args: true,
+        scope_hook: proc {|scope| define_template_func(scope)},
+        &block
+      )
+    end
+
+    def define_template_func(scope)
+      scope.instance_eval(<<-EOS)
+        def path(key, value = nil, &block)
+          if block
+            value = Dslh::ScopeBlock.nest(binding, 'block', key)
+          end
+          @__hash__[key] = value
+        end
+        def code(key, value = nil, &block)
+          if block
+            value = Dslh::ScopeBlock.nest(binding, 'block', key)
+          end
+          @__hash__[key] = value
+        end
+        EOS
+    end
+  end
+end

data/lib/rapis/logger.rb

@@ -0,0 +1,86 @@
+require 'logger'
+require 'singleton'
+
+module Rapis
+  class TermColor
+    class << self
+
+      def green(msg)
+        colorize 32, msg
+      end
+
+      def yellow(msg)
+        colorize 33, msg
+      end
+
+      def red(msg)
+        colorize 31, msg
+      end
+
+      def colorize(num, msg)
+        "\e[#{num}m#{msg}\e[0m"
+      end
+
+    end
+  end
+
+  class Logger < Logger
+    include Singleton
+
+    def initialize
+      super(STDERR)
+
+      self.formatter = proc do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+
+      self.level = Logger::INFO
+    end
+
+    def debug(progname = nil, method_name = nil, msg)
+      super(progname) { { method_name: method_name, message: msg } }
+    end
+
+    def info(msg)
+      super { Rapis::TermColor.green(msg) }
+    end
+
+    def warn(msg)
+      super { Rapis::TermColor.yellow(msg) }
+    end
+
+    def fatal(msg)
+      super { Rapis::TermColor.red(msg) }
+    end
+
+    def error(progname = nil, method_name = nil, msg, backtrace)
+      super(progname) { { method_name: method_name, message: msg, backtrace: backtrace } }
+    end
+
+    module Helper
+
+      def log(level, message)
+        logger = Rapis::Logger.instance
+        logger.send(level, message)
+      end
+
+      def info(msg)
+        log(:info, msg)
+      end
+
+      def warn(msg)
+        log(:warn, msg)
+      end
+
+      def fatal(msg)
+        log(:error, msg)
+      end
+
+      def debug(msg)
+        log(:debug, msg)
+      end
+
+      module_function :log, :info, :warn, :fatal, :debug
+    end
+  end
+end