skull_island 0.1.0 → 0.1.1

data/lib/skull_island/resources/service.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module SkullIsland
+  # Resource classes go here...
+  module Resources
+    # The Service resource class
+    #
+    # @see https://docs.konghq.com/0.14.x/admin-api/#service-object Service API definition
+    class Service < Resource
+      property :name
+      property :retries
+      property :protocol,           validate: true, required: true
+      property :host,               validate: true, required: true
+      property :port,               validate: true, required: true
+      property :path
+      property :connect_timeout,    validate: true
+      property :write_timeout,      validate: true
+      property :read_timeout,       validate: true
+      property :created_at, read_only: true, postprocess: true
+      property :updated_at, read_only: true, postprocess: true
+
+      # Convenience method to add routes
+      def add_route!(details)
+        r = details.is_a?(Route) ? details : Route.from_hash(details, api_client: api_client)
+
+        r.service = self
+        r.save
+      end
+
+      # Provides a collection of related {Route} instances
+      def routes
+        Route.where(:service, self, api_client: api_client)
+      end
+
+      # Provides a collection of related {Plugin} instances
+      def plugins
+        Plugin.where(:service, self, api_client: api_client)
+      end
+
+      def url=(uri_or_string)
+        uri_data = URI(uri_or_string)
+        self.protocol = uri_data.scheme
+        self.host = uri_data.host
+        self.port = uri_data.port
+      end
+
+      def url
+        u = URI('')
+        u.scheme = protocol
+        u.host = host
+        u.port = port unless [80, 443].include? port
+        u.to_s
+      end
+
+      private
+
+      # Used to validate {#protocol} on set
+      def validate_protocol(value)
+        # only HTTP and HTTPS are allowed
+        %w[http https].include? value
+      end
+
+      # Used to validate {#host} on set
+      def validate_host(value)
+        # allow only valid hostnames
+        value.match?(host_regex) && !value.match?(/_/)
+      end
+
+      # Used to validate {#port} on set
+      def validate_port(value)
+        # only positive Integers of the right value are allowed
+        value.is_a?(Integer) && value.positive? && (1...65_535).cover?(value)
+      end
+
+      # Used to validate {#connect_timeout} on set
+      def validate_connect_timeout(value)
+        # only positive Integers are allowed
+        value.is_a?(Integer) && value.positive?
+      end
+
+      # Used to validate {#write_timeout} on set
+      def validate_write_timeout(value)
+        # only positive Integers are allowed
+        value.is_a?(Integer) && value.positive?
+      end
+
+      # Used to validate {#read_timeout} on set
+      def validate_read_timeout(value)
+        # only positive Integers are allowed
+        value.is_a?(Integer) && value.positive?
+      end
+    end
+  end
+end

