skull_island 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19ab037beb02518e751019c8d59bd81cdf9165b373ea5b31287ed6dc829a4f21
-  data.tar.gz: 1a352da5080eaae1ce030f872fcda1e53dbbbca2dfb39af5536db2cb1772fe8e
+  metadata.gz: 4d6ae44ca3ddea5f866e493af05df16b8355716442acd5a475e1177049260177
+  data.tar.gz: 41ee93c3a6491b28b7e516e3b13166506080f52fa6b3f439bc4510e77b8cae39
 SHA512:
-  metadata.gz: f5f1d27b7b1114ccad775df93c7db93d42279fcdb085cf76323efb2f1c2d5aa09dc6a83132e4ab7dbc9eefd349b420ff10f9f7c3abc53fe39839aa18e787c9cb
-  data.tar.gz: ee44a34f72104f02785949a609919230d511e39dbb332ee96ed4c13ec95d800e240d098613570b49b2d0814ac6b81f86f4cc201dfdb8bed93de1cdc320e451c9
+  metadata.gz: 5996e8c7bf5773c8d43f98d2d85f8590d47caa61d19d9a198a4252f6e34f834dd41ff9989ea3726eedbb94ae323b3b79d0c6ad472ab8d6525eb902911191c0f5
+  data.tar.gz: 48f5e8d92c92c6ab399426c3ba39687a20c091dfe01f5c0126cb13d935f6efdf8fd906f0ae38fbb140c740d17781e80e866572c8d4cdab2a0ecc6cc417fb7af6

data/.rubocop.yml

@@ -12,10 +12,16 @@ Metrics/ClassLength:
 
 Metrics/ModuleLength:
   Max: 165
+  Exclude:
+    - 'lib/skull_island/helpers/resource.rb'
 
 Metrics/CyclomaticComplexity:
   Max: 7
 
+Metrics/PerceivedComplexity:
+  Exclude:
+    - 'lib/skull_island/cli.rb'
+
 Metrics/AbcSize:
   Max: 25
 
@@ -32,7 +38,7 @@ Layout/IndentHeredoc:
 
 Security/Eval:
   Exclude:
-    - Gemfile
+    - 'lib/skull_island/cli.rb'
 
 Style/NumericLiterals:
   Exclude:

data/Gemfile.lock

@@ -1,10 +1,12 @@
 PATH
   remote: .
   specs:
-    skull_island (0.1.1)
-      json (~> 2.0)
+    skull_island (0.2.0)
+      erubi (~> 1.8)
+      json (~> 2.1)
       linguistics (~> 2.1)
       rest-client (~> 2.0)
+      thor (~> 0.20)
       will_paginate (~> 3.1)
 
 GEM
@@ -17,6 +19,7 @@ GEM
     docile (1.3.1)
     domain_name (0.5.20180417)
       unf (>= 0.0.5, < 1.0.0)
+    erubi (1.8.0)
     ethon (0.12.0)
       ffi (>= 1.3.0)
     faraday (0.15.4)
@@ -91,6 +94,7 @@ GEM
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
+    thor (0.20.3)
     travis (1.8.9)
       backports
       faraday (~> 0.9)

data/README.md

