kongfigure 0.0.3 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 723613b6634757801133620d7297116b5a2b3c1fb5f6d4ac8bd6e86cc0e3abc3
-  data.tar.gz: 0706d49ad8363ef707df443ad230d3bb80c5f3d61c0d0772ca6a0adb82a4b84d
+  metadata.gz: ceeaed03095ba7f32fa8239ce1f184f20c871384643279724bbab85b81707f45
+  data.tar.gz: f0ce60043dff56cd391c6d5800725bd267e8f752f9d1a77968ea1d246821a1df
 SHA512:
-  metadata.gz: f9ba869ee4e68ea8659b2295989284d3811378e6cccd70369b54656a0e2b8d4cc90502437ec925b4af632d777035146ea678aef2ded4dc1dbe0378375b701648
-  data.tar.gz: b752a3e0ac7e89b3d4906b018045bca442cb658878f017ee5822e17cc1d8292d87733efb524e1dcc82232ebe0ab4b8d33021e9d07c1511443771327e43413de0
+  metadata.gz: a6c0f2f1b00cb18a0f7cbf362dc75a189824de4fe89ca90e6b0ae439889b908670968d835507faee2697ff2d06679dc8994744edebd3cee096bb5ded4aab2f08
+  data.tar.gz: 83ce0094643344c188c7a3fbbc215160e4b0ce4e6fd5e5af0292cfd38f2287c426b74a92dd6bf14ece5aee6e98bcf9d7b354da71ce386769b6f70d984a51aa76

data/lib/kongfigure.rb

@@ -27,6 +27,11 @@ require_relative "kongfigure/errors/invalid_configuration.rb"
 
 require "rest-client"
 require "logger"
+require "yaml"
+require "erb"
+require "optparse"
+require "pp"
+require "awesome_print"
 
 module Kongfigure
   def self.logger
@@ -38,8 +43,8 @@ module Kongfigure
     cli           = Kongfigure::CLI.new
     options       = cli.parse!(args)
     # Parser
-    parser        = Kongfigure::Parser.new(options[:file])
-    http_client   = Kongfigure::HTTPClient.new
+    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!
   end

data/lib/kongfigure/cli.rb

@@ -5,11 +5,19 @@ 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
         end
+        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,14 +1,10 @@
-require "optparse"
-require "pp"
-require "awesome_print"
-
 module Kongfigure
   class Configuration
 
-    attr_accessor :host, :services, :consumers, :plugins, :upstreams
+    attr_accessor :url, :services, :consumers, :plugins, :upstreams
 
     def initialize
-      @host      = nil
+      @url       = nil
       @services  = []
       @consumers = []
       @plugins   = []

data/lib/kongfigure/http_client.rb

@@ -9,11 +9,11 @@ module Kongfigure
       accept_encoding: "gzip"
     }
 
-    def initialize
+    def initialize(parser, url)
       @configuration = {
         ssl_ca_path: nil,
         verify_ssl:  OpenSSL::SSL::VERIFY_NONE,
-        url:         "https://localhost:8445"
+        url:         url || parser.parse!.url
       }
       @inflector = Dry::Inflector.new
     end
@@ -41,7 +41,7 @@ module Kongfigure
     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
@@ -54,10 +54,12 @@ module Kongfigure
     end
 
     def request_options(method, path, payload = nil)
+      uri       = URI.join(@configuration[:url], path)
+      uri.query = [uri.query, "size=1000"].compact.join("&")
       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://")
@@ -81,7 +83,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/parser.rb

@@ -1,19 +1,21 @@
-require "yaml"
-
 module Kongfigure
   class Parser
 
-    def initialize(file)
-      @yaml_configuration = File.read(file)
-      @configuration      = Kongfigure::Configuration.new
+    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 "host"
-          @configuration.host = value
+        when "url"
+          @configuration.url = value
         when "services"
           @configuration.add_services(value || [])
         when "consumers"

data/lib/kongfigure/resources/service.rb

@@ -30,8 +30,16 @@ module Kongfigure::Resources
       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/services/base.rb

@@ -35,36 +35,36 @@ module Kongfigure::Services
 
     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)
+        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_resource)
-        elsif related_resource && need_update_dependencies?(resource, related_resource)
+          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_resource)
-        elsif related_resource
+          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_resource)
+          create(http_client, resource, related_remote_resource)
         end
       end
     end
 