data/lib/skull_island/resources/upstream.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module SkullIsland
+  # Resource classes go here...
+  module Resources
+    # The Upstream resource class
+    #
+    # @see https://docs.konghq.com/0.14.x/admin-api/#upstream-objects Upstream API definition
+    class Upstream < Resource
+      property :name, required: true, validate: true
+      property :slots, validate: true
+      property :hash_on, validate: true
+      property :hash_fallback, validate: true
+      property :hash_on_header, validate: true
+      property :hash_fallback_header, validate: true
+      property :hash_on_cookie, validate: true
+      property :hash_on_cookie_path, validate: true
+      property :healthchecks, validate: true
+      property :created_at, read_only: true, postprocess: true
+
+      def health
+        if new?
+          # No health status for new Upstreams
+          nil
+        else
+          health_json = api_client.get("#{relative_uri}/health")
+          health_json['data']
+        end
+      end
+
+      # Convenience method to add upstream targets
+      def add_target!(details)
+        r = if details.is_a?(UpstreamTarget)
+              details
+            else
+              UpstreamTarget.from_hash(details, api_client: api_client)
+            end
+
+        r.upstream = self
+        r.save
+      end
+
+      def target(target_id)
+        UpstreamTarget.new(
+          entity: { 'id' => target_id, 'upstream_id' => id },
+          lazy: true,
+          tainted: false,
+          api_client: api_client
+        )
+      end
+
+      def targets
+        target_list_data = api_client.get("#{relative_uri}/targets")
+        root = 'data' # root for API JSON response data
+        # TODO: do something with lazy requests...
+
+        ResourceCollection.new(
+          target_list_data[root].each do |record|
+            UpstreamTarget.new(
+              entity: record,
+              lazy: false,
+              tainted: false,
+              api_client: api_client
+            )
+          end,
+          type: UpstreamTarget,
+          api_client: api_client
+        )
+      end
+
+      private
+
+      # Used to validate {#hash_on} on set
+      def validate_hash_on(value)
+        # only String of an acceptable value are allowed
+        %w[none consumer ip header cookie].include?(value)
+      end
+
+      # Used to validate {#hash_fallback} on set
+      def validate_hash_fallback(value)
+        # only String of an acceptable value are allowed
+        %w[none consumer ip header cookie].include?(value)
+      end
+
+      # Used to validate {#hash_on_header} on set
+      def validate_hash_on_header(value)
+        # only String is allowed and only when {#hash_on} is set to 'header'
+        value.is_a?(String) && hash_on == 'header'
+      end
+
+      # Used to validate {#hash_fallback_header} on set
+      def validate_hash_fallback_header(value)
+        # only String is allowed and only when {#hash_fallback} is set to 'header'
+        value.is_a?(String) && hash_fallback == 'header'
+      end
+
+      # Used to validate {#hash_on_cookie} on set
+      def validate_hash_on_cookie(value)
+        # only String is allowed and only when {#hash_on} or {#hash_fallback} is set to 'cookie'
+        value.is_a?(String) && [hash_on, hash_fallback].include?('cookie')
+      end
+
+      # Used to validate {#hash_cookie_path} on set
+      def validate_hash_cookie_path(value)
+        # only String is allowed and only when {#hash_on} or {#hash_fallback} is set to 'cookie'
+        value.is_a?(String) && [hash_on, hash_fallback].include?('cookie')
+      end
+
+      # Used to validate {#name} on set
+      def validate_name(value)
+        # only String is allowed
+        value.is_a?(String)
+      end
+
+      # Used to validate {#slots} on set
+      def validate_slots(value)
+        # only Integer is allowed
+        value.is_a?(Integer)
+      end
+
+      # Used to validate {#healthchecks} on set
+      def validate_healthchecks(value)
+        # TODO: seriously need to make this better...
+        # only Hash is allowed
+        value.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/skull_island/resources/upstream_target.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module SkullIsland
+  # Resource classes go here...
+  module Resources
+    # The Upstream Target resource class
+    #
+    # @see https://docs.konghq.com/0.14.x/admin-api/#target-object Target API definition
+    class UpstreamTarget < Resource
+      property :target, required: true, validate: true, preprocess: true
+      property(
+        :upstream_id,
+        required: true, validate: true, preprocess: true, postprocess: true, as: :upstream
+      )
+      property :weight, validate: true
+      property :created_at, read_only: true, postprocess: true
+
+      def self.get(id, options = {})
+        if options[:upstream]&.is_a?(Upstream)
+          options[:upstream].target(id)
+        elsif options[:upstream]
+          upstream_opts = options.merge(lazy: true)
+          Upstream.get(options[:upstream], upstream_opts).target(id)
+        end
+      end
+
+      def relative_uri
+        upstream ? "#{upstream.relative_uri}/targets/#{id}" : nil
+      end
+
+      def save_uri
+        upstream ? "#{upstream.relative_uri}/targets" : nil
+      end
+
+      def preprocess_target(input)
+        if input.is_a?(URI)
+          "#{input.host}:#{input.port || 8000}"
+        else
+          input
+        end
+      end
+
+      def preprocess_upstream_id(input)
+        if input.is_a?(Hash)
+          input['id']
+        elsif input.is_a?(String)
+          input
+        else
+          input.id
+        end
+      end
+
+      def postprocess_upstream_id(value)
+        if value.is_a?(String)
+          Upstream.new(
+            entity: { 'id' => value },
+            lazy: true,
+            tainted: false
+          )
+        else
+          value
+        end
+      end
+
+      # Used to validate {#target} on set
+      def validate_target(value)
+        # only URIs or specific strings
+        value.is_a?(URI) || (
+          value.is_a?(String) && value.match?(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d{1,5}/)
+        )
+      end
+
+      # Used to validate #upstream on set
+      def validate_upstream_id(value)
+        # allow either a Upstream object or a String
+        value.is_a?(Upstream) || value.is_a?(String)
+      end
+
+      # Used to validate {#weight} on set
+      def validate_weight(value)
+        # only positive Integers (or zero) are allowed
+        value.is_a?(Integer) && (0..1000).cover?(value)
+      end
+    end
+  end
+end

