kongfigure 0.0.2

data/lib/kongfigure/resources/service.rb

@@ -0,0 +1,56 @@
+require "uri"
+module Kongfigure::Resources
+  class Service < Base
+    attr_accessor :name, :retries, :protocol, :host, :port, :path, :connect_timeout,
+                  :write_timeout, :read_timeout, :url, :routes
+
+    def self.build(hash)
+      service = new(hash["id"], hash["kongfigure_ignore_fields"])
+      service.name            = hash["name"]
+      service.retries         = hash["retries"]
+      service.protocol        = hash["protocol"]
+      service.host            = hash["host"]
+      service.port            = hash["port"]
+      service.path            = hash["path"]
+      service.connect_timeout = hash["connect_timeout"]
+      service.write_timeout   = hash["write_timeout"]
+      service.read_timeout    = hash["read_timeout"]
+      service.plugins         = Kongfigure::Resources::Plugin.build_all(hash["plugins"] || [])
+      service.routes          = Kongfigure::Resources::Route.build_all(hash["routes"] || [])
+      service.url             = hash["url"] || URI::Generic.build({
+        scheme: hash["protocol"],
+        host:   hash["host"],
+        port:   hash["port"],
+        path:   hash["path"]
+      }).to_s
+      service
+    end
+
+    def identifier
+      name
+    end
+
+    def has_route?(route)
+      routes && routes.include?(route)
+    end
+
+    def api_attributes
+      {
+        "name"            => name,
+        "retries"         => retries,
+        "protocol"        => protocol,
+        "host"            => host,
+        "port"            => port,
+        "path"            => path,
+        "connect_timeout" => connect_timeout,
+        "write_timeout"   => write_timeout,
+        "read_timeout"    => read_timeout,
+        "url"             => url
+      }.compact
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/lib/kongfigure/resources/target.rb

@@ -0,0 +1,19 @@
+module Kongfigure::Resources
+  class Target < Base
+    attr_accessor :target, :weight
+
+    def self.build(hash)
+      target        = new(hash["id"], hash["kongfigure_ignore_fields"])
+      target.target = hash["target"]
+      target.weight = hash["weight"]
+      target
+    end
+
+    def api_attributes
+      {
+        "target" => target,
+        "weight" => weight
+      }.compact
+    end
+  end
+end

data/lib/kongfigure/resources/upstream.rb

@@ -0,0 +1,51 @@
+module Kongfigure::Resources
+  class Upstream < Base
+    attr_accessor :name, :hash_on, :hash_fallback, :hash_on_cookie_path, :slots, :healthchecks, :targets,
+                  :hash_fallback, :hash_on_header, :hash_fallback_header, :hash_on_cookie
+
+    def self.build(hash)
+      upstream                      = new(hash["id"], hash["kongfigure_ignore_fields"])
+      upstream.name                 = hash["name"]
+      upstream.hash_on              = hash["hash_on"]
+      upstream.hash_fallback        = hash["hash_fallback"]
+      upstream.hash_on_cookie_path  = hash["hash_on_cookie_path"]
+      upstream.slots                = hash["slots"]
+      upstream.healthchecks         = hash["healthchecks"]
+      upstream.hash_on_header       = hash["hash_on_header"]
+      upstream.hash_fallback        = hash["hash_fallback"]
+      upstream.hash_fallback_header = hash["hash_fallback_header"]
+      upstream.hash_on_cookie       = hash["hash_on_cookie"]
+      upstream.targets              = Kongfigure::Resources::Target.build_all(hash["targets"] || [])
+      upstream
+    end
+
+    def identifier
+      name
+    end
+
+    def to_s
+      if targets.size > 0
+        "#{name} with targets #{targets.map(&:target).join(', ')}"
+      else
+        "#{name} without target"
+      end
+    end
+
+    def api_attributes
+      {
+        "name"                 => name,
+        "hash_on"              => hash_on,
+        "hash_fallback"        => hash_fallback,
+        "hash_on_cookie_path"  => hash_on_cookie_path,
+        "slots"                => healthchecks,
+        "hash_on_header"       => hash_on_header,
+        "hash_fallback_header" => hash_fallback_header,
+        "hash_on_cookie"       => hash_on_cookie
+      }.compact
+    end
+
+    def has_target?(target)
+      targets && targets.include?(target)
+    end
+  end
+end

