kongfigure 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ceeaed03095ba7f32fa8239ce1f184f20c871384643279724bbab85b81707f45
-  data.tar.gz: f0ce60043dff56cd391c6d5800725bd267e8f752f9d1a77968ea1d246821a1df
+  metadata.gz: ebd0fda03353da5cf51cc19302e048edcce67f2fc49284d7567151c340178575
+  data.tar.gz: eba528613e4170c540396f4e506ae256349a2b1ca8cb7737fb5e5b2ce318d8a3
 SHA512:
-  metadata.gz: a6c0f2f1b00cb18a0f7cbf362dc75a189824de4fe89ca90e6b0ae439889b908670968d835507faee2697ff2d06679dc8994744edebd3cee096bb5ded4aab2f08
-  data.tar.gz: 83ce0094643344c188c7a3fbbc215160e4b0ce4e6fd5e5af0292cfd38f2287c426b74a92dd6bf14ece5aee6e98bcf9d7b354da71ce386769b6f70d984a51aa76
+  metadata.gz: c53ebed51301866e1461261964151d532479f33d7b3e510a8b908e1d997254042746156b9b5cf4e74e7180a096f6f6e8b13e1abcf54b28e007ca9cf8bbb4e8ea
+  data.tar.gz: 7b31b90435a1ca0dc5d2a4c7882048972ce24b1d8f14ac40c83945c321e7ffe319297530c9e32ec39a906795a25dbfefde19a04ff500e41c3ff1d3ec720968f6

data/.gitignore

@@ -52,3 +52,5 @@ build-iPhoneSimulator/
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
+test.yml
+test_backup.yml

data/README.md

@@ -1,3 +1,39 @@
 # Kongfigure
 
+## Test
+```
+docker run -d --name kong-database \
+                -p 5432:5432 \
+                -e "POSTGRES_USER=kong" \
+                -e "POSTGRES_DB=kong" \
+                -e "POSTGRES_PASSWORD=kong" \
+                postgres:9.6
+docker run --rm \
+    --link kong-database:kong-database \
+    -e "KONG_DATABASE=postgres" \
+    -e "KONG_PG_HOST=kong-database" \
+    -e "KONG_CASSANDRA_CONTACT_POINTS=kong-database" \
+    -e "KONG_PG_PASSWORD"=kong \
+    registry.ibanity.net/docker-images/kong:latest kong migrations bootstrap
+
+docker run -ti --name kong \
+    --link kong-database:kong-database \
+    -e "KONG_DATABASE=postgres" \
+    -e "KONG_PG_HOST=kong-database" \
+    -e "KONG_CASSANDRA_CONTACT_POINTS=kong-database" \
+    -e "KONG_PROXY_ACCESS_LOG=/dev/stdout" \
+    -e "KONG_ADMIN_ACCESS_LOG=/dev/stdout" \
+    -e "KONG_PROXY_ERROR_LOG=/dev/stderr" \
+    -e "KONG_ADMIN_ERROR_LOG=/dev/stderr" \
+    -e "KONG_ADMIN_LISTEN=0.0.0.0:8001, 0.0.0.0:8444 ssl" \
+    -e "KONG_PG_PASSWORD"=kong \
+    -p 8000:8000 \
+    -p 8443:8443 \
+    -p 8001:8001 \
+    -p 8444:8444 \
+    registry.ibanity.net/docker-images/kong:latest
+```
+```
+./exe/kongfigure_local -f test.yml
+```
 ## WIP :)

data/lib/kongfigure.rb

@@ -9,12 +9,14 @@ 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/synchronizers/base.rb"
+require_relative "kongfigure/synchronizers/consumer.rb"
+require_relative "kongfigure/synchronizers/plugin.rb"
+require_relative "kongfigure/synchronizers/route.rb"
+require_relative "kongfigure/synchronizers/service.rb"
+require_relative "kongfigure/synchronizers/upstream.rb"
+require_relative "kongfigure/synchronizers/consumers/key_auth.rb"
+require_relative "kongfigure/synchronizers/consumers/acl.rb"
 require_relative "kongfigure/configuration.rb"
 require_relative "kongfigure/parser.rb"
 require_relative "kongfigure/http_client.rb"
@@ -32,6 +34,8 @@ require "erb"
 require "optparse"
 require "pp"
 require "awesome_print"
