kongfigure 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f564d50bbbc1a4cf274b1852df89477270c45f123412a03c06201fe3a084e6fb
+  data.tar.gz: eae01666b3ce461e99ac2f2698a0a3fc33d914358ed81805a2121f550413be20
+SHA512:
+  metadata.gz: 02d1ca884c2892bb0020745baccad8491cc51dec67f8165abeb220ec323e5cb760f39ef680e8e17e10642a7cbede32527a3636b674e56d6c8437ab09225266a6
+  data.tar.gz: 9650447e01b1cc052c808df5e85ecc211f500a5168b4b6855516d502ee2e4ff0a738c283c30e8137dd20d5a9ce8aa29fc0b19d6599ad54157afda034ae8d68a7

data/.gitignore

@@ -0,0 +1,54 @@
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/ibanity/kongfigure" }
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    kongfigure (0.0.1)
+      awesome_print
+      colorize
+      dry-inflector
+      rest-client (~> 2.0, >= 2.0.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    awesome_print (1.8.0)
+    colorize (0.8.1)
+    domain_name (0.5.20180417)
+      unf (>= 0.0.5, < 1.0.0)
+    dry-inflector (0.1.2)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    mime-types (3.2.2)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2018.0812)
+    netrc (0.11.0)
+    rest-client (2.0.2)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  kongfigure!
+
+BUNDLED WITH
+   2.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Ibanity, Isabel Group
+
+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,3 @@
+# Kongfigure
+
+## WIP :)

data/exe/kongfigure

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "kongfigure"
+
+ARGV << '-h' if ARGV.empty?
+Kongfigure.start(ARGV)

data/exe/kongfigure_local

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/kongfigure"
+
+ARGV << '-h' if ARGV.empty?
+Kongfigure.start(ARGV)

data/kongfigure.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "kongfigure/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "kongfigure"
+  spec.version       = Kongfigure::VERSION
+  spec.authors       = ["Ibanity"]
+  spec.email         = ["it@ibanity.com"]
+
+  spec.summary       = %q{Kongfigure.}
+  spec.description   = %q{A tool to manage Kong resources with a declarative configuration.}
+  spec.homepage      = "https://github.com/ibanity/kongfigure"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 2.4.0"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = ["kongfigure"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+
+  spec.add_dependency "rest-client",   "~> 2.0", ">= 2.0.2"
+  spec.add_dependency "awesome_print", "~> 1.8.0"
+  spec.add_dependency "dry-inflector", "~> 0.1.2"
+  spec.add_dependency "colorize",      "~> 0.8.1"
+end

data/lib/kongfigure/cli.rb

@@ -0,0 +1,21 @@
+require "optparse"
+
+module Kongfigure
+  class CLI
+    attr_accessor :options
+
+    def initialize
+      @options       = {}
+      @option_parser = OptionParser.new do |parser|
+        parser.on("-f", "--file FILE", "Path to the Kongfigure configuration file.") do |file|
+          @options[:file] = file
+        end
+      end
+    end
+
+    def parse!(args)
+      @option_parser.parse!(args)
+      @options
+    end
+  end
+end

data/lib/kongfigure/configuration.rb

@@ -0,0 +1,51 @@
+require "optparse"
+require "pp"
+require "awesome_print"
+
+module Kongfigure
+  class Configuration
+
+    attr_accessor :host, :services, :consumers, :plugins, :upstreams
+
+    def initialize
+      @host      = nil
+      @services  = []
+      @consumers = []
+      @plugins   = []
+      @upstreams = []
+    end
+
+    def add_services(yaml_services)
+      yaml_services.each do |yaml_service|
+        @services.push(Kongfigure::Resources::Service.build(yaml_service))
+      end
+    end
+
+    def add_consumers(yaml_consumers)
+      yaml_consumers.each do |yaml_consumer|
+        @consumers.push(Kongfigure::Resources::Consumer.build(yaml_consumer))
+      end
+    end
+
+    def add_plugins(yaml_plugins)
+      yaml_plugins.each do |yaml_plugin|
+        @plugins.push(Kongfigure::Resources::Plugin.build(yaml_plugin))
+      end
+    end
+
+    def add_upstreams(yaml_upstreams)
+      yaml_upstreams.each do |yaml_upstream|
+        @upstreams.push(Kongfigure::Resources::Upstream.build(yaml_upstream))
+      end
+    end
+
+    def to_s
+      {
+        services:  @services.map  do |service| service.to_s end,
+        consumers: @consumers.map do |consumer| consumer.to_s end,
+        plugins:   @plugins.map   do |plugin| plugin.to_s end,
+        upstreams: @upstreams.map do |upstream| upstream.to_s end
+      }.ai
+    end
+  end
+end

