kong_schema 1.1.0

data/lib/kong_schema/reporter.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'kong_schema'
+require 'tty-table'
+require 'json'
+require 'diffy'
+require 'pastel'
+require_relative './actions'
+
+module KongSchema
+  # Helper class for printing a report of the changes to be committed to Kong
+  # created by {Schema.analyze}.
+  module Reporter
+    extend self
+
+    TableHeader = %w(Change Parameters).freeze
+
+    # @param [Array<KongSchema::Action>] changes
+    #        What you get from calling {KongSchema::Schema.analyze}
+    #
+    # @return [String] The report to print to something like STDOUT.
+    def report(changes, object_format: :json)
+      pretty_print = if object_format == :json
+        JSONPrettyPrinter.method(:print)
+      else
+        YAMLPrettyPrinter.method(:print)
+      end
+
+      table = TTY::Table.new header: TableHeader do |t|
+        changes.each do |change|
+          t << print_change(change: change, pretty_print: pretty_print)
+        end
+      end
+
+      table.render(:ascii, multiline: true, padding: [0, 1, 0, 1])
+    end
+
+    private
+
+    # Print objects as human-readable JSON
+    class JSONPrettyPrinter
+      def self.print(object)
+        JSON.pretty_generate(YAML.load(YAML.dump(object))) + "\n"
+      end
+    end
+
+    # Print objects as YAML
+    class YAMLPrettyPrinter
+      def self.print(object)
+        YAML.dump(object)
+      end
+    end
+
+    def print_change(change:, pretty_print:)
+      resource_name = change.model.to_s.split('::').last
+
+      case change
+      when KongSchema::Actions::Create
+        [ "Create #{resource_name}", pretty_print.call(change.params) ]
+      when KongSchema::Actions::Update
+        record_attributes = rewrite_record_attributes(change.record)
+        current_attributes = change.params.keys.reduce({}) do |map, key|
+          map[key] = record_attributes[key]
+          map
+        end
+
+        changed_attributes = pretty_print.call(change.params)
+        current_attributes = pretty_print.call(current_attributes)
+        diff = Diffy::Diff.new(current_attributes, changed_attributes)
+
+        [ "Update #{resource_name}", diff.to_s(:color) ]
+      when KongSchema::Actions::Delete
+        [
+          "Delete #{resource_name}",
+          pretty_print.call(rewrite_record_attributes(change.record))
+        ]
+      end
+    end
+
+    # This warrants some explanation.
+    #
+    # For some Kong API objects like Target, the API will accept "indirect"
+    # values for certain parameters like "upstream_id" but in the responses for
+    # those APIs, the payload will contain a value different than what we POSTed
+    # with. In this example, it will accept an upstream_id of either an actual
+    # Upstream.id like "c9633f63-fdaf-4c1c-b9dd-b5a0fa28c780" or an
+    # Upstream.name like "some-upstream.kong-service".
+    #
+    # For our purposes, the user doesn't know about Upstream.id, so we don't
+    # care to show that value, so we will rewrite it with the value they're
+    # meant to input (e.g. target.upstream_id -> target.upstream.name)
+    def rewrite_record_attributes(record)
+      case record
+      when Kong::Target
+        record.attributes.merge('upstream_id' => record.upstream.name)
+      else
+        record.attributes
+      end
+    end
+  end
+end

data/lib/kong_schema/resource/api.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'kong'
+require_relative '../adapter'
+
+module KongSchema
+  module Resource
+    module Api
+      extend self
+
+      def identify(record)
+        case record
+        when Kong::Api
+          record.name
+        when Hash
+          record['name']
+        end
+      end
+
+      def all(*)
+        Kong::Api.all
+      end
+
+      def create(attributes)
+        Adapter.for(Kong::Api).create(serialize_outbound(attributes))
+      end
+
+      def changed?(record, attributes)
+        Adapter.for(Kong::Api).changed?(record, attributes)
+      end
+
+      def update(record, partial_attributes)
+        Adapter.for(Kong::Api).update(
+          record,
+          serialize_outbound(partial_attributes)
+        )
+      end
+
+      def delete(record)
+        Adapter.for(Kong::Api).delete(record)
+      end
+
+      def serialize_outbound(attributes)
+        attributes.keys.reduce({}) do |map, key|
+          case key
+          when 'hosts', 'uris', 'methods'
+            map[key] = Array(attributes[key]).join(',')
+          else
+            map[key] = attributes[key]
+          end
+
+          map
+        end
+      end
+    end
+  end
+end