+require "digest"
+require "dry/inflector"
 
 module Kongfigure
   def self.logger

data/lib/kongfigure/configuration.rb

@@ -43,5 +43,14 @@ module Kongfigure
         upstreams: @upstreams.map do |upstream| upstream.to_s end
       }.ai
     end
+
+    def to_yaml
+      {
+        services:  @services.map  do |service| service.to_yaml end,
+        consumers: @consumers.map do |consumer| consumer.to_yaml end,
+        plugins:   @plugins.map   do |plugin| plugin.to_yaml end,
+        upstreams: @upstreams.map do |upstream| upstream.to_yaml end
+      }
+    end
   end
 end

data/lib/kongfigure/http_client.rb

@@ -19,23 +19,24 @@ module Kongfigure
     end
 
     def post(path, payload)
-      execute(request_options(:post, path, payload))
+      execute(request_options(:post, path, nil, payload))
     end
 
     def put(path, payload)
-      execute(request_options(:put, path, payload))
+      execute(request_options(:put, path, nil, payload))
     end
 
     def patch(path, payload)
-      execute(request_options(:patch, path, payload))
+      execute(request_options(:patch, path, nil, payload))
     end
 
-    def get(path)
-      execute(request_options(:get, path))
+    def get(path, size=nil)
+      size = size = 1000
+      execute(request_options(:get, path, size))
     end
 
     def delete(path)
-      execute(request_options(:delete, path))
+      execute(request_options(:delete, path, nil))
    end
 
     private
@@ -53,10 +54,13 @@ module Kongfigure
      }
     end
 
-    def request_options(method, path, payload = nil)
+    def request_options(method, path, size, payload = nil)
       uri       = URI.join(@configuration[:url], path)
-      uri.query = [uri.query, "size=1000"].compact.join("&")
-      opts = {
+      query     = [uri.query]
+      query     = query + ["size=#{size}"] if size
+      query     = query.compact
+      uri.query = query.join("&") if query.size > 0
+      opts      = {
         method: method,
         url: uri.to_s,
         headers: HTTP_HEADERS
@@ -83,7 +87,7 @@ module Kongfigure
       elsif response.code == 404
         raise Kongfigure::Errors::ResourceNotFound
       elsif response.code == 409
-        #raise Kongfigure::Errors::ResourceConflict
+        raise Kongfigure::Errors::ResourceConflict
       elsif response.code == 500
         raise Kongfigure::Errors::InternalServerError
       end

data/lib/kongfigure/kong.rb

@@ -1,32 +1,37 @@
 module Kongfigure
   class Kong
 
+    SYNCHRONIZER_MODULES = [
+      Kongfigure::Synchronizers::Upstream,
+      Kongfigure::Synchronizers::Service,
+      Kongfigure::Synchronizers::Consumer,
+      Kongfigure::Synchronizers::Plugin
+    ]
+
     def initialize(parser, http_client)
-      @parser      = parser
-      @http_client = http_client
+      @parser        = parser
+      @http_client   = http_client
+      @synchronizers = {}
+      @configuration = @parser.parse!
+      load_synchronizers
       display_information
     end
 
     def apply!
-      @configuration = @parser.parse!
       puts @configuration.to_s
+      puts "Fetching actual configuration..."
+      puts "Do you want to apply this configuration to '#{@configuration.url}' (yes/no)".colorize(:color => :white, :background => :red)
+      exit 1 unless gets.strip.downcase == "yes"
       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)
+      SYNCHRONIZER_MODULES.each do |synchronizer_module|
+        apply_all(@synchronizers[synchronizer_module])
+      end
       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)
+    def apply_all(synchronizer)
+      puts "<- Applying #{synchronizer.resource_api_name}..."
+      synchronizer.synchronize_all
     end
 
     def display_information
@@ -36,5 +41,22 @@ module Kongfigure
       puts "* version: \t#{data['hostname']}"
       puts "* lua_version: \t#{data['lua_version']}"
     end
