kong-client 0.4.0

data/lib/kong/client.rb

@@ -0,0 +1,232 @@
+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
+
+    # Initialize api client
+    #
+    def initialize
+      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)
+      @default_headers = { 'Accept' => 'application/json' }
+    end
+
+    def self.api_url
+      @api_url || ENV['KONG_URI'] || 'http://localhost:8001'
+    end
+
+    def self.api_url=(url)
+      @api_url = url
+      @http_client = Excon.new(self.api_url, omit_default_port: true)
+    end
+
+    def http_client
+      self.class.http_client
+    end
+
+    # Kong Admin API URL
+    #
+    # @return [String]
+    def api_url
+      self.class.api_url
+    end
+
+    def api_url=(url)
+      @api_url = url
+    end
+
+    # Get request
+    #
+    # @param [String] path
+    # @param [Hash,NilClass] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def get(path, params = nil, headers = {})
+      response = http_client.get(
+        path: path,
+        query: encode_params(params),
+        headers: request_headers(headers)
+      )
+      if response.status == 200
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Post request
+    #
+    # @param [String] path
+    # @param [Object] obj
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def post(path, obj, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          path: path,
+          headers: request_headers,
+          body: encode_body(obj, request_headers['Content-Type']),
+          query: encode_params(params)
+      }
+      response = http_client.post(request_options)
+      if [200, 201].include?(response.status)
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Patch request
+    #
+    # @param [String] path
+    # @param [Object] obj
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def patch(path, obj, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          path: path,
+          headers: request_headers,
+          body: encode_body(obj, request_headers['Content-Type']),
+          query: encode_params(params)
+      }
+
+      response = http_client.patch(request_options)
+      if [200, 201].include?(response.status)
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Put request
+    #
+    # @param [String] path
+    # @param [Object] obj
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def put(path, obj, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          path: path,
+          headers: request_headers,
+          body: encode_body(obj, request_headers['Content-Type']),
+          query: encode_params(params)
+      }
+
+      response = http_client.put(request_options)
+      if [200, 201].include?(response.status)
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Delete request
+    #
+    # @param [String] path
+    # @param [Hash,String] body
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def delete(path, body = nil, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          path: path,
+          headers: request_headers,
+          body: encode_body(body, request_headers['Content-Type']),
+          query: encode_params(params)
+      }
+      response = http_client.delete(request_options)
+      unless response.status == 204
+        handle_error_response(response)
+      end
+    end
+
+    private
+
+    ##
+    # Get request headers
+    #
+    # @param [Hash] headers
+    # @return [Hash]
+    def request_headers(headers = {})
+      @default_headers.merge(headers)
+    end
+
+    ##
+    # Encode body based on content type
+    #
+    # @param [Object] body
+    # @param [String] content_type
+    def encode_body(body, content_type)
+      if content_type == 'application/json'
+        dump_json(body)
+      else
+        body
+      end
+    end
+
+    def encode_params(params)
+      return nil if params.nil?
+      URI.encode_www_form(params)
+    end
+
+    ##
+    # Parse response
+    #
+    # @param [HTTP::Message]
+    # @return [Object]
+    def parse_response(response)
+      if response.headers['Content-Type'].include?('application/json')
+        parse_json(response.body)
+      else
+        response.body
+      end
+    end
+
+    ##
+    # Parse json
+    #
+    # @param [String] json
+    # @return [Hash,Object,NilClass]
+    def parse_json(json)
+      JSON.parse(json) rescue nil
+    end
+
+    ##
+    # Dump json
+    #
+    # @param [Object] obj
+    # @return [String]
+    def dump_json(obj)
+      JSON.dump(obj)
+    end
+
+    def ignore_ssl_errors?
+      ENV['SSL_IGNORE_ERRORS'] == 'true'
+    end
+
+    def handle_error_response(response)
+      message = response.body
+      if response.status == 404 && message == ''
+        message = 'Not found'
+      end
+      raise Error.new(response.status, message)
+    end
+  end
+end