data/lib/kong_schema/resource/target.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'kong'
+require_relative '../adapter'
+
+module KongSchema
+  module Resource
+    module Target
+      extend self
+
+      def identify(record)
+        case record
+        when Kong::Target
+          [record.upstream.name, record.target].to_json
+        when Hash
+          [record['upstream_id'], record['target']].to_json
+        end
+      end
+
+      def all(*)
+        Kong::Upstream.all.map(&:targets).flatten
+      end
+
+      def create(attributes)
+        with_upstream(attributes) do |upstream|
+          Adapter.for(Kong::Target).create(
+            attributes.merge('upstream_id' => upstream.id)
+          )
+        end
+      end
+
+      def changed?(record, directive)
+        (
+          record.target != directive['target'] ||
+          record.weight != directive.fetch('weight', 100) ||
+          record.upstream.name != directive['upstream_id']
+        )
+      end
+
+      def update(record, partial_attributes)
+        delete(record)
+        create(partial_attributes)
+      end
+
+      def delete(target)
+        Adapter.for(Kong::Target).delete(target)
+      end
+
+      private
+
+      def with_upstream(params)
+        upstream = Kong::Upstream.find_by_name(params.fetch('upstream_id', ''))
+
+        fail "Can not add a target without an upstream!" if upstream.nil?
+
+        yield upstream
+      end
+    end
+  end
+end

data/lib/kong_schema/resource/upstream.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'kong'
+require_relative '../adapter'
+
+module KongSchema
+  module Resource
+    # https://getkong.org/docs/0.11.x/admin-api/#upstream-objects
+    module Upstream
+      extend self
+
+      def identify(record)
+        case record
+        when Kong::Upstream
+          record.name
+        when Hash
+          record['name']
+        end
+      end
+
+      def all(*)
+        Kong::Upstream.all
+      end
+
+      def create(attributes)
+        Adapter.for(Kong::Upstream).create(attributes)
+      end
+
+      def changed?(record, attributes)
+        Adapter.for(Kong::Upstream).changed?(record, attributes)
+      end
+
+      def update(record, partial_attributes)
+        Adapter.for(Kong::Upstream).update(record, partial_attributes)
+      end
+
+      def delete(record)
+        Adapter.for(Kong::Upstream).delete(record)
+      end
+    end
+  end
+end

data/lib/kong_schema/resource.rb

@@ -0,0 +1,3 @@
+require_relative './resource/api'
+require_relative './resource/target'
+require_relative './resource/upstream'