+
+    private
+    def load_synchronizers
+      SYNCHRONIZER_MODULES.each do |synchronizer_module|
+        resources = case synchronizer_module.to_s
+        when Kongfigure::Synchronizers::Upstream.to_s
+          @configuration.upstreams
+        when Kongfigure::Synchronizers::Service.to_s
+          @configuration.services
+        when Kongfigure::Synchronizers::Consumer.to_s
+          @configuration.consumers
+        when Kongfigure::Synchronizers::Plugin.to_s
+          @configuration.plugins
+        end
+        @synchronizers[synchronizer_module] = synchronizer_module.new(@http_client, resources || [])
+      end
+    end
   end
 end

data/lib/kongfigure/parser.rb

@@ -15,7 +15,9 @@ module Kongfigure
       parsed_configuration.each do |key, value|
         case key
         when "url"
-          @configuration.url = value
+          @configuration.url = parse_url(value)
+        when "urls"
+          @configuration.url = parse_url(value)
         when "services"
           @configuration.add_services(value || [])
         when "consumers"
@@ -30,5 +32,24 @@ module Kongfigure
       end
       @configuration
     end
+
+    private
+    def parse_url(urls)
+      if urls.instance_of?(String)
+        urls
+      elsif urls.instance_of?(Hash)
+        puts "Available URLs: "
+        urls.keys.each_with_index do | key, index |
+          puts "#{index}: #{key} -> #{urls[key]}"
+        end
+        puts "Enter the URL index:"
+        index = STDIN.gets.chomp
+        url   = urls[urls.keys[index.to_i]]
+        raise "Wrong URL index: #{index}" if url.nil?
+        url
+      else
+        raise "Can't parse URL: #{urls}."
+      end
+    end
   end
 end

data/lib/kongfigure/resources/base.rb

@@ -1,14 +1,21 @@
-require "dry/inflector"
-
 module Kongfigure::Resources
   class Base
 
-    attr_accessor :id, :kongfigure_ignore_fields, :plugins
+    attr_accessor :id, :kongfigure_ignore_fields, :plugins, :updated, :unchanged
 
     def initialize(id, kongfigure_ignore_fields = nil)
       @id                       = id
       @kongfigure_ignore_fields = (kongfigure_ignore_fields || []).map { |field| field.split(".") }
+      if self.class != Kongfigure::Resources::Plugin && self.class != Kongfigure::Resources::Route
+        @kongfigure_ignore_fields.push("id")
+      end
       @plugins                  = []
+      @updated                  = false
+      @unchanged                = false
+    end
+
+    def plugin_allowed?
+      true
     end
 
     def self.build_all(resources_hash)
@@ -18,10 +25,35 @@ module Kongfigure::Resources
     end
 
     def ==(other_object)
-      differences = deep_diff(other_object.api_attributes, api_attributes, kongfigure_ignore_fields)
-      differences.flatten.size == 0
+      differences       = deep_diff(other_object.api_attributes, api_attributes, kongfigure_ignore_fields)
+      differences_count = differences.flatten.size
+      if differences_count > 0
+        ap api_attributes
+        ap other_object.api_attributes
+        ap differences
+      end
+      differences_count == 0
+    end
+
+    def display_name
+      identifier
     end
 
+    def mark_as_updated
+      @updated = true
+    end
+
+    def mark_as_unchanged
+      @unchanged = true
+    end
+
+    def has_to_be_deleted?
+      @updated == false && @unchanged == false
+    end
+
+    def api_name
+      raise NotImplementedError
+    end
     private
 
     def deep_diff(a, b, ignore_nested_keys=[], level=0)

data/lib/kongfigure/resources/consumer.rb

@@ -18,6 +18,10 @@ module Kongfigure::Resources
       username
     end
 
