kumonos 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c1fae897610887b93621540db85b472393a017d3
-  data.tar.gz: df13da5be9a09a42c0cf5a5cb9443aa28e9744b4
+  metadata.gz: 3180e4389f67a7973e06cc18560503ebe4606e3a
+  data.tar.gz: 5e104c41129d76a4628cd02dcb68df71c3c55e36
 SHA512:
-  metadata.gz: c1b80378899957b98c5cdef91af4f420c194155893300b6fd21d14d6cb7b8ed7ae610bc9b049109c29ab5c723111058922935167fb3fb36cca9a2ef3d59e6554
-  data.tar.gz: cfca16fb8e5693bc26b82fae2f3aee19cf96505410b5802b7768d44ec6b2f31fd9d48aca672f6db881bbac0b902dbd2072a30239b5ac007a60295b3d20814e26
+  metadata.gz: 551f54b256647e1b04e9c25e26d774b9a85f2d295b28628999fdc18ace1db1bb299534649382823bda7a5d8bd341d57c62e215fa95d8c464d003112d53e7e6e4
+  data.tar.gz: cc933fb394e59ef965612a90f20ed3df3af1f9f12ffe590fed577f38db6c84783952003630d96f9e87491884d424ccd63f0dcd8fa0af4af77cc038d18e883916

data/.rspec

@@ -1,3 +1,2 @@
---format documentation
 --color
 --require spec_helper

data/example/book.yml

@@ -1,9 +1,10 @@
-# A definition for book service.
+# A example definition for book service.
 # The book service uses user service and ab-testing service.
 version: 1
 dependencies:
   - name: 'user'
     lb: 'user:8080'
+    tls: false
     connect_timeout_ms: 250
     circuit_breaker:
       max_connections: 64
@@ -18,6 +19,7 @@ dependencies:
           per_try_timeout_ms: 1000
   - name: 'ab-testing'
     lb: 'ab-testing:8080'
+    tls: false
     connect_timeout_ms: 250
     circuit_breaker:
       max_connections: 64

data/example/example-with-tls.yml

@@ -0,0 +1,18 @@
+# Example for using TLS
+version: 1
+dependencies:
+  - name: 'example'
+    lb: 'example.com:443'
+    tls: true
+    connect_timeout_ms: 250
+    circuit_breaker:
+      max_connections: 64
+      max_pending_requests: 128
+      max_retries: 3
+    routes:
+      - prefix: '/'
+        timeout_ms: 3000
+        retry_policy:
+          retry_on: '5xx,connect-failure,refused-stream'
+          num_retries: 3
+          per_try_timeout_ms: 1000

data/exe/kumonos

@@ -3,54 +3,52 @@
 
 $LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
 require 'kumonos'
-
-require 'pathname'
 require 'thor'
 
 # KumonosCli
 class KumonosCli < Thor
-  desc 'envoy SERVIVE_NAME', 'Generate envoy configuration'
-  method_option :config, aliases: '-c', desc: 'Configuration file for kumonos'
-  def envoy(service_name)
-    h = JSON.parse(File.read(options[:config]))
-    result = Kumonos::Schemas.validate_kumonos_config(h)
-    unless result.empty?
-      warn("#{options[:config]} has invalid format:")
-      warn(result)
-      warn("A schema file for kumonos-configuration is #{Kumonos::Schemas::CONFIG_SCHEMA_PATH}")
-      exit 1
-    end
-
-    config = Kumonos::Configuration.from_hash(h)
-    puts JSON.dump(Kumonos.generate(config, service_name))
+  def self.exit_on_failure?
+    true
+  end
+
+  desc 'envoy ENVOY_DEFINITION', 'Generate envoy configuration'
+  def envoy(path)
+    validate_path!(path)
+    h = JSON.parse(File.read(path))
+    validate_envoy_definition!(h, path)
+
+    definition = Kumonos::EnvoyDefinition.from_hash(h)
+    puts JSON.dump(Kumonos::Envoy.generate(definition))
   end
 
-  desc 'clusters FILEPATH OUT', 'Generate clusters configuration'
-  def clusters(filepath, output_dir)
-    name = File.basename(filepath, '.*')
+  desc 'clusters SERVIVE_DEFINITION', 'Generate clusters configuration'
+  method_option :output, aliases: '-o', desc: 'Output directory', required: true, type: :string
+  def clusters(filepath)
+    output_dir = options.fetch(:output)
+    validate_path!(filepath)
+    validate_path!(output_dir)
+
     definition = YAML.load_file(filepath)
     validate_service_definition!(definition, filepath)