data/lib/kongfigure/errors/bad_request.rb

@@ -0,0 +1,4 @@
+module Kongfigure::Errors
+  class BadRequest < StandardError
+  end
+end

data/lib/kongfigure/errors/internal_server_error.rb

@@ -0,0 +1,4 @@
+module Kongfigure::Errors
+  class InternalServerError < StandardError
+  end
+end

data/lib/kongfigure/errors/invalid_configuration.rb

@@ -0,0 +1,4 @@
+module Kongfigure::Errors
+  class InvalidConfiguration < StandardError
+  end
+end

data/lib/kongfigure/errors/resource_conflict.rb

@@ -0,0 +1,4 @@
+module Kongfigure::Errors
+  class ResourceConflict < StandardError
+  end
+end

data/lib/kongfigure/errors/resource_not_found.rb

@@ -0,0 +1,4 @@
+module Kongfigure::Errors
+  class ResourceNotFound < StandardError
+  end
+end

data/lib/kongfigure/http_client.rb

@@ -0,0 +1,94 @@
+require "json"
+
+module Kongfigure
+  class HTTPClient
+
+    HTTP_HEADERS = {
+      accept: "application/json; charset=UTF-8",
+      content_type: "application/json; charset=UTF-8",
+      accept_encoding: "gzip"
+    }
+
+    def initialize
+      @configuration = {
+        ssl_ca_path: nil,
+        verify_ssl:  OpenSSL::SSL::VERIFY_NONE,
+        url:         "https://localhost:8445"
+      }
+      @inflector = Dry::Inflector.new
+    end
+
+    def post(path, payload)
+      execute(request_options(:post, path, payload))
+    end
+
+    def put(path, payload)
+      execute(request_options(:put, path, payload))
+    end
+
+    def patch(path, payload)
+      execute(request_options(:patch, path, payload))
+    end
+
+    def get(path)
+      execute(request_options(:get, path))
+    end
+
+    def delete(path)
+      execute(request_options(:delete, path))
+   end
+
+    private
+
+    def execute(options)
+      RestClient::Request.execute(options) do |response, _request, _result|
+        handle_response(response)
+      end
+    end
+
+    def ssl_options
+      {
+       ssl_ca_file: @configuration[:ssl_ca_path],
+       verify_ssl:  @configuration[:verify_ssl]
+     }
+    end
+
+    def request_options(method, path, payload = nil)
+      opts = {
+        method: method,
+        url: "#{@configuration[:url]}/#{path}",
+        headers: HTTP_HEADERS,
+      }
+
+      opts.merge!(ssl_options) if @configuration[:url].include?("https://")
+      opts.merge!(payload: payload) if payload
+
+      opts
+    end
+
+
+    def handle_response(response)
+      if response.code == 204
+        nil
+      elsif response.code.between?(200, 399)
+        handle_success(response)
+      elsif response.code == 400
+        parsed_response = JSON.parse(response.body)
+        raise Kongfigure::Errors::BadRequest, {
+          name:   parsed_response["name"],
+          fields: parsed_response["fields"]
+        }
+      elsif response.code == 404
+        raise Kongfigure::Errors::ResourceNotFound
+      elsif response.code == 409
+        raise Kongfigure::Errors::ResourceConflict
+      elsif response.code == 500
+        raise Kongfigure::Errors::InternalServerError
+      end
+    end
+
+    def handle_success(response)
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/kongfigure/kong.rb