data/lib/kong_schema/schema.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'kong'
+require 'English'
+
+require_relative './client'
+require_relative './resource'
+
+module KongSchema
+  module Schema
+    extend self
+
+    # Scan for changes between Kong's database and the configuration. To
+    # commit the changes (if any) use {.commit} with the results.
+    #
+    # @param [Object] config
+    #        The configuration directives as explain in README.
+    #
+    # @return [Array<Change>]
+    def scan(config)
+      Client.connect(config) do
+        [
+          scan_in(model: Resource::Api, directives: Array(config['apis'])),
+
+          # order matters in some of the resources; Upstream directives must be
+          # handled before Target ones
+          scan_in(model: Resource::Upstream, directives: Array(config['upstreams'])),
+
+          scan_in(model: Resource::Target, directives: Array(config['targets']))
+        ].flatten
+      end
+    end
+
+    # Commit changes to Kong's database through its REST API.
+    #
+    # @param [Object] config
+    # @param [Array<Change>] changes
+    #
+    # @return NilClass
+    def commit(config, directives)
+      Client.connect(config) do |client|
+        directives.each do |d|
+          begin
+            d.apply(client, config)
+          rescue StandardError
+            e = $ERROR_INFO
+            raise e, "#{e}\nSource:\n#{YAML.dump(d)}", e.backtrace
+          end
+        end
+      end
+    end
+
+    private
+
+    def scan_in(model:, directives:)
+      state = {
+        model: model,
+        defined: model.all.each_with_object({}) do |record, map|
+          map[model.identify(record)] = record
+        end,
+        declared: directives.each_with_object({}) do |directive, map|
+          map[model.identify(directive)] = directive
+        end
+      }
+
+      [
+        build_create_changes(state),
+        build_update_changes(state),
+        build_delete_changes(state)
+      ].flatten
+    end
+
+    def build_create_changes(model:, defined:, declared:)
+      to_create = declared.keys - defined.keys
+      to_create.map do |id|
+        Actions::Create.new(model: model, params: declared[id])
+      end
+    end
+
+    def build_update_changes(model:, defined:, declared:)
+      to_update = declared.keys & defined.keys
+      changed   = to_update.select do |id|
+        model.changed?(defined[id], declared[id])
+      end
+
+      changed.map do |id|
+        Actions::Update.new(
+          model: model,
+          record: defined[id],
+          params: declared[id]
+        )
+      end
+    end
+
+    def build_delete_changes(model:, defined:, declared:)
+      to_delete = defined.keys - declared.keys
+      to_delete.map do |id|
+        Actions::Delete.new(model: model, record: defined[id])
+      end
+    end
+  end
+end

data/lib/kong_schema/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module KongSchema
+  VERSION = "1.1.0"
+end

data/lib/kong_schema.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative '../ext/kong/upstream'
+require_relative './kong_schema/actions'
+require_relative './kong_schema/adapter'
+require_relative './kong_schema/cli'
+require_relative './kong_schema/reporter'
+require_relative './kong_schema/resource'
+require_relative './kong_schema/schema'
+require_relative './kong_schema/version'

data/spec/kong_schema/reporter_spec.rb

@@ -0,0 +1,89 @@
+describe KongSchema::Reporter do
+  subject { described_class }
+
+  let(:test_utils) { KongSchemaTestUtils.new }
+  let(:schema) { KongSchema::Schema }
+
+  after(:each) do
+    test_utils.reset_kong
+  end
+
+  let :config do
+    test_utils.generate_config({
+      upstreams: [{ name: 'bridge-learn.kong-service' }]
+    })
+  end
+
+  let :with_updated_config do
+    test_utils.generate_config({
+      upstreams: [{
+        name: 'bridge-learn.kong-service',
+        slots: 50,
+        orderlist: nil
+      }]
+    })
+  end
+
+  let :with_deleted_config do
+    test_utils.generate_config({
+      upstreams: []
+    })
+  end
+
+  it 'reports a resource to be created' do
+    report = subject.report(schema.scan(config))
+
+    expect(report).to include('Create Upstream')
+  end
+
+  it 'reports a resource to be updated [JSON]' do
+    schema.commit(config, schema.scan(config))
+
+    report = subject.report(schema.scan(with_updated_config))
+
+    expect(report).to include('Update Upstream')
+    expect(report).to match(/\-[ ]*"slots": 100/)
+    expect(report).to match(/\+[ ]*"slots": 50/)
+  end
+
+  it 'reports a resource to be updated [YAML]' do
+    schema.commit(config, schema.scan(config))
+
+    report = subject.report(schema.scan(with_updated_config), object_format: :yaml)
+
+    expect(report).to include('Update Upstream')
+    expect(report).to include('-slots: 100')
+    expect(report).to include('+slots: 50')
+  end
+
+  it 'reports a resource to be deleted' do
+    schema.commit(config, schema.scan(config))
+
+    report = subject.report(schema.scan(with_deleted_config))
+
+    expect(report).to include('Delete Upstream')
+  end
+
+  describe '.extract_record_attributes' do
+    context 'Kong::Target' do
+      it 'it rewrites "upstream_id" into the upstream name' do
+        with_target = test_utils.generate_config({
+          upstreams: [{ name: 'foo' }],
+          targets:   [{ upstream_id: 'foo', target: '127.0.0.1' }]
+        })
+
+        with_updated_target = test_utils.generate_config({
+          upstreams: [{ name: 'foo' }],
+          targets:   []
+        })
+
+        schema.commit(with_target, schema.scan(with_target))
+
+        next_changes = schema.scan(with_updated_target)
+        report = subject.report(next_changes, object_format: :yml)
+
+        expect(report).to include('upstream_id: foo')
+      end
+    end
+  end
+end