data/lib/kongfigure/services/base.rb

@@ -0,0 +1,164 @@
+require "colorize"
+
+module Kongfigure::Services
+  class Base
+
+    def initialize(http_client)
+      @http_client = http_client
+    end
+
+    def resource_name
+      Dry::Inflector.new.pluralize(self.class.to_s.split("::").last.downcase.gsub("_", "-"))
+    end
+
+    def self.resource_name
+      Dry::Inflector.new.pluralize(self.to_s.split("::").last.downcase.gsub("_", "-"))
+    end
+
+    def all
+      module_name = Kongfigure::Resources.const_get(self.class.to_s.split("::").last)
+      @http_client.get("#{resource_name}")["data"].map do |hash_resource|
+        case resource_name
+        when "consumers"
+          hash_resource["acls"]      = @http_client.get("#{resource_name}/#{hash_resource['id']}/acls")["data"]
+          hash_resource["key_auths"] = @http_client.get("#{resource_name}/#{hash_resource['id']}/key-auth")["data"]
+          hash_resource["plugins"]   = @http_client.get("#{resource_name}/#{hash_resource['id']}/plugins")["data"]
+        when "upstreams"
+          hash_resource["targets"]   = @http_client.get("#{resource_name}/#{hash_resource['id']}/targets")["data"]
+        when "services"
+          hash_resource["plugins"]   = @http_client.get("#{resource_name}/#{hash_resource['id']}/plugins")["data"]
+          hash_resource["routes"]    = @http_client.get("#{resource_name}/#{hash_resource['id']}/routes")["data"]
+        end
+        module_name.build(hash_resource)
+      end
+    end
+
+    def create_or_update(http_client, resource, remote_resources)
+      handle_api_errors do
+        related_resource = find_related_resource(resource, remote_resources)
+        if related_resource && need_update?(resource, related_resource)
+          puts "-> Update #{resource.class.name} (#{resource.identifier}).".colorize(:light_blue)
+          update(http_client, resource, related_resource)
+        elsif related_resource && need_update_dependencies?(resource, related_resource)
+          puts "-> Update dependencies #{resource.class.name} (#{resource.identifier}).".colorize(:light_blue)
+          update_dependencies(http_client, resource, related_resource)
+        elsif related_resource
+          #noop
+        else
+          puts "-> Create #{resource.class.name} (#{resource.identifier}).".colorize(:green)
+          create(http_client, resource, related_resource)
+        end
+      end
+    end
+
+    def create(http_client, resource, related_resource)
+      module_name = Kongfigure::Resources.const_get(self.class.to_s.split("::").last)
+      data        = http_client.post("#{resource_name}", resource.api_attributes.to_json)
+      create_dependencies(http_client, resource, module_name.build(data))
+    end
+
+    def update(http_client, resource, related_resource)
+      http_client.put("#{resource_name}/#{related_resource.id}", resource.api_attributes.to_json) if need_update?(resource, related_resource)
+      update_dependencies(http_client, resource, related_resource)
+    end
+
+    def cleanup(http_client, resource, related_resource)
+      puts "-> Cleanup #{related_resource.class.name} (#{related_resource.identifier}).".colorize(:magenta)
+      http_client.delete("#{resource_name}/#{related_resource.id}")
+    end
+
+    def cleanup_useless_resources(http_client, local_resources, remote_resources)
+      useless_remote_resources = remote_resources.each do |remote_resource|
+        related_local_resource = find_related_resource(remote_resource, local_resources)
+        handle_api_errors do
+          if need_cleanup_dependencies?(related_local_resource, remote_resource)
+
+            cleanup_dependencies(http_client, related_local_resource, remote_resource)
+          end
+          unless related_local_resource
+            cleanup(http_client, related_local_resource, remote_resource)
+          end
+        end
+      end
+    end
+
+    def find_related_resource(target_resource, resources)
+      resources.find do|resource|
+        case target_resource.class
+        when Kongfigure::Resources::Plugin
+          resource.name     == target_resource.name &&
+          resource.service  == target_resource.service &&
+          resource.consumer == target_resource.consumer &&
+          resource.route    == target_resource.route
+        else
+          resource.identifier == target_resource.identifier
+        end
+      end
+    end
+
+    def need_update?(resource, related_resource)
+      resource != related_resource
+    end
+
+    def need_update_dependencies?(resource, related_resource)
+      need_update_plugins?(resource, related_resource)
+    end
+
+    def need_cleanup_dependencies?(resource, related_resource)
+      resource.nil? || need_cleanup_plugins?(resource, related_resource)
+    end
+
+    def has_plugins?(resource)
+      resource.plugins && resource.plugins.size > 0
+    end
+
+    def update_dependencies(http_client, local_resource, remote_resource)
+      create_plugins(http_client, local_resource, remote_resource)
+    end
+
+    def create_dependencies(http_client, local_resource, remote_resource)
+      create_plugins(http_client, local_resource, remote_resource)
+    end
+
+    def cleanup_dependencies(http_client, local_resource, remote_resource)
+      puts "-> Cleanup dependencies #{remote_resource.class.name} (#{remote_resource.identifier}).".colorize(:magenta)
+      cleanup_plugins(http_client, local_resource, remote_resource)
+    end
+
+    def handle_api_errors(&block)
+      begin
+        yield
+      rescue Kongfigure::Errors::BadRequest => e
+        puts "<- Bad request: #{e.message}".colorize(:red)
+      end
+    end
+
+    def need_update_plugins?(resource, related_resource)
+      resource.plugins.reject do |plugin|
+        find_related_resource(plugin, related_resource.plugins)
+      end.size != 0
+    end
+
+    def need_cleanup_plugins?(resource, related_resource)
+      resource.plugins.reject do |plugin|
+        find_related_resource(plugin, related_resource.plugins)
+      end.size == 0 && resource.plugins.size < related_resource.plugins.size
+    end
+
+    def create_plugins(http_client, local_resource, remote_resource)
+      local_resource.plugins.each do |plugin|
+        unless find_related_resource(plugin, remote_resource.plugins)
+          http_client.post("#{resource_name}/#{local_resource.identifier}/plugins", plugin.api_attributes.to_json)
+        end
+      end
+    end
+
+    def cleanup_plugins(http_client, local_resource, remote_resource)
+      remote_resource.plugins.each do |plugin|
+        unless find_related_resource(plugin, local_resource.plugins)
+          http_client.delete("#{resource_name}/#{remote_resource.identifier}/plugins/#{plugin.id}")
+        end
+      end
+    end
+  end
+end