data/lib/kong/consumer.rb

@@ -0,0 +1,103 @@
+module Kong
+  class Consumer
+    include Base
+
+    ATTRIBUTE_NAMES = %w(id custom_id username created_at).freeze
+    API_END_POINT = '/consumers/'.freeze
+
+    def delete
+      self.oauth2_tokens.each do |token|
+        token.delete
+      end
+      super
+    end
+
+    # List plugins
+    #
+    # @return [Array<Kong::Plugin>]
+    def plugins
+      Plugin.list({ consumer_id: self.id })
+    end
+
+    # List OAuth applications
+    #
+    # @return [Array<Kong::OAuthApp>]
+    def oauth_apps
+      apps = []
+      response = client.get("#{@api_end_point}#{self.id}/oauth2") rescue nil
+      if response
+        response['data'].each do |attributes|
+          apps << Kong::OAuthApp.new(attributes)
+        end
+      end
+      apps
+    end
+
+    # List KeyAuth credentials
+    #
+    # @return [Array<Kong::KeyAuth]
+    def basic_auths
+      apps = []
+      response = client.get("#{@api_end_point}#{self.id}/basic-auth") rescue nil
+      if response
+        response['data'].each do |attributes|
+          apps << Kong::BasicAuth.new(attributes)
+        end
+      end
+      apps
+    end
+
+    # List KeyAuth credentials
+    #
+    # @return [Array<Kong::KeyAuth]
+    def key_auths
+      apps = []
+      response = client.get("#{@api_end_point}#{self.id}/key-auth") rescue nil
+      if response
+        response['data'].each do |attributes|
+          apps << Kong::KeyAuth.new(attributes)
+        end
+      end
+      apps
+    end
+
+    # List OAuth2Tokens
+    #
+    # @return [Array<Kong::OAuth2Token>]
+    def oauth2_tokens
+      if self.custom_id
+        OAuth2Token.list({ authenticated_userid: self.custom_id })
+      else
+        []
+      end
+    end
+
+    # List Acls
+    #
+    # @return [Array<Kong::Acl>]
+    def acls
+      acls = []
+      response = client.get("#{@api_end_point}#{self.id}/acls") rescue nil
+      if response
+        response['data'].each do |attributes|
+          acls << Kong::Acl.new(attributes)
+        end
+      end
+      acls
+    end
+
+    # List JWTs
+    #
+    # @return [Array<Kong::JWT>]
+    def jwts
+      apps = []
+      response = client.get("#{@api_end_point}#{self.id}/jwt") rescue nil
+      if response
+        response['data'].each do |attributes|
+          apps << Kong::JWT.new(attributes)
+        end
+      end
+      apps
+    end
+  end
+end

data/lib/kong/error.rb

@@ -0,0 +1,10 @@
+module Kong
+  class Error < StandardError
+    attr_reader :status
+
+    def initialize(status, message)
+      @status = status
+      super(message)
+    end
+  end
+end

data/lib/kong/hmac_auth.rb

@@ -0,0 +1,9 @@
+module Kong
+  class HmacAuth
+    include Base
+    include BelongsToConsumer
+
+    ATTRIBUTE_NAMES = %w(id username consumer_id).freeze
+    API_END_POINT = '/hmac-auth/'
+  end
+end

data/lib/kong/jwt.rb

@@ -0,0 +1,8 @@
+module Kong
+  class JWT
+    include Base
+    include BelongsToConsumer
+    ATTRIBUTE_NAMES = %w(id key secret consumer_id).freeze
+    API_END_POINT = '/jwt/'.freeze
+  end
+end

data/lib/kong/key_auth.rb

@@ -0,0 +1,8 @@
+module Kong
+  class KeyAuth
+    include Base
+    include BelongsToConsumer
+    ATTRIBUTE_NAMES = %w(id key consumer_id).freeze
+    API_END_POINT = "/key-auth/".freeze
+  end
+end