@@ -26,7 +26,92 @@ Gem::Specification.new do |spec|
 end
 ```
 
-## Usage
+## CLI Usage
+
+Skull Island comes with an executable called `skull_island` that leverages the SDK under the hood. Learn about what is can do via `help`:
+
+```
+$ skull_island help
+Commands:
+  skull_island export [OPTIONS] OUTPUT_FILE  # Export the current configuration to OUTPUT_FILE
+  skull_island help [COMMAND]                # Describe available commands or one specific command
+  skull_island import [OPTIONS] INPUT_FILE   # Import a configuration from INPUT_FILE
+
+Options:
+  [--verbose], [--no-verbose]
+```
+
+To use the commands that interact with the Kong API, set environment variables for the required parameters:
+
+```
+KONG_ADMIN_URL='https://api-admin.mydomain.com' \
+KONG_ADMIN_USERNAME='my-basicauth-user' \
+KONG_ADMIN_PASSWORD='my-basicauth-password' \
+skull_island ...
+```
+
+Note that you can skip `KONG_ADMIN_USERNAME` and `KONG_ADMIN_PASSWORD` if you aren't using a basic-auth reverse-proxy in front of the Admin API.
+
+Also note that if you're having SSL issues (such as with a private CA), you can have Ruby make use of a custom CA public key using `SSL_CERT_FILE`:
+
+```
+SSL_CERT_FILE=/path/to/cabundle.pem \
+KONG_ADMIN_URL='https://api-admin.mydomain.com' \
+KONG_ADMIN_USERNAME='my-basicauth-user' \
+KONG_ADMIN_PASSWORD='my-basicauth-password' \
+skull_island ...
+```
+
+### Exporting
+
+The CLI allows you to export an existing configuration to a YAML + ERB document (a YAML document with embedded Ruby). This format is helpful because it doesn't require you to know the IDs of resources, making your configuration portable.
+
+The `export` command will default to outputting to STDOUT if you don't provide an output file location. Otherwise, simply specify the filename you'd like to export to:
+
+```
+KONG_ADMIN_URL='https://api-admin.mydomain.com' \
+skull_island export /path/to/export.yml
+```
+
+You can also get a little more information by turning on `--verbose`:
+
+```
+KONG_ADMIN_URL='https://api-admin.mydomain.com' \
+skull_island export --verbose /path/to/export.yml
+```
+
+### Importing
+
+Skull Island also supports importing configurations (both partial and full) from a YAML + ERB document:
+
+```
+KONG_ADMIN_URL='https://api-admin.mydomain.com' \
+skull_island import /path/to/export.yml
+```
+
+It'll also read from STDIN if you don't specify a file path (or if you specify `-` as the path):
+
+```
+cat /path/to/export.yml | KONG_ADMIN_URL='https://api-admin.mydomain.com' skull_island import
+# OR
+KONG_ADMIN_URL='https://api-admin.mydomain.com' skull_island import < /path/to/export.yml
+```
+
+You can also get a little more information by turning on `--verbose`:
+
+```
+KONG_ADMIN_URL='https://api-admin.mydomain.com' \
+skull_island import --verbose /path/to/export.yml
+```
+
+Importing also supports a "dry run" functionality that shows you what it would do (but makes no changes) using `--test`:
+
+```
+KONG_ADMIN_URL='https://api-admin.mydomain.com' \
+skull_island import --verbose --test /path/to/export.yml
+```
+
+## SDK Usage
 
 The API Client requires configuration before it can be used. For now, this is a matter of calling `APIClient.configure()`, passing a Hash, with Symbols for keys:
 
@@ -59,7 +144,7 @@ APIClient.server_status
 # => {"database"=>{"reachable"=>true...
 ```
 