+    def api_name
+      "consumers"
+    end
+
     def api_attributes
       {
         "username"  =>  username,

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

@@ -9,6 +9,18 @@ module Kongfigure::Resources::Consumers
       acl
     end
 
+    def plugin_allowed?
+      false
+    end
+
+    def identifier
+      group
+    end
+
+    def api_name
+      "acls"
+    end
+
     def api_attributes
       {
         "group" => group

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

@@ -9,6 +9,18 @@ module Kongfigure::Resources::Consumers
       key_auth
     end
 
+    def plugin_allowed?
+      false
+    end
+
+    def identifier
+      key
+    end
+
+    def api_name
+      "key-auth"
+    end
+
     def api_attributes
       {
         "key" => key

data/lib/kongfigure/resources/plugin.rb

@@ -1,9 +1,11 @@
 module Kongfigure::Resources
   class Plugin < Base
-    attr_accessor :name, :config, :enabled, :route, :service, :consumer, :run_on
+    attr_accessor :name, :config, :enabled, :route, :service, :consumer, :run_on, :id
 
     def self.build(hash)
+      raise "Plugin ID is missing for #{hash.inspect}" if hash["id"].nil?
       plugin          = new(hash["id"], hash["kongfigure_ignore_fields"])
+      plugin.id       = hash["id"]
       plugin.config   = hash["config"]
       plugin.name     = hash["name"]
       plugin.enabled  = hash["enabled"]
@@ -14,19 +16,24 @@ module Kongfigure::Resources
       plugin
     end
 
+    def plugin_allowed?
+      false
+    end
+
     def identifier
-      name
+      id
     end
 
     def api_attributes
       {
-        "name"     =>     name,
-        "config"   =>   config,
-        "enabled"  =>  enabled,
-        "route"    =>    route,
-        "service"  =>  service,
+        "id"       => id,
+        "name"     => name,
+        "config"   => config || {},
+        "enabled"  => enabled,
+        "route"    => route,
+        "service"  => service,
         "consumer" => consumer,
-        "run_on"   =>   run_on
+        "run_on"   => run_on
       }.compact
     end
 
@@ -34,8 +41,16 @@ module Kongfigure::Resources
       service.nil? && route.nil? && consumer.nil?
     end
 
+    def display_name
+      name + " (id: #{identifier})"
+    end
+
+    def api_name
+      "plugins"
+    end
+
     def to_s
-      str = name
+      str = display_name
       if route
         str += " on route #{route}"
       elsif service

data/lib/kongfigure/resources/route.rb

@@ -4,6 +4,7 @@ module Kongfigure::Resources
                   :sources, :destinations, :service
 
     def self.build(hash)
+      raise "Route ID is missing for #{hash.inspect}" if hash["id"].nil?
       route                = new(hash["id"], hash["kongfigure_ignore_fields"])
       route.name           = hash["name"]
       route.protocols      = hash["protocols"]
@@ -20,11 +21,24 @@ module Kongfigure::Resources
     end
 
     def identifier
-      name
+      id
+    end
+
+    def api_name
+      "routes"
+    end
+
+    def display_name
+      if name.nil?
+        "default route"
+      else
+        "route (name: #{name})"
+      end
     end
 
     def api_attributes
       {
+        "id"             => id,
         "name"           => name,
         "protocols"      => protocols,
         "methods"        => methods,

data/lib/kongfigure/resources/service.rb

@@ -26,6 +26,10 @@ module Kongfigure::Resources
       service
     end
 
+    def api_name
+      "services"
+    end
+
     def identifier
       name
     end

data/lib/kongfigure/resources/target.rb

@@ -9,6 +9,10 @@ module Kongfigure::Resources
       target
     end
 
+    def api_name
+      "targets"
+    end
+
     def api_attributes
       {
         "target" => target,

data/lib/kongfigure/resources/upstream.rb

@@ -31,6 +31,10 @@ module Kongfigure::Resources
       end
     end
 
+    def api_name
+      "upstreams"
+    end
+
     def api_attributes
       {
         "name"                 => name,

data/lib/kongfigure/synchronizers/base.rb

@@ -0,0 +1,107 @@
+require "colorize"
+
+module Kongfigure::Synchronizers
+  class Base
+
+    attr_reader :remote_resources, :resources, :parent_resource
+
+    def initialize(http_client, resources, parent_resource=nil)
+      @http_client      = http_client
+      @parent_resource  = parent_resource
+      @resources        = resources
+      @remote_resources = load_all_remote_resources
+    end
+
+    def find(identifier)
+      module_name = Kongfigure::Resources.const_get(self.class.to_s.split("::").last)
+      module_name.build(@http_client.get("#{resource_api_name}/#{identifier}"))
+    rescue Kongfigure::Errors::ResourceNotFound
+      nil
+    end
+
+    def synchronize_resource(resource)
+      remote_resource = find_related_remote_resource(resource)
+      if remote_resource.nil?
+        create(resource)
+      elsif resource == remote_resource
+        unchanged(resource)
+        remote_resource.mark_as_unchanged
+      else
+        update(resource, remote_resource)
+        remote_resource.mark_as_updated
+      end
+    end
+
+    def synchronize_plugins(resource)
+      plugins_synchronizer = Kongfigure::Synchronizers::Plugin.new(@http_client, resource.plugins, resource)
+      plugins_synchronizer.synchronize_all
+    end
+
+    def synchronize(resource)
+      synchronize_resource(resource)
+      synchronize_plugins(resource)
+    end
+
+    def synchronize_all
+      @resources.each do |resource|
+        synchronize(resource)
+      end
+      @remote_resources.each do |remote_resource|
+        cleanup(remote_resource) if remote_resource.has_to_be_deleted?
+      end
+    end
+
+    def cleanup(remote_resource)
+      puts "#{parent_resource.nil? ? '' : '  *'}#{'---'.colorize(:red)} #{remote_resource.display_name}"
+      path = if parent_resource
+        "#{parent_resource.api_name}/#{parent_resource.identifier}/#{resource_api_name}/#{remote_resource.identifier}"
+      else
+        "#{resource_api_name}/#{remote_resource.identifier}"
+      end
+      @http_client.delete(path)
+    end
+
+    def create(resource)
+      puts "#{parent_resource.nil? ? '' : '  *'}#{'+++'.colorize(:green)} #{resource.display_name}"
+      path = if parent_resource
+        "#{parent_resource.api_name}/#{parent_resource.identifier}/#{resource_api_name}"
+      else
+        "#{resource_api_name}"
+      end
+      @http_client.post(path, resource.api_attributes.to_json)
+    end
+
+    def unchanged(resource)
+      puts "#{parent_resource.nil? ? '' : '  *'}#{'==='.colorize(:blue)} #{resource.display_name}"
+    end
+
+    def update(resource, remote_resource)
+      puts "#{'uuu'.colorize(:yellow)} #{resource.display_name}"
+      path = if parent_resource
+        "#{parent_resource.api_name}/#{parent_resource.identifier}/#{resource_api_name}/#{remote_resource.identifier}"
+      else
+        "#{resource_api_name}/#{remote_resource.identifier}"
+      end
+      @http_client.put(path, resource.api_attributes.to_json)
+    end
+
+    private
+    def load_all_remote_resources
+      if parent_resource.nil?
+        @http_client.get("#{resource_api_name}")["data"].map do |hash_resource|
+          resource_module.build(hash_resource)
+        end
+      else
+        @http_client.get("#{parent_resource.api_name}/#{parent_resource.identifier}/#{resource_api_name}")["data"].map do |hash_resource|
+          resource_module.build(hash_resource)
+        end
+      end
+    end
+
+    def find_related_remote_resource(resource)
+      remote_resources.find do|remote_resource|
+        resource.identifier == remote_resource.identifier
+      end
+    end
+  end
+end

data/lib/kongfigure/synchronizers/consumer.rb

@@ -0,0 +1,22 @@
+module Kongfigure::Synchronizers
+  class Consumer < Base
+
+    def synchronize(resource)
+      super(resource)
+      key_auths_synchronizer = Kongfigure::Synchronizers::Consumers::KeyAuth.new(@http_client, resource.key_auths, resource)
+      key_auths_synchronizer.synchronize_all
+
+      acls_synchronizer = Kongfigure::Synchronizers::Consumers::ACL.new(@http_client, resource.acls, resource)
+      acls_synchronizer.synchronize_all
+    end
+
+    def resource_module
+      Kongfigure::Resources::Consumer
+    end
+
+    def resource_api_name
+      "consumers"
+    end
+  end
+end
+

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

@@ -0,0 +1,16 @@
+module Kongfigure::Synchronizers::Consumers
+  class ACL < Kongfigure::Synchronizers::Base
+
+    def resource_module
+      Kongfigure::Resources::Consumers::ACL
+    end
+
+    def resource_api_name
+      "acls"
+    end
+
+    def synchronize(resource)
+      synchronize_resource(resource)
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Kongfigure::Synchronizers::Consumers
+  class KeyAuth < Kongfigure::Synchronizers::Base
+
+    def resource_module
+      Kongfigure::Resources::Consumers::KeyAuth
+    end
+
+    def resource_api_name
+      "key-auth"
+    end
+
+    def synchronize(resource)
+      synchronize_resource(resource)
+    end
+  end
+end

data/lib/kongfigure/synchronizers/plugin.rb

@@ -0,0 +1,26 @@
+module Kongfigure::Synchronizers
+  class Plugin < Base
+
+    def load_all_remote_resources
+      remote_resources = if parent_resource.nil?
+        super.filter do |resource|
+          resource.is_global?
+        end
+      else
+        super
+      end
+    end
+
+    def resource_module
+      Kongfigure::Resources::Plugin
+    end
+
+    def resource_api_name
+      "plugins"
+    end
+
+    def synchronize(resource)
+      synchronize_resource(resource)
+    end
+  end
+end

data/lib/kongfigure/synchronizers/route.rb

@@ -0,0 +1,16 @@
+module Kongfigure::Synchronizers
+  class Route < Base
+
+    def resource_module
+      Kongfigure::Resources::Route
+    end
+
+    def resource_api_name
+      "routes"
+    end
+
+    def synchronize(resource)
+      synchronize_resource(resource)
+    end
+  end
+end

data/lib/kongfigure/synchronizers/service.rb

@@ -0,0 +1,23 @@
+module Kongfigure::Synchronizers
+  class Service < Base
+
+    def resource_module
+      Kongfigure::Resources::Service
+    end
+
+    def resource_api_name
+      "services"
+    end
+
+    def synchronize_routes(resource)
+      routes_synchronizer = Kongfigure::Synchronizers::Route.new(@http_client, resource.routes, resource)
+      routes_synchronizer.synchronize_all
+    end
+
+    def synchronize(resource)
+      synchronize_resource(resource)
+      synchronize_routes(resource)
+      synchronize_plugins(resource)
+    end
+  end
+end

data/lib/kongfigure/synchronizers/upstream.rb

@@ -0,0 +1,16 @@
+module Kongfigure::Synchronizers
+  class Upstream < Base
+
+    def resource_module
+      Kongfigure::Resources::Upstream
+    end
+
+    def resource_api_name
+      "upstreams"
+    end
+
+    def synchronize(resource)
+      synchronize_resource(resource)
+    end
+  end
+end

data/lib/kongfigure/version.rb

@@ -1,3 +1,3 @@
 module Kongfigure
-  VERSION = "0.0.8"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kongfigure
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Ibanity
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2020-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,18 +122,20 @@ files:
 - 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/synchronizers/base.rb
+- lib/kongfigure/synchronizers/consumer.rb
+- lib/kongfigure/synchronizers/consumers/acl.rb
+- lib/kongfigure/synchronizers/consumers/key_auth.rb
+- lib/kongfigure/synchronizers/plugin.rb
+- lib/kongfigure/synchronizers/route.rb
+- lib/kongfigure/synchronizers/service.rb
+- lib/kongfigure/synchronizers/upstream.rb
 - lib/kongfigure/version.rb
 homepage: https://github.com/ibanity/kongfigure
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -149,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Kongfigure.
 test_files: []

data/lib/kongfigure/services/base.rb

@@ -1,168 +0,0 @@
-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_remote_resource = find_related_resource(resource, remote_resources)
-        if related_remote_resource && need_update?(resource, related_remote_resource)
-          puts "-> Update #{resource.class.name} (#{resource.identifier}).".colorize(:light_blue)
-          update(http_client, resource, related_remote_resource)
-        elsif related_remote_resource && need_update_dependencies?(resource, related_remote_resource)
-          puts "-> Update dependencies #{resource.class.name} (#{resource.identifier}).".colorize(:light_blue)
-          update_dependencies(http_client, resource, related_remote_resource)
-        elsif related_remote_resource
-          #noop
-        else
-          puts "-> Create #{resource.class.name} (#{resource.identifier}).".colorize(:green)
-          create(http_client, resource, related_remote_resource)
-        end
-      end
-    end
-
-    def create(http_client, resource, _related_remote_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_remote_resource)
-      http_client.put("#{resource_name}/#{related_remote_resource.id}", resource.api_attributes.to_json) if need_update?(resource, related_remote_resource)
-      update_dependencies(http_client, resource, related_remote_resource)
-    end
-
-    def cleanup(http_client, resource, related_remote_resource)
-      puts "-> Cleanup #{related_remote_resource.class.name} (#{related_remote_resource.identifier}).".colorize(:magenta)
-      http_client.delete("#{resource_name}/#{related_remote_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_remote_resource)
-      resource != related_remote_resource
-    end
-
-    def need_update_dependencies?(resource, related_remote_resource)
-      need_update_plugins?(resource, related_remote_resource)
-    end
-
-    def need_cleanup_dependencies?(resource, related_remote_resource)
-      resource.nil? || need_cleanup_plugins?(resource, related_remote_resource)
-    end
-
-    def has_plugins?(resource)
-      resource.plugins && resource.plugins.size > 0
-    end
-
-    def update_dependencies(http_client, local_resource, related_remote_resource)
-      create_or_update_plugins(http_client, local_resource, related_remote_resource)
-    end
-
-    def create_dependencies(http_client, local_resource, related_remote_resource)
-      create_or_update_plugins(http_client, local_resource, related_remote_resource)
-    end
-
-    def cleanup_dependencies(http_client, local_resource, related_remote_resource)
-      puts "-> Cleanup dependencies #{related_remote_resource.class.name} (#{related_remote_resource.identifier}).".colorize(:magenta)
-      cleanup_plugins(http_client, local_resource, related_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_remote_resource)
-      resource.plugins.reject do |plugin|
-        related_plugin = find_related_resource(plugin, related_remote_resource.plugins)
-        related_plugin && plugin == related_plugin
-      end.size != 0
-    end
-
-    def need_cleanup_plugins?(resource, related_remote_resource)
-      resource.plugins.reject do |plugin|
-        related_remote_plugin = find_related_resource(plugin, related_remote_resource.plugins)
-        related_remote_plugin && plugin == related_remote_plugin
-      end.size == 0 && resource.plugins.size < related_remote_resource.plugins.size
-    end
-
-    def create_or_update_plugins(http_client, local_resource, remote_resource)
-      local_resource.plugins.each do |plugin|
-        related_plugin = find_related_resource(plugin, remote_resource.plugins)
-        if related_plugin
-          http_client.patch("#{resource_name}/#{local_resource.identifier}/plugins/#{related_plugin.id}", plugin.api_attributes.to_json)
-        else
-          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|
-        if local_resource.nil? || find_related_resource(plugin, local_resource.plugins).nil?
-          http_client.delete("#{resource_name}/#{remote_resource.identifier}/plugins/#{plugin.id}")
-        end
-      end
-    end
-  end
-end

data/lib/kongfigure/services/consumer.rb

@@ -1,60 +0,0 @@
-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 && 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 && 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

@@ -1,18 +0,0 @@
-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 #{related_resource.class.name} (#{related_resource.identifier}).".colorize(:magenta)
-      http_client.delete("#{resource_name}/#{related_resource.id}")
-    end
-  end
-end

data/lib/kongfigure/services/route.rb

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

data/lib/kongfigure/services/service.rb

@@ -1,53 +0,0 @@
-module Kongfigure::Services
-  class Service < Base
-    def create_dependencies(http_client, resource, related_remote_resource)
-      create_routes(http_client, resource, related_remote_resource)
-      super(http_client, resource, related_remote_resource)
-    end
-
-    def update_dependencies(http_client, resource, related_remote_resource)
-      create_routes(http_client, resource, related_remote_resource)
-      super(http_client, resource, related_remote_resource)
-    end
-
-    def cleanup_dependencies(http_client, resource, related_remote_resource)
-      super(http_client, resource, related_remote_resource)
-      cleanup_routes(http_client, resource, related_remote_resource)
-    end
-
-    def need_cleanup_dependencies?(resource, related_remote_resource)
-      super(resource, related_remote_resource) || resource.nil? || resource.routes != related_remote_resource.routes
-    end
-
-    def need_update_dependencies?(resource, related_remote_resource)
-      super(resource, related_remote_resource) || (resource && !related_remote_resource.has_routes?(resource.routes))
-    end
-
-    private
-
-    def create_routes(http_client, resource, related_remote_resource)
-      resource.routes.each do |route|
-        unless related_remote_resource.has_route?(route)
-          http_client.post("#{resource_name}/#{related_remote_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|
-        if local_resource.nil? || !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

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