data/spec/kong_schema/resource/api_spec.rb

@@ -0,0 +1,125 @@
+describe KongSchema::Resource::Api do
+  let(:schema) { KongSchema::Schema }
+  let(:test_utils) { KongSchemaTestUtils.new }
+
+  after(:each) do
+    test_utils.reset_kong
+  end
+
+  describe 'creating APIs' do
+    let :config do
+      test_utils.generate_config({
+        apis: [{
+          name: 'bridge-learn',
+          hosts: ['bridgeapp.com'],
+          upstream_url: 'http://bridge-learn.kong-service'
+        }]
+      })
+    end
+
+    it 'adds an API if it does not exist' do
+      directives = schema.scan(config)
+
+      expect(directives.map(&:class)).to include(KongSchema::Actions::Create)
+    end
+
+    it 'does add an API' do
+      directives = schema.scan(config)
+
+      expect {
+        schema.commit(config, directives)
+      }.to change {
+        KongSchema::Client.connect(config) { Kong::Api.all.count }
+      }.by(1)
+    end
+
+    it 'does not add an API if it exists' do
+      directives = schema.scan(config)
+
+      schema.commit(config, directives)
+
+      next_directives = schema.scan(config)
+
+      expect(next_directives.map(&:class)).not_to include(KongSchema::Actions::Create)
+    end
+  end
+
+  describe 'updating APIs' do
+    let :config do
+      test_utils.generate_config({
+        apis: [{
+          name: 'bridge-learn',
+          hosts: ['bridgeapp.com'],
+          upstream_url: 'http://bridge-learn.kong-service'
+        }]
+      })
+    end
+
+    let :with_updated_config do
+      test_utils.generate_config({
+        apis: [{
+          name: 'bridge-learn',
+          hosts: ['bar.com'],
+          upstream_url: 'http://bridge-learn.kong-service'
+        }]
+      })
+    end
+
+    before(:each) do
+      schema.commit(config, schema.scan(config))
+    end
+
+    it 'updates an API' do
+      directives = schema.scan(with_updated_config)
+      expect(directives.map(&:class)).to include(KongSchema::Actions::Update)
+    end
+
+    it 'does update an API' do
+      directives = schema.scan(with_updated_config)
+
+      expect {
+        schema.commit(with_updated_config, directives)
+      }.to change {
+        KongSchema::Client.connect(config) { Kong::Api.all[0].hosts[0] }
+      }.from('bridgeapp.com').to('bar.com')
+    end
+  end
+
+  describe 'deleting APIs' do
+    let :config do
+      test_utils.generate_config({
+        apis: [{
+          name: 'bridge-learn',
+          hosts: ['bar.com'],
+          upstream_url: 'http://bridge-learn.kong-service'
+        }]
+      })
+    end
+
+    let :with_deleted_config do
+      test_utils.generate_config({
+        apis: []
+      })
+    end
+
+    before(:each) do
+      schema.commit(config, schema.scan(config))
+    end
+
+    it 'deletes an API' do
+      directives = schema.scan(with_deleted_config)
+
+      expect(directives.map(&:class)).to include(KongSchema::Actions::Delete)
+    end
+
+    it 'does delete an API' do
+      directives = schema.scan(with_deleted_config)
+
+      expect {
+        schema.commit(with_deleted_config, directives)
+      }.to change {
+        KongSchema::Client.connect(config) { Kong::Api.all.count }
+      }.from(1).to(0)
+    end
+  end
+end