kong 0.1.0

data/README.md

@@ -0,0 +1,210 @@
+# 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)
+
+## 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'
+```
+
+### Desing
+
+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
+
+#### Consumer
+
+```ruby
+Kong::Consumer.list(filters)
+Kong::Consumer.all()
+Kong::Consumer.find(id)
+Kong::Consumer.find_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',
+  request_host: 'mockbin.com',
+  request_path: '/someservice',
+  strip_request_path: 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
+```
+
+#### 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::KeyAuth.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
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/kontena/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"
+  spec.version       = Kong::VERSION
+  spec.authors       = ["Lauri Nevala"]
+  spec.email         = ["lauri@kontena.io"]
+  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/kontena/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.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency "excon", "~> 0.49.0"
+end

data/lib/kong.rb

@@ -0,0 +1,13 @@
+require 'kong/version'
+require 'kong/base'
+require 'kong/api'
+require 'kong/belongs_to_api'
+require 'kong/client'
+require 'kong/consumer'
+require 'kong/belongs_to_consumer'
+require 'kong/plugin'
+require 'kong/error'
+require 'kong/oauth_app'
+require 'kong/oauth2_token'
+require 'kong/basic_auth'
+require 'kong/key_auth'

data/lib/kong/api.rb

@@ -0,0 +1,14 @@
+module Kong
+  class Api
+    include Base
+
+    ATTRIBUTE_NAMES = %w(id name request_host request_path strip_request_path preserve_host upstream_url).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,153 @@
+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
+        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/x-www-form-urlencoded' }
+      response = client.post(@api_end_point, nil, attributes, 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/x-www-form-urlencoded' }
+      response = client.patch("#{@api_end_point}#{self.id}", nil, attributes, 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)
+    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