[WIP] Allow to operate against multiple Kong API servers

lib/kong.rb

@@ -1,5 +1,7 @@
 require 'kong/version'
 require_relative 'kong/base'
+require_relative 'kong/rootless'
+require_relative 'kong/collection'
 require_relative 'kong/api'
 require_relative 'kong/belongs_to_api'
 require_relative 'kong/client'

lib/kong/api.rb

@@ -13,7 +13,7 @@ class Api
     ##
     # @return [Array<Kong::Plugin>]
     def plugins
-      Plugin.list({ api_id: self.id })
+      Plugin.list({ api_id: self.id }, client: self.client)
     end
   end
 end

lib/kong/base.rb

@@ -4,36 +4,46 @@ module ClassMethods
 
       # List resources
       # @return [Array]
-      def list(params = {})
+      def list(params = {}, opts = {})
+        opts = {} if opts.nil?
+        client = opts[:client] ? opts[:client] : Client.instance
+        collection = opts[:collection] ? opts[:collection] : Collection.new(self, client)
+        api_end_point = opts[:api_end_point] ? opts[:api_end_point] : self::API_END_POINT
         result = []
-        json_data = Client.instance.get(self::API_END_POINT, params)
+        json_data = client.get(api_end_point, params)
         if json_data['data']
           json_data['data'].each do |instance|
-            result << self.new(instance)
+            result << self.new(instance, { client: client, collection: collection })
           end
         end
         result
       end
 
-      alias_method :all, :list
+      def all(params = {}, opts = {})
+        self.list({ size: 9999999 }, opts)
+      end
+
+      def first(opts={})
+        self.list({},opts).first
+      end
 
       # Create resource
       # @param [Hash] attributes
-      def create(attributes = {})
-        self.new(attributes).create
+      def create(attributes = {}, opts = {})
+        self.new(attributes, opts).create
       end
 
       # Find resource
       # @param [String] id
-      def find(id)
-        self.new.get(id)
+      def find(id, opts = {})
+        self.new({}, opts).get(id)
       end
 
       def method_missing(method, *arguments, &block)
         if method.to_s.start_with?('find_by_')
           attribute = method.to_s.sub('find_by_', '')
           if self.attribute_names.include?(attribute)
-            self.list({ attribute => arguments[0] })[0]
+            self.list({ attribute => arguments[0] }, arguments[1])[0]
           else
             super
           end
@@ -57,6 +67,7 @@ def respond_to?(method, include_private = false)
     end
 
     attr_accessor :attributes, :api_end_point
+    attr_reader :client, :collection
 
     def self.included(base)
       base.extend(ClassMethods)
@@ -72,18 +83,13 @@ def self.included(base)
 
     ##
     # @param [Hash] attributes
-    def initialize(attributes = {})
+    def initialize(attributes = {}, opts = {})
+      @client = opts[:client] ? opts[:client] : Client.instance
+      @collection = opts[:collection] ? opts[:collection] : Collection.new(self.class, @client)
       init_api_end_point
       init_attributes(attributes)
     end
 
-    # Get Kong API client
-    # @return [Kong::Client]
-    def client
-      Client.instance
-    end
-
-
     # Get resource
     # @param [String] key
     def get(key = nil)
@@ -104,13 +110,30 @@ def new?
       self.id.nil?
     end
 
+    def set(attributes)
+      self.attributes = attributes
+      self.attributes
+    end
+
+    def to_s
+      self.attributes.to_s
+    end
+
+    def to_json
+      self.attributes.to_json
+    end
+
+    def inspect
+      self.attributes.inspect
+    end
     # Save resource to Kong
     def save
       create_or_update
     end
 
     # Create resource
-    def create
+    def create(attributes = {})
+      attributes = self.attributes.merge(attributes)
       headers = { 'Content-Type' => 'application/x-www-form-urlencoded' }
       response = client.post(@api_end_point, nil, attributes, headers)
       init_attributes(response)
@@ -156,8 +179,12 @@ def respond_to?(method, include_private = false)
 
     def init_attributes(attributes)
       @attributes = {}
+      self.attributes = attributes
+    end
+
+    def attributes=(attributes)
       attributes.each do |key, value|