data/lib/kong/oauth2_token.rb

@@ -0,0 +1,14 @@
+require_relative './base'
+module Kong
+  class OAuth2Token
+    include Base
+    ATTRIBUTE_NAMES = %w(id credential_id expires_in created_at token_type access_token refresh_token scope authenticated_userid).freeze
+    API_END_POINT = "/oauth2_tokens/".freeze
+
+    # Get OAuthApp resource
+    # @return [Kong::OAuthApp]
+    def oauth_app
+      Kong::OAuthApp.find_by_id(self.credential_id)
+    end
+  end
+end

data/lib/kong/oauth_app.rb

@@ -0,0 +1,8 @@
+module Kong
+  class OAuthApp
+    include Base
+    include BelongsToConsumer
+    ATTRIBUTE_NAMES = %w(id name client_id client_secret redirect_uri consumer_id).freeze
+    API_END_POINT = "/oauth2/".freeze
+  end
+end

data/lib/kong/plugin.rb

@@ -0,0 +1,31 @@
+require_relative './util'
+
+module Kong
+  class Plugin
+    include Base
+    include BelongsToApi
+
+    ATTRIBUTE_NAMES = %w(id api_id name config enabled consumer_id).freeze
+    API_END_POINT = '/plugins/'.freeze
+
+    # Create resource
+    def create
+      flatten_config
+      super
+    end
+
+    # update resource
+    def update
+      flatten_config
+      super
+    end
+
+    private
+
+    def flatten_config
+      if attributes['config']
+        attributes.merge!(Util.flatten(attributes.delete('config'), 'config'))
+      end
+    end
+  end
+end

data/lib/kong/server.rb

@@ -0,0 +1,23 @@
+module Kong
+  class Server
+    def self.version
+      self.info['version'] rescue nil
+    end
+
+    def self.info
+      Client.instance.get('/')
+    end
+
+    def self.status
+      Client.instance.get('/status')
+    end
+
+    def self.cluster
+      Client.instance.get('/cluster')
+    end
+
+    def self.remove_node(name)
+      Client.instance.delete("/cluster/nodes/#{name}")
+    end
+  end
+end

data/lib/kong/target.rb

@@ -0,0 +1,61 @@
+module Kong
+  class Target
+    include Base
+
+    ATTRIBUTE_NAMES = %w(id upstream_id target weight).freeze
+    API_END_POINT = '/targets/'.freeze
+
+    def self.find(id)
+      raise NotImplementedError, 'Kong does not support direct access to targets, you must go via an upstream'
+    end
+
+    def self.list(params = {})
+      raise NotImplementedError, 'Kong does not support direct access to targets, you must go via an upstream'
+    end
+
+    def initialize(attributes = {})
+      super(attributes)
+      raise ArgumentError, 'You must specify an upstream_id' unless self.upstream_id
+    end
+
+    def active?
+      self.weight > 0
+    end
+
+    def save
+      create
+    end
+
+    def create_or_update
+      raise NotImplementedError, 'Kong does not support updating targets, you must delete and re-create'
+    end
+
+    def update
+      raise NotImplementedError, 'Kong does not support updating targets, you must delete and re-create'
+    end
+
+    def use_upstream_end_point
+      self.api_end_point = "/upstreams/#{self.upstream_id}#{self.class::API_END_POINT}" if self.upstream_id
+    end
+
+    # Get Upstream resource
+    # @return [Kong::Upstream]
+    def upstream
+      @upstream ||= Upstream.find(self.upstream_id)
+    end
+
+    # Set Upstream resource
+    # @param [Kong::Upstream] upstream
+    def upstream=(upstream)
+      @upstream = upstream
+      self.upstream_id = upstream.id
+    end
+
+    # Set Upstream id
+    # @param [String] id
+    def upstream_id=(id)
+      super(id)
+      use_upstream_end_point
+    end
+  end
+end

