kongfigure 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf57cebf09bbe6f5d2a0be2ef0b963d26b8482fdf3be87d38308db576593effe
-  data.tar.gz: f072f428db96554d2fd79b1121af4fe414cf8a61153d71ff853d3720f71b59fc
+  metadata.gz: ebd0fda03353da5cf51cc19302e048edcce67f2fc49284d7567151c340178575
+  data.tar.gz: eba528613e4170c540396f4e506ae256349a2b1ca8cb7737fb5e5b2ce318d8a3
 SHA512:
-  metadata.gz: 90325a8f142dbf70982d3d3d5e05d8f1d7eb9c85d5283c202334cc32c9fb97b500768a24b81b909e27522b4b0e94f8c09c0ed54b89a441f6c17b0545b2f726a4
-  data.tar.gz: 114692c7a0dae4e049cfd0b5441d2817ceeb7bf126fb8a922ff0c82aa7811846b1efe1cd962400927b421bb5aa8488ee0f9f838547069c021118b77b6c324ebe
+  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"
@@ -27,6 +29,13 @@ require_relative "kongfigure/errors/invalid_configuration.rb"
 
 require "rest-client"
 require "logger"
+require "yaml"
+require "erb"
+require "optparse"
+require "pp"
+require "awesome_print"
+require "digest"
+require "dry/inflector"
 
 module Kongfigure
   def self.logger
@@ -38,7 +47,7 @@ module Kongfigure
     cli           = Kongfigure::CLI.new
     options       = cli.parse!(args)
     # Parser
-    parser        = Kongfigure::Parser.new(options[:file])
+    parser        = Kongfigure::Parser.new(options[:file], options[:debug])
     http_client   = Kongfigure::HTTPClient.new(parser, options[:url])
     kong          = Kongfigure::Kong.new(parser, http_client)
     kong.apply!

data/lib/kongfigure/cli.rb

@@ -5,7 +5,9 @@ module Kongfigure
     attr_accessor :options
 
     def initialize
-      @options       = {}
+      @options       = {
+        debug: false
+      }
       @option_parser = OptionParser.new do |parser|
         parser.on("-f", "--file FILE", "Path to the Kongfigure configuration file.") do |file|
           @options[:file] = file
@@ -13,6 +15,9 @@ module Kongfigure
         parser.on("-u", "--url URL", "Url to the kong admin API.") do |url|
           @options[:url] = url
         end
+        parser.on("-d", "--debug", "Debug mode.") do
+          @options[:debug] = true
+        end
       end
     end
 

data/lib/kongfigure/configuration.rb

@@ -1,7 +1,3 @@
-require "optparse"
-require "pp"
-require "awesome_print"
-
 module Kongfigure
   class Configuration
 
@@ -47,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,29 +19,30 @@ 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
 
     def execute(options)
-      RestClient::Request.execute(options) do |response, _request, _result|
+      RestClient::Request.execute(options) do |response, request, _result|
         handle_response(response)
       end
     end
@@ -53,11 +54,16 @@ module Kongfigure
      }
     end
 
-    def request_options(method, path, payload = nil)
-      opts = {
+    def request_options(method, path, size, payload = nil)
+      uri       = URI.join(@configuration[:url], path)
+      query     = [uri.query]
+      query     = query + ["size=#{size}"] if size
+      query     = query.compact
+      uri.query = query.join("&") if query.size > 0
+      opts      = {
         method: method,
-        url: "#{@configuration[:url]}/#{path}",
-        headers: HTTP_HEADERS,
+        url: uri.to_s,
+        headers: HTTP_HEADERS
       }
 
       opts.merge!(ssl_options) if @configuration[:url].include?("https://")

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

@@ -1,20 +1,23 @@
-require "yaml"
-
 module Kongfigure
   class Parser
 
-    def initialize(file)
-      @yaml_configuration = File.read(file)
+    def initialize(file, debug=false)
+      @yaml_erb_configuration = File.read(file)
+      @debug                  = debug
     end
 
     def parse!
       return @configuration unless @configuration.nil?
       @configuration = Kongfigure::Configuration.new
       puts "Parsing YAML configuration...".colorize(:color => :white, :background => :red)
-      YAML.load(@yaml_configuration).each do |key, value|
+      parsed_configuration = YAML.load(ERB.new(@yaml_erb_configuration).result)
+      ap parsed_configuration if @debug
+      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"
@@ -29,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,12 +26,24 @@ module Kongfigure::Resources
       service
     end
 
+    def api_name
+      "services"
+    end
+
     def identifier
       name
     end
 
-    def has_route?(route)
-      routes && routes.include?(route)
+    def has_route?(other_route)
+      routes && routes.find do |route|
+        other_route == route
+      end
+    end
+
+    def has_routes?(other_routes)
+      other_routes.reject do |other_route|
+        has_route?(other_route)
+      end.size == 0
     end
 
     def api_attributes

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.4"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kongfigure
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Ibanity
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-02-12 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
@@ -148,8 +150,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: Kongfigure.
 test_files: []

data/lib/kongfigure/services/base.rb

@@ -1,164 +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_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

@@ -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.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

@@ -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_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

@@ -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