-    def create(http_client, resource, related_resource)
+    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_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)
+    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_resource)
-      puts "-> Cleanup #{related_resource.class.name} (#{related_resource.identifier}).".colorize(:magenta)
-      http_client.delete("#{resource_name}/#{related_resource.id}")
+    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)
@@ -72,7 +72,6 @@ module Kongfigure::Services
         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
@@ -96,33 +95,33 @@ module Kongfigure::Services
       end
     end
 
-    def need_update?(resource, related_resource)
-      resource != related_resource
+    def need_update?(resource, related_remote_resource)
+      resource != related_remote_resource
     end
 
-    def need_update_dependencies?(resource, related_resource)
-      need_update_plugins?(resource, related_resource)
+    def need_update_dependencies?(resource, related_remote_resource)
+      need_update_plugins?(resource, related_remote_resource)
     end
 
-    def need_cleanup_dependencies?(resource, related_resource)
-      resource.nil? || need_cleanup_plugins?(resource, related_resource)
+    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, remote_resource)
-      create_plugins(http_client, local_resource, remote_resource)
+    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, remote_resource)
-      create_plugins(http_client, local_resource, remote_resource)
+    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, remote_resource)
-      puts "-> Cleanup dependencies #{remote_resource.class.name} (#{remote_resource.identifier}).".colorize(:magenta)
-      cleanup_plugins(http_client, local_resource, remote_resource)
+    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)
@@ -133,21 +132,26 @@ module Kongfigure::Services
       end
     end
 
-    def need_update_plugins?(resource, related_resource)
+    def need_update_plugins?(resource, related_remote_resource)
       resource.plugins.reject do |plugin|
-        find_related_resource(plugin, related_resource.plugins)
+        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_resource)
+    def need_cleanup_plugins?(resource, related_remote_resource)
       resource.plugins.reject do |plugin|
-        find_related_resource(plugin, related_resource.plugins)
-      end.size == 0 && resource.plugins.size < related_resource.plugins.size
+        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_plugins(http_client, local_resource, remote_resource)
+    def create_or_update_plugins(http_client, local_resource, remote_resource)
       local_resource.plugins.each do |plugin|
-        unless find_related_resource(plugin, remote_resource.plugins)
+        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
@@ -155,7 +159,7 @@ module Kongfigure::Services
 
     def cleanup_plugins(http_client, local_resource, remote_resource)
       remote_resource.plugins.each do |plugin|
-        unless find_related_resource(plugin, local_resource.plugins)
+        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

data/lib/kongfigure/services/consumer.rb

@@ -43,7 +43,7 @@ module Kongfigure::Services
 
     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)
+        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
@@ -51,7 +51,7 @@ module Kongfigure::Services
 
     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)
+        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

data/lib/kongfigure/services/plugin.rb

@@ -11,7 +11,7 @@ module Kongfigure::Services
 
     def cleanup(http_client, resource, related_resource)
       return unless related_resource.is_global?
-      puts "-> Cleanup #{remote_resource.class.name} (#{remote_resource.identifier}).".colorize(:magenta)
+      puts "-> Cleanup #{related_resource.class.name} (#{related_resource.identifier}).".colorize(:magenta)
       http_client.delete("#{resource_name}/#{related_resource.id}")
     end
   end

data/lib/kongfigure/services/service.rb

@@ -1,34 +1,34 @@
 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)
+    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_resource)
-      super(http_client, resource, related_resource)
-      create_routes(http_client, resource, related_resource)
+    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_resource)
-      super(http_client, resource, related_resource)
-      cleanup_routes(http_client, resource, related_resource)
+    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_resource)
-      super(resource, related_resource) || resource.nil? || resource.routes != related_resource.routes
+    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_resource)
-      super(resource, related_resource) || (resource && (resource.routes != related_resource.routes))
+    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_resource)
+    def create_routes(http_client, resource, related_remote_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)
+        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
@@ -44,7 +44,7 @@ module Kongfigure::Services
       end
       # cleanup useless routes
       remote_resource.routes.each do |remote_resource_route|
-        unless local_resource.has_route?(remote_resource_route)
+        if local_resource.nil? || !local_resource.has_route?(remote_resource_route)
           http_client.delete("routes/#{remote_resource_route.id}")
         end
       end

data/lib/kongfigure/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kongfigure
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.8
 platform: ruby
 authors:
 - Ibanity
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-06 00:00:00.000000000 Z
+date: 2020-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -148,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Kongfigure.