data/lib/kong/upstream.rb

@@ -0,0 +1,24 @@
+module Kong
+  class Upstream
+    include Base
+
+    ATTRIBUTE_NAMES = %w(id name slots orderlist).freeze
+    API_END_POINT = '/upstreams/'.freeze
+
+    ##
+    # @return [Array<Kong::Target>]
+    def targets
+      targets   = []
+      json_data = Client.instance.get("#{API_END_POINT}#{self.id}/targets")
+
+      if json_data['data']
+        json_data['data'].each do |target_data|
+          target = Target.new(target_data)
+          targets << target if target.active?
+        end
+      end
+
+      targets
+    end
+  end
+end

data/lib/kong/util.rb

@@ -0,0 +1,16 @@
+module Kong
+  module Util
+    def self.flatten(cursor, parent_key = nil, memo = {})
+      memo.tap do
+        case cursor
+        when Hash
+          cursor.keys.each do |key|
+            flatten(cursor[key], [parent_key, key].compact.join('.'), memo)
+          end
+        else
+          memo["#{parent_key}"] = cursor
+        end
+      end
+    end
+  end
+end

data/lib/kong/version.rb

@@ -0,0 +1,3 @@
+module Kong
+  VERSION = '0.4.0'.freeze
+end

data/lib/kong.rb

@@ -0,0 +1,20 @@
+require 'kong/version'
+require_relative 'kong/base'
+require_relative 'kong/api'
+require_relative 'kong/belongs_to_api'
+require_relative 'kong/client'
+require_relative 'kong/consumer'
+require_relative 'kong/belongs_to_consumer'
+require_relative 'kong/plugin'
+require_relative 'kong/error'
+require_relative 'kong/oauth_app'
+require_relative 'kong/oauth2_token'
+require_relative 'kong/basic_auth'
+require_relative 'kong/hmac_auth'
+require_relative 'kong/key_auth'
+require_relative 'kong/jwt'
+require_relative 'kong/acl'
+require_relative 'kong/target'
+require_relative 'kong/upstream'
+require_relative 'kong/server'
+require_relative 'kong/util'

data/spec/kong/acl_spec.rb

@@ -0,0 +1,19 @@
+require_relative "../spec_helper"
+
+describe Kong::Acl do
+  let(:valid_attribute_names) do
+    %w(id group tags consumer_id)
+  end
+
+  describe '::ATTRIBUTE_NAMES' do
+    it 'contains valid names' do
+      expect(subject.class::ATTRIBUTE_NAMES).to eq(valid_attribute_names)
+    end
+  end
+
+  describe '::API_END_POINT' do
+    it 'contains valid end point' do
+      expect(subject.class::API_END_POINT).to eq('/acls/')
+    end
+  end
+end

data/spec/kong/api_spec.rb

@@ -0,0 +1,32 @@
+require_relative "../spec_helper"
+
+describe Kong::Api do
+  let(:valid_attribute_names) do
+    %w(
+      id name request_host request_path strip_request_path
+      hosts uris strip_uri preserve_host upstream_url retries
+      upstream_connect_timeout upstream_send_timeout upstream_read_timeout
+      https_only http_if_terminated methods
+    )
+  end
+
+  describe 'ATTRIBUTE_NAMES' do
+    it 'contains valid names' do
+      expect(subject.class::ATTRIBUTE_NAMES).to eq(valid_attribute_names)
+    end
+  end
+
+  describe 'API_END_POINT' do
+    it 'contains valid end point' do
+      expect(subject.class::API_END_POINT).to eq('/apis/')
+    end
+  end
+
+  describe '.plugins' do
+    it 'requests plugins attached to Api' do
+      subject.id = '12345'
+      expect(Kong::Plugin).to receive(:list).with({ api_id: subject.id })
+      subject.plugins
+    end
+  end
+end