data/lib/kongfigure/services/consumer.rb

@@ -0,0 +1,60 @@
+module Kongfigure::Services
+  class Consumer < Base
+    def create_dependencies(http_client, resource, related_resource)
+      super(http_client, resource, related_resource)
+      create_key_auths(http_client, resource, related_resource)
+      create_acls(http_client, resource, related_resource)
+    end
+
+    def update_dependencies(http_client, resource, related_resource)
+      super(http_client, resource, related_resource)
+      create_key_auths(http_client, resource, related_resource)
+      create_acls(http_client, resource, related_resource)
+    end
+
+    def cleanup_dependencies(http_client, resource, related_resource)
+      super(http_client, resource, related_resource)
+      cleanup_key_auths(http_client, resource, related_resource)
+      cleanup_acls(http_client, resource, related_resource)
+    end
+
+    def need_update_dependencies?(resource, related_resource)
+      super(resource, related_resource) ||
+        (resource && (resource.acls != related_resource.acls || resource.key_auths != related_resource.key_auths))
+    end
+
+    private
+
+    def create_acls(http_client, resource, related_resource)
+      resource.acls.each do |acl|
+        unless related_resource.has_acl?(acl)
+          http_client.post("#{resource_name}/#{related_resource.identifier}/acls", acl.api_attributes.to_json)
+        end
+      end
+    end
+
+    def create_key_auths(http_client, resource, related_resource)
+      resource.key_auths.each do |key_auth|
+        unless related_resource.has_key_auth?(key_auth)
+          http_client.post("#{resource_name}/#{related_resource.identifier}/key-auth", key_auth.api_attributes.to_json)
+        end
+      end
+    end
+
+    def cleanup_key_auths(http_client, local_resource, remote_resource)
+      remote_resource.key_auths.each do |remote_resource_key_auth|
+        unless local_resource.has_key_auth?(remote_resource_key_auth)
+          http_client.delete("#{resource_name}/#{remote_resource.identifier}/key-auth/#{remote_resource_key_auth.id}")
+        end
+      end
+    end
+
+    def cleanup_acls(http_client, local_resource, remote_resource)
+      remote_resource.acls.each do |remote_resource_acl|
+        unless local_resource.has_acl?(remote_resource_acl)
+          http_client.delete("#{resource_name}/#{remote_resource.identifier}/acls/#{remote_resource_acl.id}")
+        end
+      end
+    end
+  end
+end