data/lib/skull_island/rspec/fake_api_client.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module SkullIsland
+  module RSpec
+    # A Fake API Client for RSpec testing
+    class FakeAPIClient
+      attr_reader :server, :base_uri
+      attr_accessor :username, :password
+
+      include Validations::APIClient
+      include Helpers::APIClient
+
+      def initialize(opts = {})
+        # validations
+        validate_opts(opts)
+
+        # Set up the client's state
+        @server     = opts[:server] || 'http://localhost:8001'
+        @username   = opts[:username] || 'admin'
+        @password   = opts[:password] || 'admin'
+        @cache      = LRUCache.new(100) # LRU cache of up to 100 items
+        @configured = true
+      end
+
+      def hash(data)
+        if data
+          Digest::MD5.hexdigest(data.sort.to_s)
+        else
+          ''
+        end
+      end
+
+      def response_for(type, uri, data: nil, response: {})
+        @responses ||= {}
+        @responses[type.to_s] ||= {}
+        key = data ? uri.to_s + hash(data) : uri.to_s
+        @responses[type.to_s][key] = response
+      end
+
+      def get(uri, _data = nil)
+        @responses ||= {}
+        @responses.dig('get', uri.to_s)
+      end
+
+      def post(uri, data = nil)
+        @responses ||= {}
+        @responses.dig('post', uri.to_s + hash(data))
+      end
+
+      def patch(uri, data)
+        @responses ||= {}
+        @responses.dig('patch', uri.to_s + hash(data))
+      end
+
+      def put(uri, data)
+        @responses ||= {}
+        @responses.dig('put', uri.to_s + hash(data))
+      end
+    end
+  end
+end

data/lib/skull_island/rspec.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'skull_island/rspec/fake_api_client'

data/lib/skull_island/simple_api_client.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SkullIsland
+  # The Simple API Client class
+  class SimpleAPIClient < APIClientBase
+    def initialize(opts = {})
+      # validations
+      validate_opts(opts)
+
+      # Set up the client's state
+      @server     = opts[:server] || 'http://localhost:8001'
+      @username   = opts[:username]
+      @password   = opts[:password]
+      @cache      = LRUCache.new(size: 1000) # LRU cache of up to 1000 items
+      @configured = true
+    end
+  end
+end

data/lib/skull_island/validations/api_client.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SkullIsland
+  module Validations
+    # APIClient validation methods
+    module APIClient
+      def validate_creds(opts, exception)
+        auto_opts_size = [opts[:username], opts[:password]].compact.size
+        raise(exception, 'Invalid Auth Provided') if auto_opts_size == 1
+      end
+
+      # Validate the options passed on initialize
+      def validate_opts(opts)
+        e = Exceptions::InvalidOptions
+        raise(e, 'Is not Hash-like') unless opts.respond_to?(:[]) && opts.respond_to?(:key?)
+
+        validate_server(opts[:server])
+        if opts.key?(:base_uri)
+          begin
+            URI.parse(opts[:base_uri])
+          rescue URI::InvalidURIError => e
+            raise(e, "Invalid base_uri: #{e}")
+          end
+        end
+
+        validate_creds(opts, e)
+        true
+      end
+
+      # Validate the server name provided
+      def validate_server(name)
+        return true unless name # if no name is provided, just go with the defaults
+
+        valid = name.is_a? String
+        begin
+          u = URI.parse(name)
+          valid = false unless u.class == URI::HTTP || u.class == URI::HTTPS
+        rescue URI::InvalidURIError
+          valid = false
+        end
+        valid || raise(Exceptions::InvalidOptions, 'Invalid server')
+      end
+    end
+  end
+end