-This SDK also makes automatic (and mostly unobtrusive) caching behind the scenes. As long as this tool is the only tool making changes to the Admin API (at least while it is being used), this should be fine. Eventually, there will be an option to disable this cache (at the cost of poor performance). For now, it is possible to query this cache and even flushed it manually when required:
+This SDK also makes use of automatic (and mostly unobtrusive) caching behind the scenes. As long as this tool is the only tool making changes to the Admin API (at least while it is being used), this should be fine. Eventually, there will be an option to disable this cache (at the cost of poor performance). For now, it is possible to query this cache and even flushed it manually when required:
 
 ```ruby
 APIClient.lru_cache
@@ -194,7 +279,7 @@ resource.enabled  = true            # A Boolean
 resource.config   = { 'minute' => 50, 'hour' => 1000 } # A Hash of config keys and values
 
 # Either reference related resources by ID
-resource.service  = { 'id' => '5fd1z584-1adb-40a5-c042-63b19db49x21' }
+resource.service  = '5fd1z584-1adb-40a5-c042-63b19db49x21'
 resource.service
 # => #<SkullIsland::Resources::Services:0x00007f9f201f6f44...
 

data/exe/skull_island

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'skull_island/cli'
+
+configuration = {
+  server: ENV['KONG_ADMIN_URL']
+}
+configuration[:username] = ENV['KONG_ADMIN_USERNAME'] if ENV['KONG_ADMIN_USERNAME']
+configuration[:password] = ENV['KONG_ADMIN_PASSWORD'] if ENV['KONG_ADMIN_PASSWORD']
+
+SkullIsland::APIClient.configure(configuration)
+
+SkullIsland::CLI.start(ARGV)

data/lib/skull_island/cli.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Internal requirements
+require 'skull_island'
+
+# External requirements
+require 'yaml'
+require 'thor'
+
+module SkullIsland
+  # Base CLI for SkullIsland
+  class CLI < Thor
+    class_option :verbose, type: :boolean
+
+    desc 'export [OPTIONS] OUTPUT_FILE', 'Export the current configuration to OUTPUT_FILE'
+    def export(output_file = '-')
+      if output_file == '-'
+        STDERR.puts '[INFO] Outputting to STDOUT' if options['verbose']
+      else
+        full_filename = File.expand_path(output_file)
+        dirname = File.dirname(full_filename)
+        unless File.exist?(dirname) && File.ftype(dirname) == 'directory'
+          raise Exceptions::InvalidArguments, "#{full_filename} is invalid"
+        end
+      end
+
+      output = { 'version' => '0.14' }
+
+      [
+        Resources::Consumer,
+        Resources::Service,
+        Resources::Upstream,
+        Resources::Plugin
+      ].each { |clname| export_class(clname, output) }
+
+      if output_file == '-'
+        STDOUT.puts output.to_yaml
+      else
+        File.write(full_filename, output.to_yaml)
+      end
+    end
+
+    desc 'import [OPTIONS] INPUT_FILE', 'Import a configuration from INPUT_FILE'
+    option :test, type: :boolean, desc: "Don't do anything, just show what would happen"
+    def import(input_file = '-')
+      raw ||= if input_file == '-'
+                STDERR.puts '[INFO] Reading from STDOUT' if options['verbose']
+                STDIN.read
+              else
+                full_filename = File.expand_path(input_file)
+                unless File.exist?(full_filename) && File.ftype(full_filename) == 'file'
+                  raise Exceptions::InvalidArguments, "#{full_filename} is invalid"
+                end
+
+                begin
+                  File.read(full_filename)
+                rescue StandardError => e
+                  raise "Unable to process #{relative_path}: #{e.message}"
+                end
+              end
+
+      # rubocop:disable Security/YAMLLoad
+      input = YAML.load(raw)
+      # rubocop:enable Security/YAMLLoad
+
+      [
+        Resources::Consumer,
+        Resources::Service,
+        Resources::Upstream,
+        Resources::Plugin
+      ].each { |clname| import_class(clname, input) }
+    end
+
+    private
+
+    def export_class(class_name, output_data)
+      STDERR.puts "[INFO] Processing #{class_name.route_key}" if options['verbose']
+      output_data[class_name.route_key] = class_name.all.collect(&:export)
+    end
+
+    def import_class(class_name, import_data)
+      STDERR.puts "[INFO] Processing #{class_name.route_key}" if options['verbose']
+      class_name.batch_import(
+        import_data[class_name.route_key],
+        verbose: options['verbose'],
+        test: options['test']
+      )
+    end
+  end
+end

data/lib/skull_island/helpers/resource.rb

@@ -14,6 +14,45 @@ module SkullIsland
         )
       end
 
+      # rubocop:disable Style/GuardClause
+      def delayed_set(property, data, key)
+        # rubocop:disable Security/Eval
+        if data[key]
+          send(
+            "#{property}=".to_sym,
+            data[key].is_a?(String) ? eval(Erubi::Engine.new(data[key]).src) : data[key]
+          )
+        end
+        # rubocop:enable Security/Eval
+      end
+      # rubocop:enable Style/GuardClause
+
+      def digest
+        Digest::MD5.hexdigest(
+          digest_properties.sort.map { |prop| "#{prop}=#{send(prop.to_sym)}" }.compact.join(':')
+        )
+      end
+
+      def digest_properties
+        properties.keys.reject { |k| %i[created_at updated_at].include? k }
+      end
+
+      # Tests for an existing version of this resource based on its properties rather than its `id`
+      def find_by_digest
+        result = self.class.where(:digest, digest) # matching digest means the equivalent resource
+        if result.size == 1
+          entity_data = @api_client.cache(result.first.relative_uri.to_s) do |client|
+            client.get(result.first.relative_uri.to_s)
+          end
+          @entity  = entity_data
+          @lazy    = false
+          @tainted = false
+          true
+        else
+          false
+        end
+      end
+
       def fresh?
         !tainted?
       end
@@ -34,6 +73,39 @@ module SkullIsland
         self.class.immutable?
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def import_update_or_skip(verbose: false, test: false, index:)
+        if find_by_digest
+          puts "[INFO] Skipping #{self.class} index #{index} (#{id})" if verbose
+        elsif test
+          puts "[INFO] Would have saved #{sef.class} index #{index}"
+        elsif modified_existing?
+          puts "[INFO] Modified #{self.class} index #{index} (#{id})" if verbose
+        elsif save
+          puts "[INFO] Saved #{self.class} index #{index} (#{id})" if verbose
+        else
+          puts "[ERR] Failed to save #{self.class} index #{index}"
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def lookup(type, value)
+        case type
+        when :consumer
+          Resources::Consumer.find(:username, value).id
+        when :route
+          Resources::Route.find(:name, value).id
+        when :service
+          Resources::Service.find(:name, value).id
+        when :upstream
+          Resources::Upstream.find(:name, value).id
+        else
+          raise Exceptions::InvalidArguments, "#{type} is not a valid lookup type"
+        end
+      end
+
       # ActiveRecord ActiveModel::Name compatibility method
       def model_name
         self.class
@@ -68,21 +140,15 @@ module SkullIsland
         @tainted ? true : false
       end
 
-      # ActiveRecord ActiveModel::Conversion compatibility method
-      def to_key
-        new? ? [] : [id]
-      end
-
-      # ActiveRecord ActiveModel::Conversion compatibility method
-      def to_model
-        self
-      end
-
       # ActiveRecord ActiveModel::Conversion compatibility method
       def to_param
         new? ? nil : id.to_s
       end
 
+      def to_s
+        to_param.to_s
+      end
+
       def destroy
         raise Exceptions::ImmutableModification if immutable?
 
@@ -123,6 +189,7 @@ module SkullIsland
           @api_client.invalidate_cache_for(relative_uri.to_s)
           @entity = @api_client.put(relative_uri, saveable_data)
         end
+        @api_client.invalidate_cache_for(self.class.relative_uri.to_s) # clear any collection class
         @tainted = false
         true
       end

data/lib/skull_island/helpers/resource_class.rb

@@ -10,7 +10,8 @@ module SkullIsland
       # @return [Array<Symbol>] the list of names
       def determine_getter_names(original_name, opts)
         names = []
-        names << (opts[:type] == :boolean ? "#{original_name}?" : original_name)
+        names << original_name
+        names << "#{original_name}?" if opts[:type] == :boolean
         if opts[:as]
           Array(opts[:as]).each do |new_name|
             names << (opts[:type] == :boolean ? "#{new_name}?" : new_name)

data/lib/skull_island/resource.rb

@@ -97,8 +97,12 @@ module SkullIsland
       root = 'data' # root for API JSON response data
       # TODO: do something with lazy requests...
 
+      collection_entity = api_client.cache(relative_uri) do |client|
+        client.get(relative_uri)[root]
+      end
+
       ResourceCollection.new(
-        api_client.get(relative_uri)[root].collect do |record|
+        collection_entity.collect do |record|
           unless options[:lazy]
             api_client.invalidate_cache_for "#{relative_uri}/#{record['id']}"
             api_client.cache("#{relative_uri}/#{record['id']}") do
@@ -131,6 +135,12 @@ module SkullIsland
       )
     end
 
+    # Returns the first (and hopefully only) resource given some criteria
+    # This is a very crude helper and could be made much better
+    def self.find(attribute, value, options = {})
+      where(attribute, value, options).first
+    end
+
     def self.get(id, options = {})
       # TODO: Add validations for options
 

data/lib/skull_island/resources/certificate.rb

@@ -12,6 +12,45 @@ module SkullIsland
       property :snis, validate: true
       property :created_at, read_only: true, postprocess: true
 
+      def self.batch_import(data, verbose: false, test: false)
+        raise(Exceptions::InvalidArguments) unless data.is_a?(Array)
+
+        data.each_with_index do |resource_data, index|
+          resource = new
+          resource.cert = resource_data['cert']
+          resource.key = resource_data['key']
+          resource.snis = resource_data['snis'] if resource_data['snis']
+          resource.import_update_or_skip(index: index, verbose: verbose, test: test)
+        end
+      end
+
+      def export(options = {})
+        hash = { 'cert' => cert, 'key' => key, 'snis' => snis }
+        [*options[:exclude]].each do |exclude|
+          hash.delete(exclude.to_s)
+        end
+        [*options[:include]].each do |inc|
+          hash[inc.to_s] = send(:inc)
+        end
+        hash.reject { |_, value| value.nil? }
+      end
+
+      def modified_existing?
+        return false unless new?
+
+        # Find certs of the same cert and key
+        same_key = self.class.where(:key, key)
+
+        existing = same_key.size == 1 ? same_key.first : nil
+
+        if existing
+          @entity['id'] = existing.id
+          save
+        else
+          false
+        end
+      end
+
       private
 
       # Used to validate {#cert} on set

data/lib/skull_island/resources/consumer.rb

@@ -11,10 +11,48 @@ module SkullIsland
       property :custom_id
       property :created_at, read_only: true, postprocess: true
 
+      def self.batch_import(data, verbose: false, test: false)
+        raise(Exceptions::InvalidArguments) unless data.is_a?(Array)
+
+        data.each_with_index do |resource_data, index|
+          resource = new
+          resource.username = resource_data['username']
+          resource.custom_id = resource_data['custom_id']
+          resource.import_update_or_skip(index: index, verbose: verbose, test: test)
+        end
+      end
+
       # Provides a collection of related {Plugin} instances
       def plugins
         Plugin.where(:consumer, self, api_client: api_client)
       end
+
+      def export(options = {})
+        hash = { 'username' => username, 'custom_id' => custom_id }
+        [*options[:exclude]].each do |exclude|
+          hash.delete(exclude.to_s)
+        end
+        [*options[:include]].each do |inc|
+          hash[inc.to_s] = send(:inc)
+        end
+        hash.reject { |_, value| value.nil? }
+      end
+
+      def modified_existing?
+        return false unless new?
+
+        # Find consumers of the same username
+        same_username = self.class.where(:username, username)
+
+        existing = same_username.size == 1 ? same_username.first : nil
+
+        if existing
+          @entity['id'] = existing.id
+          save
+        else
+          false
+        end
+      end
     end
   end
 end

data/lib/skull_island/resources/plugin.rb

@@ -16,6 +16,21 @@ module SkullIsland
       property :service_id, validate: true, preprocess: true, postprocess: true, as: :service
       property :created_at, read_only: true, postprocess: true
 
+      def self.batch_import(data, verbose: false, test: false)
+        raise(Exceptions::InvalidArguments) unless data.is_a?(Array)
+
+        data.each_with_index do |resource_data, index|
+          resource = new
+          resource.name = resource_data['name']
+          resource.enabled = resource_data['enabled']
+          resource.config = resource_data['config'] if resource_data['config']
+          resource.delayed_set(:consumer, resource_data, 'consumer_id')
+          resource.delayed_set(:route, resource_data, 'route_id')
+          resource.delayed_set(:service, resource_data, 'service_id')
+          resource.import_update_or_skip(index: index, verbose: verbose, test: test)
+        end
+      end
+
       def self.enabled_names(api_client: APIClient.instance)
         api_client.get("#{relative_uri}/enabled")['enabled_plugins']
       end
@@ -24,6 +39,51 @@ module SkullIsland
         api_client.get("#{relative_uri}/schema/#{name}")
       end
 
+      def export(options = {})
+        hash = {
+          'name' => name,
+          'enabled' => enabled?,
+          'config' => config
+        }
+        hash['consumer_id'] = "<%= lookup :consumer, '#{consumer.username}' %>" if consumer
+        hash['route_id'] = "<%= lookup :route, '#{route.name}' %>" if route
+        hash['service_id'] = "<%= lookup :service, '#{service.name}' %>" if service
+        [*options[:exclude]].each do |exclude|
+          hash.delete(exclude.to_s)
+        end
+        [*options[:include]].each do |inc|
+          hash[inc.to_s] = send(:inc)
+        end
+        hash.reject { |_, value| value.nil? }
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity
+      def modified_existing?
+        return false unless new?
+
+        # Find plugins of the same name
+        same_name = self.class.where(:name, name)
+        return false if same_name.size.zero?
+
+        same_name_and_consumer = same_name.where(:consumer, consumer)
+        same_name_and_route = same_name.where(:route, route)
+        same_name_and_service = same_name.where(:service, service)
+        existing = if same_name_and_consumer.size == 1
+                     same_name_and_consumer.first
+                   elsif same_name_and_route.size == 1
+                     same_name_and_route.first
+                   elsif same_name_and_service.size == 1
+                     same_name_and_service.first
+                   end
+        if existing
+          @entity['id'] = existing.id
+          save
+        else
+          false
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
       private
 
       # TODO: 1.0.x requires refactoring as `consumer_id` becomes `consumer`
@@ -125,19 +185,19 @@ module SkullIsland
       # Used to validate {#consumer} on set
       def validate_consumer_id(value)
         # allow either a Consumer object or a Hash of a specific structure
-        value.is_a?(Consumer) || (value.is_a?(Hash) && value['id'].is_a?(String))
+        value.is_a?(Consumer) || value.is_a?(String)
       end
 
       # Used to validate {#route} on set
       def validate_route_id(value)
         # allow either a Route object or a Hash of a specific structure
-        value.is_a?(Route) || (value.is_a?(Hash) && value['id'].is_a?(String))
+        value.is_a?(Route) || value.is_a?(String)
       end
 
       # Used to validate {#service} on set
       def validate_service_id(value)
         # allow either a Service object or a Hash of a specific structure
-        value.is_a?(Service) || (value.is_a?(Hash) && value['id'].is_a?(String))
+        value.is_a?(Service) || value.is_a?(String)
       end
     end
   end

data/lib/skull_island/resources/route.rb

@@ -23,11 +23,72 @@ module SkullIsland
       property :created_at, read_only: true, postprocess: true
       property :updated_at, read_only: true, postprocess: true
 
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize
+      def self.batch_import(data, verbose: false, test: false)
+        raise(Exceptions::InvalidArguments) unless data.is_a?(Array)
+
+        data.each_with_index do |rdata, index|
+          resource = new
+          resource.name = rdata['name']
+          resource.methods = rdata['methods'] if rdata['methods']
+          resource.paths = rdata['paths'] if rdata['paths']
+          resource.protocols = rdata['protocols'] if rdata['protocols']
+          resource.hosts = rdata['hosts'] if rdata['hosts']
+          resource.regex_priority = rdata['regex_priority'] if rdata['regex_priority']
+          resource.strip_path = rdata['strip_path'] unless rdata['strip_path'].nil?
+          resource.preserve_host = rdata['preserve_host'] unless rdata['preserve_host'].nil?
+          resource.delayed_set(:service, rdata, 'service')
+          resource.import_update_or_skip(index: index, verbose: verbose, test: test)
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize
+
       # Provides a collection of related {Plugin} instances
       def plugins
         Plugin.where(:route, self, api_client: api_client)
       end
 
+      def export(options = {})
+        hash = {
+          'name' => name,
+          'methods' => methods,
+          'paths' => paths,
+          'protocols' => protocols,
+          'hosts' => hosts,
+          'regex_priority' => regex_priority,
+          'strip_path' => strip_path?,
+          'preserve_host' => preserve_host?
+        }
+        hash['service'] = { 'id' => "<%= lookup :service, '#{service.name}' %>" } if service
+        [*options[:exclude]].each do |exclude|
+          hash.delete(exclude.to_s)
+        end
+        [*options[:include]].each do |inc|
+          hash[inc.to_s] = send(:inc)
+        end
+        hash.reject { |_, value| value.nil? }
+      end
+
+      def modified_existing?
+        return false unless new?
+
+        # Find routes of the same name and service
+        same_name_and_service = self.class.where(:name, name).and(:service, service)
+
+        existing = same_name_and_service.size == 1 ? same_name_and_service.first : nil
+
+        if existing
+          @entity['id'] = existing.id
+          save
+        else
+          false
+        end
+      end
+
       private
 
       def postprocess_service(value)

data/lib/skull_island/resources/service.rb

@@ -19,6 +19,32 @@ module SkullIsland
       property :created_at, read_only: true, postprocess: true
       property :updated_at, read_only: true, postprocess: true
 
+      # rubocop:disable Metrics/AbcSize
+      def self.batch_import(data, verbose: false, test: false)
+        raise(Exceptions::InvalidArguments) unless data.is_a?(Array)
+
+        data.each_with_index do |rdata, index|
+          resource = new
+          resource.name = rdata['name']
+          resource.retries = rdata['retries'] if rdata['retries']
+          resource.protocol = rdata['protocol']
+          resource.host = rdata['host']
+          resource.port = rdata['port']
+          resource.path = rdata['path'] if rdata['path']
+          resource.connect_timeout = rdata['connect_timeout'] if rdata['connect_timeout']
+          resource.write_timeout = rdata['write_timeout'] if rdata['write_timeout']
+          resource.read_timeout = rdata['read_timeout'] if rdata['read_timeout']
+          resource.import_update_or_skip(index: index, verbose: verbose, test: test)
+
+          Route.batch_import(
+            rdata['routes'].map { |r| r.merge('service' => { 'id' => resource.id }) },
+            verbose: verbose,
+            test: test
+          )
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
       # Convenience method to add routes
       def add_route!(details)
         r = details.is_a?(Route) ? details : Route.from_hash(details, api_client: api_client)
@@ -37,6 +63,44 @@ module SkullIsland
         Plugin.where(:service, self, api_client: api_client)
       end
 
+      def export(options = {})
+        hash = {
+          'name' => name,
+          'retries' => retries,
+          'protocol' => protocol,
+          'host' => host,
+          'port' => port,
+          'path' => path,
+          'connect_timeout' => connect_timeout,
+          'write_timeout' => write_timeout,
+          'read_timeout' => read_timeout
+        }
+        hash['routes'] = routes.collect { |route| route.export(exclude: 'service') }
+        [*options[:exclude]].each do |exclude|
+          hash.delete(exclude.to_s)
+        end
+        [*options[:include]].each do |inc|
+          hash[inc.to_s] = send(:inc)
+        end
+        hash.reject { |_, value| value.nil? }
+      end
+
+      def modified_existing?
+        return false unless new?
+
+        # Find routes of the same name
+        same_name = self.class.where(:name, name)
+
+        existing = same_name.size == 1 ? same_name.first : nil
+
+        if existing
+          @entity['id'] = existing.id
+          save
+        else
+          false
+        end
+      end
+
       def url=(uri_or_string)
         uri_data = URI(uri_or_string)
         self.protocol = uri_data.scheme

data/lib/skull_island/resources/upstream.rb

@@ -18,6 +18,41 @@ module SkullIsland
       property :healthchecks, validate: true
       property :created_at, read_only: true, postprocess: true
 
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize
+      def self.batch_import(data, verbose: false, test: false)
+        raise(Exceptions::InvalidArguments) unless data.is_a?(Array)
+
+        data.each_with_index do |rdata, index|
+          resource = new
+          resource.name = rdata['name']
+          resource.slots = rdata['slots'] if rdata['slots']
+          resource.hash_on = rdata['hash_on']
+          resource.hash_fallback = rdata['hash_fallback']
+          resource.hash_on_header = rdata['hash_on_header']
+          if rdata['hash_fallback_header']
+            resource.hash_fallback_header = rdata['hash_fallback_header']
+          end
+          resource.hash_on_cookie = rdata['hash_on_cookie'] if rdata['hash_on_cookie']
+          if rdata['hash_on_cookie_path']
+            resource.hash_on_cookie_path = rdata['hash_on_cookie_path']
+          end
+          resource.healthchecks = rdata['healthchecks'] if rdata['healthchecks']
+          resource.import_update_or_skip(index: index, verbose: verbose, test: test)
+          puts '[INFO] Processing UpstreamTarget entries...' if verbose
+
+          UpstreamTarget.batch_import(
+            rdata['targets'].map { |t| t.merge('upstream_id' => resource.id) },
+            verbose: verbose,
+            test: test
+          )
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize
+
       def health
         if new?
           # No health status for new Upstreams
@@ -68,6 +103,44 @@ module SkullIsland
         )
       end
 
+      def export(options = {})
+        hash = {
+          'name' => name,
+          'slots' => slots,
+          'hash_on' => hash_on,
+          'hash_fallback' => hash_fallback,
+          'hash_on_header' => hash_on_header,
+          'hash_fallback_header' => hash_fallback_header,
+          'hash_on_cookie' => hash_on_cookie,
+          'hash_on_cookie_path' => hash_on_cookie_path,
+          'healthchecks' => healthchecks
+        }
+        hash['targets'] = targets.collect { |route| route.export(exclude: 'upstream_id') }
+        [*options[:exclude]].each do |exclude|
+          hash.delete(exclude.to_s)
+        end
+        [*options[:include]].each do |inc|
+          hash[inc.to_s] = send(:inc)
+        end
+        hash.reject { |_, value| value.nil? }
+      end
+
+      def modified_existing?
+        return false unless new?
+
+        # Find routes of the same name
+        same_name = self.class.where(:name, name)
+
+        existing = same_name.size == 1 ? same_name.first : nil
+
+        if existing
+          @entity['id'] = existing.id
+          save
+        else
+          false
+        end
+      end
+
       private
 
       # Used to validate {#hash_on} on set

data/lib/skull_island/resources/upstream_target.rb

@@ -15,6 +15,18 @@ module SkullIsland
       property :weight, validate: true
       property :created_at, read_only: true, postprocess: true
 
+      def self.batch_import(data, verbose: false, test: false)
+        raise(Exceptions::InvalidArguments) unless data.is_a?(Array)
+
+        data.each_with_index do |resource_data, index|
+          resource = new
+          resource.target = resource_data['target']
+          resource.delayed_set(:upstream, resource_data, 'upstream_id')
+          resource.weight = resource_data['weight'] if resource_data['weight']
+          resource.import_update_or_skip(index: index, verbose: verbose, test: test)
+        end
+      end
+
       def self.get(id, options = {})
         if options[:upstream]&.is_a?(Upstream)
           options[:upstream].target(id)
@@ -32,6 +44,36 @@ module SkullIsland
         upstream ? "#{upstream.relative_uri}/targets" : nil
       end
 
+      def export(options = {})
+        hash = { 'target' => target, 'weight' => weight }
+        hash['upstream_id'] = "<%= lookup :upstream, '#{upstream.name}' %>" if upstream
+        [*options[:exclude]].each do |exclude|
+          hash.delete(exclude.to_s)
+        end
+        [*options[:include]].each do |inc|
+          hash[inc.to_s] = send(:inc)
+        end
+        hash.reject { |_, value| value.nil? }
+      end
+
+      def modified_existing?
+        return false unless new?
+
+        # Find routes of the same name
+        same_target_and_upstream = self.class.where(:target, target).and(:upstream, upstream)
+
+        existing = same_target_and_upstream.size == 1 ? same_target_and_upstream.first : nil
+
+        if existing
+          @entity['id'] = existing.id
+          save
+        else
+          false
+        end
+      end
+
+      private
+
       def preprocess_target(input)
         if input.is_a?(URI)
           "#{input.host}:#{input.port || 8000}"

data/lib/skull_island/rspec/fake_api_client.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'digest'
-
 module SkullIsland
   module RSpec
     # A Fake API Client for RSpec testing

data/lib/skull_island/version.rb

@@ -3,7 +3,7 @@
 module SkullIsland
   VERSION = [
     0, # Major
-    1, # Minor
-    1  # Patch
+    2, # Minor
+    0  # Patch
   ].join('.')
 end

data/lib/skull_island.rb

@@ -2,11 +2,14 @@
 
 # Standard Library Requirements
 require 'date'
+require 'digest'
 require 'json'
 require 'singleton'
 require 'uri'
+require 'yaml'
 
 # External Library Requirements
+require 'erubi'
 require 'linguistics'
 Linguistics.use(:en)
 require 'rest-client'

data/skull_island.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['jonathan.gnagy@gmail.com']
 
   spec.summary       = 'Ruby SDK for Kong'
-  spec.description   = 'A Ruby SDK for Kong 1.0.x'
+  spec.description   = 'A Ruby SDK for Kong 0.14.x'
   spec.homepage      = 'https://github.com/jgnagy/skull_island'
   spec.license       = 'MIT'
 
@@ -26,9 +26,11 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '~> 2.5'
 
-  spec.add_runtime_dependency 'json', '~> 2.0'
+  spec.add_runtime_dependency 'erubi', '~> 1.8'
+  spec.add_runtime_dependency 'json', '~> 2.1'
   spec.add_runtime_dependency 'linguistics', '~> 2.1'
   spec.add_runtime_dependency 'rest-client', '~> 2.0'
+  spec.add_runtime_dependency 'thor', '~> 0.20'
   spec.add_runtime_dependency 'will_paginate', '~> 3.1'
 
   spec.add_development_dependency 'bundler', '~> 2.0'

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: skull_island
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Jonathan Gnagy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-04 00:00:00.000000000 Z
+date: 2019-03-06 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: erubi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: linguistics
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
 - !ruby/object:Gem::Dependency
   name: will_paginate
   requirement: !ruby/object:Gem::Requirement
@@ -164,10 +192,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: A Ruby SDK for Kong 1.0.x
+description: A Ruby SDK for Kong 0.14.x
 email:
 - jonathan.gnagy@gmail.com
-executables: []
+executables:
+- skull_island
 extensions: []
 extra_rdoc_files: []
 files:
@@ -182,11 +211,13 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/skull_island
 - lib/core_extensions/string/transformations.rb
 - lib/skull_island.rb
 - lib/skull_island/api_client.rb
 - lib/skull_island/api_client_base.rb
 - lib/skull_island/api_exception.rb
+- lib/skull_island/cli.rb
 - lib/skull_island/exceptions/api_client_not_configured.rb
 - lib/skull_island/exceptions/immutable_modification.rb
 - lib/skull_island/exceptions/invalid_arguments.rb
@@ -234,7 +265,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Ruby SDK for Kong