data/lib/kongfigure/services/plugin.rb

@@ -0,0 +1,18 @@
+module Kongfigure::Services
+  class Plugin < Base
+
+    def need_update_dependencies?(resource, related_resource)
+      false
+    end
+
+    def need_cleanup_dependencies?(resource, related_resource)
+      false
+    end
+
+    def cleanup(http_client, resource, related_resource)
+      return unless related_resource.is_global?
+      puts "-> Cleanup #{remote_resource.class.name} (#{remote_resource.identifier}).".colorize(:magenta)
+      http_client.delete("#{resource_name}/#{related_resource.id}")
+    end
+  end
+end

data/lib/kongfigure/services/route.rb

@@ -0,0 +1,4 @@
+module Kongfigure::Services
+  class Route < Base
+  end
+end

data/lib/kongfigure/services/service.rb

@@ -0,0 +1,53 @@
+module Kongfigure::Services
+  class Service < Base
+    def create_dependencies(http_client, resource, related_resource)
+      super(http_client, resource, related_resource)
+      create_routes(http_client, resource, related_resource)
+    end
+
+    def update_dependencies(http_client, resource, related_resource)
+      super(http_client, resource, related_resource)
+      create_routes(http_client, resource, related_resource)
+    end
+
+    def cleanup_dependencies(http_client, resource, related_resource)
+      super(http_client, resource, related_resource)
+      cleanup_routes(http_client, resource, related_resource)
+    end
+
+    def need_cleanup_dependencies?(resource, related_resource)
+      super(resource, related_resource) || resource.nil? || resource.routes != related_resource.routes
+    end
+
+    def need_update_dependencies?(resource, related_resource)
+      super(resource, related_resource) || (resource && (resource.routes != related_resource.routes))
+    end
+
+    private
+
+    def create_routes(http_client, resource, related_resource)
+      resource.routes.each do |route|
+        unless related_resource.has_route?(route)
+          http_client.post("#{resource_name}/#{related_resource.identifier}/routes", route.api_attributes.to_json)
+        end
+      end
+    end
+
+    def cleanup_routes(http_client, local_resource, remote_resource)
+      # cleanup duplicated routes
+      duplicated_routes = remote_resource.routes.select do |route|
+        remote_resource.routes.count(route) > 1
+      end.uniq
+      duplicated_routes.each do |duplicated_route|
+        http_client.delete("routes/#{duplicated_route.id}")
+        remote_resource.routes.delete(duplicated_route)
+      end
+      # cleanup useless routes
+      remote_resource.routes.each do |remote_resource_route|
+        unless local_resource.has_route?(remote_resource_route)
+          http_client.delete("routes/#{remote_resource_route.id}")
+        end
+      end
+    end
+  end
+end

data/lib/kongfigure/services/upstream.rb

@@ -0,0 +1,41 @@
+module Kongfigure::Services
+  class Upstream < Base
+    def create_dependencies(http_client, resource, related_resource)
+      super(http_client, resource, related_resource)
+      create_targets(http_client, resource, related_resource)
+    end
+
+    def update_dependencies(http_client, resource, related_resource)
+      super(http_client, resource, related_resource)
+      create_targets(http_client, resource, related_resource)
+    end
+
+    def cleanup_dependencies(http_client, resource, related_resource)
+      super(http_client, resource, related_resource)
+      cleanup_targets(http_client, resource, related_resource)
+    end
+
+    def need_update_dependencies?(resource, related_resource)
+      super(resource, related_resource) &&
+        resource && (resource.targets != related_resource.targets)
+    end
+
+    private
+
+    def create_targets(http_client, resource, related_resource)
+      resource.targets.each do |target|
+        unless related_resource.has_target?(target)
+          http_client.post("#{resource_name}/#{related_resource.identifier}/targets", target.api_attributes.to_json)
+        end
+      end
+    end
+
+    def cleanup_targets(http_client, local_resource, remote_resource)
+      remote_resource.targets.each do |remote_resource_target|
+        if (local_resource.nil? || !local_resource.has_target?(remote_resource_target)) && remote_resource_target.weight > 0
+          http_client.delete("#{resource_name}/#{remote_resource.identifier}/targets/#{remote_resource_target.id}")
+        end
+      end
+    end
+  end
+end