-    out = JSON.dump(Kumonos.generate_clusters(definition))
+    json = JSON.dump(Kumonos::Clusters.generate(definition))
 
-    output_dir = Pathname.new(output_dir)
-    target = output_dir.join('v1', 'clusters', name, name)
-    target.parent.mkpath unless target.parent.exist?
-    target.write(out)
-    puts target
+    output = Kumonos::Output.new(output_dir, :clusters, File.basename(filepath, '.*'))
+    puts output.write(json)
   end
 
-  desc 'routes FILEPATH OUT', 'Generate routes configuration'
-  def routes(filepath, output_dir)
-    name = File.basename(filepath, '.*')
+  desc 'routes SERVIVE_DEFINITION', 'Generate routes configuration'
+  method_option :output, aliases: '-o', desc: 'Output directory', required: true, type: :string
+  def routes(filepath)
+    output_dir = options.fetch(:output)
+    validate_path!(filepath)
+    validate_path!(output_dir)
+
     definition = YAML.load_file(filepath)
     validate_service_definition!(definition, filepath)
-    out = JSON.dump(Kumonos.generate_routes(definition))
+    json = JSON.dump(Kumonos::Routes.generate(definition))
 
-    output_dir = Pathname.new(output_dir)
-    target = output_dir.join('v1', 'routes', name, name, name)
-    target.parent.mkpath unless target.parent.exist?
-    target.write(out)
-    puts target
+    output = Kumonos::Output.new(output_dir, :routes, File.basename(filepath, '.*'))
+    puts output.write(json)
   end
 
   desc 'init NAME', 'Generate a service definition'
@@ -67,13 +65,29 @@ class KumonosCli < Thor
 
   private
 
-  def validate_service_definition!(definition, filepath)
-    result = Kumonos::Schemas.validate_service_definition(definition)
+  def validate_path!(path)
+    return if File.exist?(path)
+
+    warn("No such file or directory: #{path}")
+    exit 1
+  end
+
+  def validate_envoy_definition!(h, path)
+    result = Kumonos::Schemas.validate_envoy_definition(h)
     return if result.empty?
+    warn_and_exit(result, path, Kumonos::Schemas::ENVOY_SCHEMA_PATH)
+  end
+
+  def validate_service_definition!(h, path)
+    result = Kumonos::Schemas.validate_service_definition(h)
+    return if result.empty?
+    warn_and_exit(result, path, Kumonos::Schemas::SERVIVE_DEFINITION_PATH)
+  end
 
-    warn("#{filepath} has invalid format:")
+  def warn_and_exit(result, path, schema_path)
+    warn("#{path} has invalid format:")
     warn(result)
-    warn("A schema file is #{Kumonos::Schemas::SERVIVE_DEFINITION_PATH}")
+    warn("The schema file is #{schema_path}")
     exit 1
   end
 end

data/kumonos.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Taiki Ono']
   spec.email         = ['taiks.4559@gmail.com']
 
-  spec.summary       = 'Manage configuration for Service Mesh.'
+  spec.summary       = 'A management tool for building Microservices "service mesh".'
   spec.description   = spec.summary
   spec.homepage      = 'https://github.com/taiki45/kumonos'
   spec.license       = 'MIT'

data/lib/kumonos/clusters.rb

@@ -0,0 +1,29 @@
+module Kumonos
+  # Generate clusters configuration.
+  module Clusters
+    class << self
+      def generate(definition)
+        {
+          clusters: definition['dependencies'].map { |s| service_to_cluster(s) }
+        }
+      end
+
+      private
+
+      def service_to_cluster(service)
+        out = {
+          name: service['name'],
+          connect_timeout_ms: service['connect_timeout_ms'],
+          type: 'strict_dns',
+          lb_type: 'round_robin',
+          hosts: [{ url: "tcp://#{service['lb']}" }],
+          circuit_breakers: {
+            default: service['circuit_breaker']
+          }
+        }
+        out[:ssl_context] = {} if service['tls']
+        out
+      end
+    end
+  end
+end

data/lib/kumonos/envoy.rb