@@ -0,0 +1,40 @@
+module Kongfigure
+  class Kong
+
+    def initialize(parser, http_client)
+      @parser      = parser
+      @http_client = http_client
+      display_information
+    end
+
+    def apply!
+      @configuration = @parser.parse!
+      puts @configuration.to_s
+      puts "Applying configuration...".colorize(:color => :white, :background => :red)
+      apply_all(@configuration.plugins, Kongfigure::Services::Plugin)
+      apply_all(@configuration.upstreams, Kongfigure::Services::Upstream)
+      apply_all(@configuration.services, Kongfigure::Services::Service)
+      apply_all(@configuration.consumers, Kongfigure::Services::Consumer)
+      puts "Done.".colorize(:color => :white, :background => :red)
+    end
+
+    def apply_all(resources, service_module)
+      service          = service_module.new(@http_client)
+      puts "<- Fetching remote #{service.resource_name}..."
+      remote_resources = service.all
+
+      resources.map do |resource|
+        service.create_or_update(@http_client, resource, remote_resources)
+      end
+      service.cleanup_useless_resources(@http_client, resources, remote_resources)
+    end
+
+    def display_information
+      data = @http_client.get("/")
+      puts "Kong information:".colorize(:color => :white, :background => :red)
+      puts "* hostname: \t#{data['version']}"
+      puts "* version: \t#{data['hostname']}"
+      puts "* lua_version: \t#{data['lua_version']}"
+    end
+  end
+end

data/lib/kongfigure/parser.rb

@@ -0,0 +1,32 @@
+require "yaml"
+
+module Kongfigure
+  class Parser
+
+    def initialize(file)
+      @yaml_configuration = File.read(file)
+      @configuration      = Kongfigure::Configuration.new
+    end
+
+    def parse!
+      puts "Parsing YAML configuration...".colorize(:color => :white, :background => :red)
+      YAML.load(@yaml_configuration).each do |key, value|
+        case key
+        when "host"
+          @configuration.host = value
+        when "services"
+          @configuration.add_services(value || [])
+        when "consumers"
+           @configuration.add_consumers(value || [])
+        when "plugins"
+           @configuration.add_plugins(value || [])
+        when "upstreams"
+           @configuration.add_upstreams(value || [])
+        else
+          raise "Invalid configuration key: #{key}."
+        end
+      end
+      @configuration
+    end
+  end
+end

data/lib/kongfigure/resources/base.rb

@@ -0,0 +1,48 @@
+require "dry/inflector"
+
+module Kongfigure::Resources
+  class Base
+
+    attr_accessor :id, :kongfigure_ignore_fields, :plugins
+
+    def initialize(id, kongfigure_ignore_fields = nil)
+      @id                       = id
+      @kongfigure_ignore_fields = (kongfigure_ignore_fields || []).map { |field| field.split(".") }
+      @plugins                  = []
+    end
+
+    def self.build_all(resources_hash)
+      resources_hash.map do |resource_hash|
+        build(resource_hash)
+      end
+    end
+
+    def ==(other_object)
+      differences = deep_diff(other_object.api_attributes, api_attributes, kongfigure_ignore_fields)
+      differences.flatten.size == 0
+    end
+
+    private
+
+    def deep_diff(a, b, ignore_nested_keys=[], level=0)
+      ignore_nested_keys = ignore_nested_keys.inject([]) do |ignore_nested_keys, ignore_nested_key|
+        current_key = ignore_nested_key[level]
+        if a.has_key?(current_key) || b.has_key?(current_key)
+          ignore_nested_keys.push(ignore_nested_key[level..ignore_nested_key.size])
+        end
+        ignore_nested_keys
+      end
+      ignore_keys = ignore_nested_keys.select {|ignore_nested_key| ignore_nested_key.size == 1}.flatten
+      (a.keys | b.keys).each_with_object([]) do |k, diff|
+        if a[k] != b[k]
+          if a[k].is_a?(Hash) && b[k].is_a?(Hash)
+            diff.push(deep_diff(a[k], b[k], ignore_nested_keys, level + 1))
+          elsif !ignore_keys.include?(k) && !b[k].nil? && k != "id"
+            diff.push([a[k], b[k], k, level])
+          end
+        end
+        diff
+      end
+    end
+  end
+end

data/lib/kongfigure/resources/consumer.rb

@@ -0,0 +1,40 @@
+module Kongfigure::Resources
+  class Consumer < Base
+    attr_accessor :username, :acls, :key_auths, :custom_id
+
+    def self.build(hash)
+      consumer           = new(hash["id"], hash["kongfigure_ignore_fields"])
+      consumer.username  = hash["username"]
+      consumer.custom_id = hash["custom_id"]
+      consumer.acls      = Kongfigure::Resources::Consumers::ACL.build_all(hash["acls"] || [])
+      consumer.plugins   = Kongfigure::Resources::Plugin.build_all(hash["plugins"] || [])
+      consumer.key_auths = (hash["key_auths"] || []).map do |key_auth_hash|
+        Kongfigure::Resources::Consumers::KeyAuth.build(key_auth_hash)
+      end
+      consumer
+    end
+
+    def identifier
+      username
+    end
+
+    def api_attributes
+      {
+        "username"  =>  username,
+        "custom_id" => custom_id
+      }.compact
+    end
+
+    def has_key_auth?(key_auth)
+      key_auths && key_auths.include?(key_auth)
+    end
+
+    def has_acl?(acl)
+      acls && acls.include?(acl)
+    end
+
+    def to_s
+      "#{username}"
+    end
+  end
+end