data/lib/skull_island/validations/resource.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SkullIsland
+  module Validations
+    # Resource validation methods
+    module Resource
+      def validate_mutability
+        raise Exceptions::ImmutableModification if immutable? && @tainted # this shouldn't happen
+      end
+
+      # The 'id' field should not be set manually
+      def validate_id
+        raise Exceptions::NewInstanceWithID if @entity.key?('id') && @tainted
+      end
+
+      # Ensure that required properties are set before saving
+      def validate_required_properties(data)
+        required_properties.each do |name, _value|
+          raise Exceptions::InvalidArguments if data[name.to_s].nil?
+        end
+      end
+    end
+  end
+end

data/lib/skull_island/version.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module SkullIsland
   VERSION = [
     0, # Major
     1, # Minor
-    0  # Patch
+    1  # Patch
   ].join('.')
 end

data/lib/skull_island.rb

@@ -1,4 +1,50 @@
-require "skull_island/version"
+# frozen_string_literal: true
+
+# Standard Library Requirements
+require 'date'
+require 'json'
+require 'singleton'
+require 'uri'
+
+# External Library Requirements
+require 'linguistics'
+Linguistics.use(:en)
+require 'rest-client'
+require 'will_paginate'
+require 'will_paginate/array'
+
+# Internal Requirements
+require 'core_extensions/string/transformations'
+String.include CoreExtensions::String::Transformations
+
+require 'skull_island/version'
+require 'skull_island/api_exception'
+require 'skull_island/exceptions/api_client_not_configured'
+require 'skull_island/exceptions/immutable_modification'
+require 'skull_island/exceptions/invalid_arguments'
+require 'skull_island/exceptions/invalid_cache_size'
+require 'skull_island/exceptions/invalid_options'
+require 'skull_island/exceptions/invalid_property'
+require 'skull_island/exceptions/invalid_where_query'
+require 'skull_island/exceptions/new_instance_with_id'
+require 'skull_island/helpers/api_client'
+require 'skull_island/validations/api_client'
+require 'skull_island/lru_cache'
+require 'skull_island/api_client_base'
+require 'skull_island/api_client'
+require 'skull_island/simple_api_client'
+require 'skull_island/resource_collection'
+require 'skull_island/helpers/resource'
+require 'skull_island/helpers/resource_class'
+require 'skull_island/validations/resource'
+require 'skull_island/resource'
+require 'skull_island/resources/certificate'
+require 'skull_island/resources/consumer'
+require 'skull_island/resources/plugin'
+require 'skull_island/resources/service'
+require 'skull_island/resources/route'
+require 'skull_island/resources/upstream'
+require 'skull_island/resources/upstream_target'
 
 module SkullIsland
   class Error < StandardError; end

data/skull_island.gemspec

@@ -1,36 +1,39 @@
+# frozen_string_literal: true
 
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "skull_island/version"
+require 'skull_island/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "skull_island"
+  spec.name          = 'skull_island'
   spec.version       = SkullIsland::VERSION
-  spec.authors       = ["Jonathan Gnagy"]
-  spec.email         = ["jonathan.gnagy@gmail.com"]
+  spec.authors       = ['Jonathan Gnagy']
+  spec.email         = ['jonathan.gnagy@gmail.com']
 
   spec.summary       = 'Ruby SDK for Kong'
   spec.description   = 'A Ruby SDK for Kong 1.0.x'
   spec.homepage      = 'https://github.com/jgnagy/skull_island'
-  spec.license       = "MIT"
+  spec.license       = 'MIT'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   spec.required_ruby_version = '~> 2.5'
 
   spec.add_runtime_dependency 'json', '~> 2.0'
-  spec.add_runtime_dependency 'faraday', '~> 0.15'
+  spec.add_runtime_dependency 'linguistics', '~> 2.1'
+  spec.add_runtime_dependency 'rest-client', '~> 2.0'
+  spec.add_runtime_dependency 'will_paginate', '~> 3.1'
 
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.50'
   spec.add_development_dependency 'simplecov', '~> 0.15'
   spec.add_development_dependency 'travis', '~> 1.8'