-        @attributes[key.to_s] = value
+        @attributes[key.to_s] = value if self.class.attribute_names.include?(key.to_s)
       end
       use_consumer_end_point if respond_to?(:use_consumer_end_point)
       use_api_end_point if respond_to?(:use_api_end_point)

lib/kong/belongs_to_api.rb

@@ -10,7 +10,7 @@ def use_api_end_point
     # Get Api resource
     # @return [Kong::Api]
     def api
-      @api ||= Api.find(self.api_id)
+      @api ||= Api.find(self.api_id, client: self.client)
     end
 
     # Set Api resource

lib/kong/belongs_to_consumer.rb

@@ -10,7 +10,7 @@ def use_consumer_end_point
     # Get Consumer resource
     # @return [Kong::Consumer]
     def consumer
-      @consumer ||= Consumer.find(self.consumer_id)
+      @consumer ||= Consumer.find(self.consumer_id, client: self.client)
     end
 
     # Set Consumer resource

lib/kong/client.rb

@@ -1,25 +1,25 @@
-require 'singleton'
+
 require 'json'
 require 'excon'
 require_relative './error'
 
 module Kong
   class Client
-    class << self
-      attr_accessor :http_client
-    end
 
-    include Singleton
-
-    attr_accessor :default_headers
+    attr_accessor :default_headers, :http_client, :api_url
 
     # Initialize api client
     #
-    def initialize
+    def initialize(url = nil)
       Excon.defaults[:ssl_verify_peer] = false if ignore_ssl_errors?
-      @api_url = api_url
-      self.class.http_client = Excon.new(@api_url, omit_default_port: true)
+      if url
+        @api_url = url
+      else
+        @api_url = self.class.api_url
+      end
+      @http_client = Excon.new(@api_url, omit_default_port: true)
       @default_headers = { 'Accept' => 'application/json' }
+      @collections = {}
     end
 
     def self.api_url
@@ -28,22 +28,55 @@ def self.api_url
 
     def self.api_url=(url)
       @api_url = url
-      @http_client = Excon.new(self.api_url, omit_default_port: true)
+      @instance = self.new
     end
 
-    def http_client
-      self.class.http_client
+    def self.instance
+      @instance ||= self.new
     end
 
-    # Kong Admin API URL
-    #
-    # @return [String]
-    def api_url
-      self.class.api_url
+    def consumers
+      collection(Consumer)
     end
 
-    def api_url=(url)
-      @api_url = url
+    def apis
+      collection(Api)
+    end
+
+    def oauth_apps
+      collection(OAuthApp)
+    end
+
+    def oauth2_tokens
+      collection(OAuth2Token)
+    end
+
+    def plugins
+      collection(Plugin)
+    end
+
+    def targets
+      collection(Target)
+    end
+
+    def info
+      get('/')
+    end
+
+    def status
+      get('/status')
+    end
+
+    def cluster
+      get('/cluster')
+    end
+
+    def version
+      self.info['version'] rescue nil
+    end
+
+    def remove_node(name)
+      delete("/cluster/nodes/#{name}")
     end
 
 
@@ -161,6 +194,10 @@ def delete(path, body = nil, params = {}, headers = {})
 
     private
 
+    def collection(klass)
+      @collections[klass.name] || @collections[klass.name] = Collection.new(klass, self)
+    end
+
     ##
     # Get request headers
     #

lib/kong/collection.rb

@@ -0,0 +1,31 @@
+module Kong
+  class Collection
+    def initialize(klass, client, api_end_point = nil)
+      @klass = klass
+      @client = client
+      @api_end_point = api_end_point
+    end
+
+    def first
+      self.list.first
+    end
+
+    def last
+      self.all.last
+    end
+
+    def method_missing(method, *arguments, &block)
+      opts = { client: @client, collection: self, api_end_point: @api_end_point }
+      if arguments.size == 0
+        arguments = [{}, opts]
+      else
+        arguments << opts
+      end
+      @klass.send(method, *arguments)
+    end
+
+    def respond_to?(method, include_private = false)
+      @klass.respond_to?(method, include_private)
+    end
+  end
+end