data/lib/kongfigure/version.rb

@@ -0,0 +1,3 @@
+module Kongfigure
+  VERSION = "0.0.2"
+end

data/lib/kongfigure.rb

@@ -0,0 +1,46 @@
+require_relative "kongfigure/version.rb"
+require_relative "kongfigure/cli.rb"
+require_relative "kongfigure/resources/base.rb"
+require_relative "kongfigure/resources/consumers/acl.rb"
+require_relative "kongfigure/resources/consumers/key_auth.rb"
+require_relative "kongfigure/resources/consumer.rb"
+require_relative "kongfigure/resources/plugin.rb"
+require_relative "kongfigure/resources/route.rb"
+require_relative "kongfigure/resources/service.rb"
+require_relative "kongfigure/resources/target.rb"
+require_relative "kongfigure/resources/upstream.rb"
+require_relative "kongfigure/services/base.rb"
+require_relative "kongfigure/services/consumer.rb"
+require_relative "kongfigure/services/plugin.rb"
+require_relative "kongfigure/services/route.rb"
+require_relative "kongfigure/services/service.rb"
+require_relative "kongfigure/services/upstream.rb"
+require_relative "kongfigure/configuration.rb"
+require_relative "kongfigure/parser.rb"
+require_relative "kongfigure/http_client.rb"
+require_relative "kongfigure/kong.rb"
+require_relative "kongfigure/errors/resource_not_found.rb"
+require_relative "kongfigure/errors/resource_conflict.rb"
+require_relative "kongfigure/errors/bad_request.rb"
+require_relative "kongfigure/errors/internal_server_error.rb"
+require_relative "kongfigure/errors/invalid_configuration.rb"
+
+require "rest-client"
+require "logger"
+
+module Kongfigure
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  def self.start(args)
+    # CLI
+    cli           = Kongfigure::CLI.new
+    options       = cli.parse!(args)
+    # Parser
+    parser        = Kongfigure::Parser.new(options[:file])
+    http_client   = Kongfigure::HTTPClient.new
+    kong          = Kongfigure::Kong.new(parser, http_client)
+    kong.apply!
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: kongfigure
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Ibanity
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: dry-inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: A tool to manage Kong resources with a declarative configuration.
+email:
+- it@ibanity.com
+executables:
+- kongfigure
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- exe/kongfigure
+- exe/kongfigure_local
+- kongfigure.gemspec
+- lib/kongfigure.rb
+- lib/kongfigure/cli.rb
+- lib/kongfigure/configuration.rb
+- lib/kongfigure/errors/bad_request.rb
+- lib/kongfigure/errors/internal_server_error.rb
+- lib/kongfigure/errors/invalid_configuration.rb
+- lib/kongfigure/errors/resource_conflict.rb
+- lib/kongfigure/errors/resource_not_found.rb
+- lib/kongfigure/http_client.rb
+- lib/kongfigure/kong.rb
+- lib/kongfigure/parser.rb
+- lib/kongfigure/resources/base.rb
+- lib/kongfigure/resources/consumer.rb
+- lib/kongfigure/resources/consumers/acl.rb
+- lib/kongfigure/resources/consumers/key_auth.rb
+- lib/kongfigure/resources/plugin.rb
+- lib/kongfigure/resources/route.rb
+- lib/kongfigure/resources/service.rb
+- lib/kongfigure/resources/target.rb
+- lib/kongfigure/resources/upstream.rb
+- lib/kongfigure/services/base.rb
+- lib/kongfigure/services/consumer.rb
+- lib/kongfigure/services/plugin.rb
+- lib/kongfigure/services/route.rb
+- lib/kongfigure/services/service.rb
+- lib/kongfigure/services/upstream.rb
+- lib/kongfigure/version.rb
+homepage: https://github.com/ibanity/kongfigure
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Kongfigure.
+test_files: []