data/lib/kongfigure/resources/consumers/acl.rb

@@ -0,0 +1,18 @@
+module Kongfigure::Resources::Consumers
+  class ACL < ::Kongfigure::Resources::Base
+
+    attr_accessor :group
+
+    def self.build(hash)
+      acl       = new(hash["id"])
+      acl.group = hash["group"]
+      acl
+    end
+
+    def api_attributes
+      {
+        "group" => group
+      }.compact
+    end
+  end
+end

data/lib/kongfigure/resources/consumers/key_auth.rb

@@ -0,0 +1,18 @@
+module Kongfigure::Resources::Consumers
+  class KeyAuth < ::Kongfigure::Resources::Base
+
+    attr_accessor :key
+
+    def self.build(hash)
+      key_auth     = new(hash["id"])
+      key_auth.key = hash["key"]
+      key_auth
+    end
+
+    def api_attributes
+      {
+        "key" => key
+      }
+    end
+  end
+end

data/lib/kongfigure/resources/plugin.rb

@@ -0,0 +1,51 @@
+module Kongfigure::Resources
+  class Plugin < Base
+    attr_accessor :name, :config, :enabled, :route, :service, :consumer, :run_on
+
+    def self.build(hash)
+      plugin          = new(hash["id"], hash["kongfigure_ignore_fields"])
+      plugin.config   = hash["config"]
+      plugin.name     = hash["name"]
+      plugin.enabled  = hash["enabled"]
+      plugin.route    = hash["route"]
+      plugin.service  = hash["service"]
+      plugin.consumer = hash["consumer"]
+      plugin.run_on   = hash["run_on"]
+      plugin
+    end
+
+    def identifier
+      name
+    end
+
+    def api_attributes
+      {
+        "name"     =>     name,
+        "config"   =>   config,
+        "enabled"  =>  enabled,
+        "route"    =>    route,
+        "service"  =>  service,
+        "consumer" => consumer,
+        "run_on"   =>   run_on
+      }.compact
+    end
+
+    def is_global?
+      service.nil? && route.nil? && consumer.nil?
+    end
+
+    def to_s
+      str = name
+      if route
+        str += " on route #{route}"
+      elsif service
+        str += " on service #{service}"
+      elsif consumer
+        str += " on consumer #{consumer}"
+      else
+        str += " attached globally"
+      end
+      str + (enabled ? " (enabled)" : " (disabled)")
+    end
+  end
+end

data/lib/kongfigure/resources/route.rb

@@ -0,0 +1,41 @@
+module Kongfigure::Resources
+  class Route < Base
+    attr_accessor :name, :protocols, :methods, :hosts, :paths, :regex_priority, :strip_path, :preserve_host, :snis,
+                  :sources, :destinations, :service
+
+    def self.build(hash)
+      route                = new(hash["id"], hash["kongfigure_ignore_fields"])
+      route.name           = hash["name"]
+      route.protocols      = hash["protocols"]
+      route.methods        = hash["methods"]
+      route.paths          = hash["paths"]
+      route.regex_priority = hash["regex_priority"]
+      route.strip_path     = hash["strip_path"]
+      route.preserve_host  = hash["snis"]
+      route.sources        = hash["destinations"]
+      route.service        = hash["service"]
+      route.hosts          = hash["hosts"]
+      route.plugins        = Kongfigure::Resources::Plugin.build_all(hash["plugins"] || [])
+      route
+    end
+
+    def identifier
+      name
+    end
+
+    def api_attributes
+      {
+        "name"           => name,
+        "protocols"      => protocols,
+        "methods"        => methods,
+        "paths"          => paths,
+        "hosts"          => hosts,
+        "regex_priority" => regex_priority,
+        "strip_path"     => strip_path,
+        "preserve_host"  => preserve_host,
+        "sources"        => sources,
+        "service"        => service
+      }.compact
+    end
+  end
+end