kong-client 0.4.0

data/README.md

@@ -0,0 +1,295 @@
+# Kong Client for Ruby
+
+[Kong](http://getkong.org) API client for Ruby
+
+[![Build Status](https://travis-ci.org/kontena/kong-client-ruby.svg?branch=master)](https://travis-ci.org/kontena/kong-client-ruby)
+[![Gem Version](https://badge.fury.io/rb/kong.svg)](https://badge.fury.io/rb/kong)
+
+## Installation
+Add this line to your application's Gemfile:
+
+    gem 'kong'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kong
+
+## Usage
+
+By default Kong client tries to connect `http://localhost:8001` or address provided by environment variable: `KONG_URI='http://your-kong-url:8001'`.
+
+You can set it also in your code:
+```ruby
+require 'kong'
+Kong::Client.api_url = 'http://your-kong-url:8001'
+```
+
+### Design
+
+Kong client follows a design of resoures as Plain Old Ruby objects(tm). For examples to create a new Consumer resource you can do it like this:
+
+```ruby
+consumer = Kong::Consumer.create({ username: 'testuser', custom_id: 'custom_id' })
+```
+
+OR
+
+```ruby
+consumer = Kong::Consumer.new({ username: 'testuser'})
+consumer.custom_id = '12345'
+consumer.save
+```
+
+To find existing consumer:
+
+```ruby
+consumer = Kong::Consumer.find_by_username('testuser')
+consumer = Kong::Consumer.find_by_custom_id('custom_id')
+```
+
+### All Resources and Actions
+
+To see the complete Kong Admin API documentation, please visit: https://getkong.org/docs/0.11.x/admin-api/
+
+#### Consumer
+
+```ruby
+Kong::Consumer.list(filters)
+Kong::Consumer.all()
+Kong::Consumer.find(id)
+Kong::Consumer.find_by_*(value)
+Kong::Consumer.find_all_by_*(value)
+Kong::Consumer.create(attributes)
+
+consumer = Kong::Consumer.new({ username: 'test-user' })
+consumer.get # reloads resource
+consumer.create
+consumer.update
+consumer.save # requests create_or_update action
+consumer.delete
+
+consumer.plugins
+consumer.oauth_apps
+consumer.key_auths
+consumer.basic_auths
+consumer.oauth2_tokens
+```
+
+#### API
+
+```ruby
+Kong::Api.list(filters)
+Kong::Api.all()
+Kong::Api.find(id)
+Kong::Api.find_by_*(value)
+Kong::Api.create(attributes)
+
+api = Kong::Api.new({
+  name: 'Mockbin',
+  hosts: ['example.com'],
+  uris: ['/someservice'],
+  methods: ['GET'],
+  strip_uri: false,
+  preserve_host: false,
+  upstream_url: 'https://mockbin.com'
+})
+api.get # reloads resource
+api.create
+api.update
+api.save # requests create_or_update action
+api.delete
+
+api.plugins
+```
+
+#### Plugin
+
+```ruby
+Kong::Plugin.list(filters)
+Kong::Plugin.all()
+Kong::Plugin.find(id)
+Kong::Plugin.find_by_*(value)
+Kong::Plugin.create(attributes)
+
+plugin = Kong::Plugin.new({
+  api_id: '5fd1z584-1adb-40a5-c042-63b19db49x21',
+  consumer_id: 'a3dX2dh2-1adb-40a5-c042-63b19dbx83hF4',
+  name: 'rate-limiting',
+  config: {
+    minute: 20,
+    hour: 500
+  }
+})
+
+plugin.get # reloads resource
+plugin.create
+plugin.update
+plugin.save # requests create_or_update action
+plugin.delete
+```
+
+#### Upstream and Targets (for load-balanced APIs)
+
+```ruby
+Kong::Upstream.list(filters)
+Kong::Upstream.all()
+Kong::Upstream.find(id)
+Kong::Upstream.find_by_*(value)
+Kong::Upstream.create(attributes)
+
+upstream = Kong::Upstream.new({ name: 'myservice' })
+
+upstream.get # reloads resource
+upstream.create
+upstream.update
+upstream.save # requests create_or_update action
+upstream.delete
+
+upstream.targets # lists active targets
+
+# Add targets
+Kong::Target.new({ upstream_id: upstream.id, target: 'appserver1:80' }).save
+Kong::Target.new({ upstream_id: upstream.id, target: 'appserver2:80' }).save
+
+# Add the API
+Kong::Api.new({
+  ...
+  upstream_url: 'http://myservice'
+}).save
+```
+
+#### OAuthApp
+
+```ruby
+Kong::OAuthApp.list(filters)
+Kong::OAuthApp.all()
+Kong::OAuthApp.find(consumer_id)
+Kong::OAuthApp.find_by_*(value)
+Kong::OAuthApp.create(attributes)
+
+app = Kong::OAuthApp.new({
+  consumer_id: 'a3dX2dh2-1adb-40a5-c042-63b19dbx83hF4',
+  redirect_uri: 'http://some-domain/endpoint/'
+})
+
+app.create
+app.get # reloads resource
+app.update
+app.save # requests create_or_update action
+app.delete
+```
+
+#### KeyAuth
+
+```ruby
+Kong::KeyAuth.create(attributes)
+
+auth = Kong::KeyAuth.new({
+  consumer_id: 'a3dX2dh2-1adb-40a5-c042-63b19dbx83hF4',
+})
+
+auth.create
+auth.get # reloads resource
+auth.update
+auth.save # requests create_or_update action
+auth.delete
+```
+
+#### BasicAuth
+
+```ruby
+Kong::BasicAuth.create(attributes)
+
+auth = Kong::BasicAuth.new({
+  consumer_id: 'a3dX2dh2-1adb-40a5-c042-63b19dbx83hF4',
+  username: 'user123',
+  password: 'secret'
+})
+
+auth.create
+auth.get # reloads resource
+auth.update
+auth.save # requests create_or_update action
+auth.delete
+```
+
+#### OAuth2Token
+
+```ruby
+token = Kong::OAuth2Token.find_by_access_token('SOME-TOKEN')
+
+token = Kong::OAuth2Token.new({
+  credential_id: 'KONG-APPLICATION-ID',
+  token_type: 'bearer',
+  access_token: 'SOME-TOKEN',
+  refresh_token: 'SOME-TOKEN',
+  expires_in: 3600
+})
+
+token.create
+token.update
+token.save # requests create_or_update action
+token.delete
+
+token.oauth_app
+```
+
+#### JWT
+
+```ruby
+
+jwt = Kong::JWT.new({
+  consumer_id: 'a3dX2dh2-1adb-40a5-c042-63b19dbx83hF4',
+  key: 'a36c3049b36249a3c9f8891cb127243c',
+  secret: 'e71829c351aa4242c2719cbfbe671c09'
+})
+
+jwt.create
+jwt.update
+jwt.save # requests create_or_update action
+jwt.delete
+
+consumer = Kong::Consumer.find_by_username('testuser')
+consumer.jwts
+```
+
+#### ACL
+
+```ruby
+
+acl = Kong::Acl.new({
+  consumer_id: 'a3dX2dh2-1adb-40a5-c042-63b19dbx83hF4',
+  group: 'group1',
+  tags: ["tag1", "tag2"]
+})
+
+acl.create
+acl.update
+acl.save # requests create_or_update action
+acl.delete
+
+consumer = Kong::Consumer.find_by_username('testuser')
+consumer.acls
+```
+
+#### Server Information
+
+```ruby
+Kong::Server.info
+Kong::Server.version
+Kong::Server.status
+Kong::Server.cluster
+Kong::Server.remove_node(node_name)
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/ResultadosDigitais/kong-client-ruby/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+Dir.glob('tasks/*.rake').each { |r| import r }
+
+task :default => :spec

data/kong.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kong/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kong-client"
+  spec.version       = Kong::VERSION
+  spec.authors       = ["Ecosystem API Team"]
+  spec.email         = ["ecosystem-apis@rdstation.com", "renan.porto@rdstation.com", "rogerio.angeliski@rdstation.com"]
+  spec.summary       = %q{A Ruby client for the Kong API }
+  spec.description   = %q{A Ruby client for the Kong API}
+  spec.homepage      = "https://github.com/ResultadosDigitais/kong-client-ruby"
+  spec.license       = "Apache-2.0"
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.0.0"
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_runtime_dependency "excon"
+end

data/lib/kong/acl.rb

@@ -0,0 +1,8 @@
+module Kong
+  class Acl
+    include Base
+    include BelongsToConsumer
+    ATTRIBUTE_NAMES = %w(id group tags consumer_id).freeze
+    API_END_POINT = "/acls/".freeze
+  end
+end

data/lib/kong/api.rb

@@ -0,0 +1,19 @@
+module Kong
+  class Api
+    include Base
+
+    ATTRIBUTE_NAMES = %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
+    ).freeze
+    API_END_POINT = '/apis/'.freeze
+
+    ##
+    # @return [Array<Kong::Plugin>]
+    def plugins
+      Plugin.list({ api_id: self.id })
+    end
+  end
+end

data/lib/kong/base.rb

@@ -0,0 +1,180 @@
+module Kong
+  module Base
+    module ClassMethods
+
+      # List resources
+      # @return [Array]
+      def list(params = {})
+        result = []
+        json_data = Client.instance.get(self::API_END_POINT, params)
+        if json_data['data']
+          json_data['data'].each do |instance|
+            result << self.new(instance)
+          end
+        end
+        result
+      end
+
+      alias_method :all, :list
+
+      # Create resource
+      # @param [Hash] attributes
+      def create(attributes = {})
+        self.new(attributes).create
+      end
+
+      # Find resource
+      # @param [String] id
+      def find(id)
+        self.new.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]
+          else
+            super
+          end
+        elsif method.to_s.start_with?('find_all_by_')
+          attribute = method.to_s.sub('find_all_by_', '')
+          if self.attribute_names.include?(attribute)
+            self.list({ attribute => arguments[0] })
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to?(method, include_private = false)
+        if method.to_s.start_with?('find_by_')
+          attribute = method.to_s.sub('find_by_', '')
+          if self.attribute_names.include?(attribute)
+            return true
+          else
+            super
+          end
+        elsif method.to_s.start_with?('find_all_by_')
+          attribute = method.to_s.sub('find_all_by_', '')
+          if self.attribute_names.include?(attribute)
+            return true
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+    end
+
+    attr_accessor :attributes, :api_end_point
+
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      base.send(:define_singleton_method, :attribute_names) do
+        base::ATTRIBUTE_NAMES
+      end
+
+      base.send(:define_method, :init_api_end_point) do
+        @api_end_point = base::API_END_POINT
+      end
+    end
+
+    ##
+    # @param [Hash] attributes
+    def initialize(attributes = {})
+      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)
+      key = self.id if key.nil?
+      path = @api_end_point + key
+      response = client.get(path) rescue nil
+      return nil if response.nil?
+      init_attributes(response)
+      self
+    end
+
+    # Delete resource
+    def delete
+      client.delete("#{@api_end_point}#{self.id}")
+    end
+
+    def new?
+      self.id.nil?
+    end
+
+    # Save resource to Kong
+    def save
+      create_or_update
+    end
+
+    # Create resource
+    def create
+      headers = { 'Content-Type' => 'application/json' }
+      response = client.post(@api_end_point, attributes, nil, headers)
+      init_attributes(response)
+      self
+    end
+
+    # Create or update resource
+    # Data is sent to Kong in JSON format and HTTP PUT request is used
+    def create_or_update
+      headers = { 'Content-Type' => 'application/json' }
+      response = client.put(@api_end_point, attributes, nil, headers)
+      init_attributes(response)
+      self
+    end
+
+    # Update resource
+    def update
+      headers = { 'Content-Type' => 'application/json' }
+      response = client.patch("#{@api_end_point}#{self.id}", attributes, nil, headers)
+      init_attributes(response)
+      self
+    end
+
+    def method_missing(method, *arguments, &block)
+      if self.class.attribute_names.include?(method.to_s)
+        @attributes[method.to_s]
+      elsif method.to_s.end_with?('=') && self.class.attribute_names.include?(attribute = method.to_s.split('=').first)
+        @attributes[attribute] = arguments[0]
+      else
+        super
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      if self.class.attribute_names.include?(method.to_s.split('=')[0])
+        true
+      else
+        super
+      end
+    end
+
+    private
+
+    def init_attributes(attributes)
+      @attributes = {}
+      attributes.each do |key, value|
+        @attributes[key.to_s] = value
+      end
+      use_consumer_end_point if respond_to?(:use_consumer_end_point)
+      use_api_end_point if respond_to?(:use_api_end_point)
+      use_upstream_end_point if respond_to?(:use_upstream_end_point)
+    end
+  end
+end

data/lib/kong/basic_auth.rb

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

data/lib/kong/belongs_to_api.rb

@@ -0,0 +1,30 @@
+module Kong
+  module BelongsToApi
+    attr_accessor :api
+
+    # Convert API end point relative to Kong API resource
+    def use_api_end_point
+      self.api_end_point = "/apis/#{self.api_id}#{self.class::API_END_POINT}" if self.api_id
+    end
+
+    # Get Api resource
+    # @return [Kong::Api]
+    def api
+      @api ||= Api.find(self.api_id)
+    end
+
+    # Set Api resource
+    # @param [Kong::Api] api
+    def api=(api)
+      @api = api
+      self.api_id = api.id
+    end
+
+    # Set Api id
+    # @param [String] id
+    def api_id=(id)
+      super(id)
+      use_api_end_point
+    end
+  end
+end

data/lib/kong/belongs_to_consumer.rb

@@ -0,0 +1,30 @@
+module Kong
+  module BelongsToConsumer
+    attr_accessor :consumer
+
+    # Convert API end point relative to Kong Consumer resource
+    def use_consumer_end_point
+      self.api_end_point = "/consumers/#{self.consumer_id}#{self.class::API_END_POINT}" if self.consumer_id
+    end
+
+    # Get Consumer resource
+    # @return [Kong::Consumer]
+    def consumer
+      @consumer ||= Consumer.find(self.consumer_id)
+    end
+
+    # Set Consumer resource
+    # @param [Kong::Consumer] consumer
+    def consumer=(consumer)
+      @consumer = consumer
+      self.consumer_id = consumer.id
+    end
+
+    # Set Consumer id
+    # @param [String] id
+    def consumer_id=(id)
+      super(id)
+      use_consumer_end_point
+    end
+  end
+end