@@ -0,0 +1,45 @@
+module Kumonos
+  # Generate envoy configuration.
+  module Envoy
+    class << self
+      # @param [Kumonos::EnvoyDefinition] definition
+      # @return [Hash] envoy configuration hash
+      def generate(definition)
+        {
+          listeners: [
+            {
+              address: definition.listener.fetch(:address),
+              filters: [
+                type: 'read',
+                name: 'http_connection_manager',
+                config: {
+                  codec_type: 'auto',
+                  stat_prefix: 'ingress_http',
+                  access_log: [{ path: definition.listener.fetch(:access_log_path) }],
+                  rds: {
+                    cluster: definition.ds.fetch(:name),
+                    route_config_name: DEFAULT_ROUTE_NAME,
+                    refresh_delay_ms: definition.ds.fetch(:refresh_delay_ms)
+                  },
+                  filters: [{ type: 'decoder', name: 'router', config: {} }]
+                }
+              ]
+            }
+          ],
+          admin: {
+            access_log_path: definition.admin.fetch(:access_log_path),
+            address: definition.admin.fetch(:address)
+          },
+          statsd_tcp_cluster_name: definition.statsd.fetch(:name),
+          cluster_manager: {
+            clusters: [definition.statsd],
+            cds: {
+              cluster: definition.ds.fetch(:cluster),
+              refresh_delay_ms: definition.ds.fetch(:refresh_delay_ms)
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/kumonos/{configuration.rb → envoy_definition.rb}

@@ -1,5 +1,5 @@
 module Kumonos
-  Configuration = Struct.new(:version, :ds, :statsd, :listener, :admin) do
+  EnvoyDefinition = Struct.new(:version, :ds, :statsd, :listener, :admin) do
     class << self
       def from_hash(h)
         new(

data/lib/kumonos/output.rb

@@ -0,0 +1,27 @@
+require 'pathname'
+
+module Kumonos
+  # Output manipulation.
+  class Output
+    def initialize(dir, type, name)
+      @dir = Pathname.new(dir)
+      @type = type
+      @name = name
+    end
+
+    def write(json)
+      target =
+        case @type
+        when :clusters
+          @dir.join('v1', 'clusters', @name, @name)
+        when :routes
+          @dir.join('v1', 'routes', Kumonos::DEFAULT_ROUTE_NAME, @name, @name)
+        else
+          raise %(Unknown type "#{@type}" given)
+        end
+      target.parent.mkpath unless target.parent.exist?
+      target.write(json)
+      target
+    end
+  end
+end

data/lib/kumonos/routes.rb

@@ -0,0 +1,38 @@
+module Kumonos
+  # Generate routes configuration
+  module Routes
+    class << self
+      def generate(definition)
+        {
+          validate_clusters: false,
+          virtual_hosts: definition['dependencies'].map { |s| service_to_vhost(s) }
+        }
+      end
+
+      private
+
+      def service_to_vhost(service)
+        name = service['name']
+        {
+          name: name,
+          domains: [name],
+          routes: service['routes'].flat_map { |r| split_route(r, name) }
+        }
+      end
+
+      # Split route definition to apply retry definition only to GET/HEAD requests.
+      def split_route(route, name)
+        base = {
+          prefix: route['prefix'],
+          timeout_ms: route['timeout_ms'],
+          cluster: name
+        }
+        with_retry = base.merge(
+          retry_policy: route['retry_policy'],
+          headers: [{ name: ':method', value: '(GET|HEAD)', regex: true }]
+        )
+        [with_retry, base]
+      end
+    end
+  end
+end

data/lib/kumonos/schemas.rb

@@ -5,12 +5,12 @@ module Kumonos
   # Schemas
   module Schemas
     ROOT = Pathname.new(File.expand_path('../schemas', __dir__))
-    CONFIG_SCHEMA_PATH = ROOT.join('kumonos_config.json')
+    ENVOY_SCHEMA_PATH = ROOT.join('envoy.json')
     SERVIVE_DEFINITION_PATH = ROOT.join('service_definition.json')
 
     class << self
-      def validate_kumonos_config(hash)
-        schema = load_schema(CONFIG_SCHEMA_PATH)
+      def validate_envoy_definition(hash)
+        schema = load_schema(ENVOY_SCHEMA_PATH)
         JSON::Validator.fully_validate(schema, hash)
       end
 

data/lib/kumonos/version.rb

@@ -1,3 +1,3 @@
 module Kumonos
-  VERSION = '0.3.1'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/lib/kumonos.rb

@@ -3,97 +3,13 @@ require 'yaml'
 
 require 'kumonos/version'
 require 'kumonos/schemas'
-require 'kumonos/configuration'
+require 'kumonos/envoy_definition'
+require 'kumonos/envoy'
+require 'kumonos/routes'
+require 'kumonos/clusters'
+require 'kumonos/output'
 
 # Kumonos
 module Kumonos
-  class << self
-    def generate(config, name)
-      {
-        listeners: [
-          {
-            address: config.listener.fetch(:address),
-            filters: [
-              type: 'read',
-              name: 'http_connection_manager',
-              config: {
-                codec_type: 'auto',
-                stat_prefix: 'ingress_http',
-                access_log: [{ path: config.listener.fetch(:access_log_path) }],
-                rds: {
-                  cluster: config.ds.fetch(:name),
-                  route_config_name: name,
-                  refresh_delay_ms: config.ds.fetch(:refresh_delay_ms)
-                },
-                filters: [{ type: 'decoder', name: 'router', config: {} }]
-              }
-            ]
-          }
-        ],
-        admin: {
-          access_log_path: config.admin.fetch(:access_log_path),
-          address: config.admin.fetch(:address)
-        },
-        statsd_tcp_cluster_name: config.statsd.fetch(:name),
-        cluster_manager: {
-          clusters: [config.statsd],
-          cds: {
-            cluster: config.ds.fetch(:cluster),
-            refresh_delay_ms: config.ds.fetch(:refresh_delay_ms)
-          }
-        }
-      }
-    end
-
-    def generate_routes(definition)
-      {
-        validate_clusters: false,
-        virtual_hosts: definition['dependencies'].map { |s| service_to_vhost(s) }
-      }
-    end
-
-    def generate_clusters(definition)
-      {
-        clusters: definition['dependencies'].map { |s| service_to_cluster(s) }
-      }
-    end
-
-    private
-
-    def service_to_vhost(service)
-      name = service['name']
-      {
-        name: name,
-        domains: [name],
-        routes: service['routes'].flat_map { |r| split_route(r, name) }
-      }
-    end
-
-    # Split route definition to apply retry definition only to GET/HEAD requests.
-    def split_route(route, name)
-      base = {
-        prefix: route['prefix'],
-        timeout_ms: route['timeout_ms'],
-        cluster: name
-      }
-      with_retry = base.merge(
-        retry_policy: route['retry_policy'],
-        headers: [{ name: ':method', value: '(GET|HEAD)', regex: true }]
-      )
-      [with_retry, base]
-    end
-
-    def service_to_cluster(service)
-      {
-        name: service['name'],
-        connect_timeout_ms: service['connect_timeout_ms'],
-        type: 'strict_dns',
-        lb_type: 'round_robin',
-        hosts: [{ url: "tcp://#{service['lb']}" }],
-        circuit_breakers: {
-          default: service['circuit_breaker']
-        }
-      }
-    end
-  end
+  DEFAULT_ROUTE_NAME = 'default'.freeze
 end

data/lib/schemas/service_definition.json

@@ -24,6 +24,7 @@
         "required": [
           "name",
           "lb",
+          "tls",
           "connect_timeout_ms",
           "circuit_breaker",
           "routes"
@@ -39,6 +40,11 @@
             "id": "/properties/dependencies/items/properties/lb",
             "default": "host:port"
           },
+          "tls": {
+            "type": "boolean",
+            "id": "/properties/dependencies/items/properties/tls",
+            "default": false
+          },
           "connect_timeout_ms": {
             "type": "integer",
             "id": "/properties/dependencies/items/properties/connect_timeout_ms",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kumonos
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Taiki Ono
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-06 00:00:00.000000000 Z
+date: 2017-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -122,7 +122,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.51.0
-description: Manage configuration for Service Mesh.
+description: A management tool for building Microservices "service mesh".
 email:
 - taiks.4559@gmail.com
 executables:
@@ -142,14 +142,19 @@ files:
 - bin/setup
 - bump
 - example/book.yml
-- example/kumonos.json
+- example/envoy.json
+- example/example-with-tls.yml
 - exe/kumonos
 - kumonos.gemspec
 - lib/kumonos.rb
-- lib/kumonos/configuration.rb
+- lib/kumonos/clusters.rb
+- lib/kumonos/envoy.rb
+- lib/kumonos/envoy_definition.rb
+- lib/kumonos/output.rb
+- lib/kumonos/routes.rb
 - lib/kumonos/schemas.rb
 - lib/kumonos/version.rb
-- lib/schemas/kumonos_config.json
+- lib/schemas/envoy.json
 - lib/schemas/service_definition.json
 homepage: https://github.com/taiki45/kumonos
 licenses:
@@ -174,5 +179,5 @@ rubyforge_project:
 rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
-summary: Manage configuration for Service Mesh.
+summary: A management tool for building Microservices "service mesh".
 test_files: []