kumonos 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e8bce93ae7e9f596bc9be6c4095b9e743536ff10
-  data.tar.gz: e3d0d47a86b65f3434e5b10757e543105ead5385
+  metadata.gz: afaa277aeea2b85f5bc5620bdb387aa5a9d0a26e
+  data.tar.gz: 3819d46ee9f7b0dc92b2509e75661be77212e9ca
 SHA512:
-  metadata.gz: cc1a11c5f9762e9eb7463447ed8c4b4b30127c9185e5cad69ba5fe5d73839a67a4d54d8729511b66d68a1f34026261eaf84b74ba9c40bbda9309bb1836ad4324
-  data.tar.gz: 2384a77f383f890ffdc67c1f1c8a24ac6b36303a4a50a242e87c4251f7b9011b47ee91c5a8510df55312038b31bcd9affd584b2d6311d3e8e0236a6dd9f7a0ab
+  metadata.gz: a39107a4642db4fb6129956013e248b2737edc05589025fcaa2afd707f8461fced00bb3c335cec08826aa69e6792b5dd6ff53060088cf0248e208613dca40e3b
+  data.tar.gz: deee3de7fdb0e54a86a6902a0ba037a2c5b69d617c07b9141ebb12d40abb43aa8ab8a9783805b9d4efd4eac590210aa3fa8689a6267378152f0d84b5d3782902

data/exe/kumonos

@@ -14,10 +14,8 @@ class KumonosCli < Thor
   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)
+    definition = JSON.parse(File.read(path))
+    validate_envoy_definition!(definition, path)
     puts JSON.dump(Kumonos::Envoy.generate(definition))
   end
 

data/lib/kumonos/clusters.rb

@@ -4,25 +4,47 @@ module Kumonos
     class << self
       def generate(definition)
         {
-          clusters: definition['dependencies'].map { |s| service_to_cluster(s) }
+          clusters: definition['dependencies'].map { |s| Cluster.build(s).to_h }
         }
       end
+    end
 
-      private
+    Cluster = Struct.new(:name, :connect_timeout_ms, :lb, :tls, :circuit_breaker) do
+      class << self
+        def build(h)
+          new(
+            h.fetch('name'),
+            h.fetch('connect_timeout_ms'),
+            h.fetch('lb'),
+            h.fetch('tls'),
+            CircuitBreaker.build(h.fetch('circuit_breaker'))
+          )
+        end
+      end
 
-      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
+      def to_h
+        h = super
+
+        h.delete(:lb)
+        h[:type] = 'strict_dns'
+        h[:lb_type] = 'round_robin'
+        h[:hosts] = [{ url: "tcp://#{lb}" }]
+
+        h.delete(:tls)
+        h[:ssl_context] = {} if tls
+
+        h.delete(:circuit_breaker)
+        h[:circuit_breakers] = { default: circuit_breaker.to_h }
+
+        h
+      end
+    end
+
+    CircuitBreaker = Struct.new(:max_connections, :max_pending_requests, :max_retries) do
+      class << self
+        def build(h)
+          new(h.fetch('max_connections'), h.fetch('max_pending_requests'), h.fetch('max_retries'))
+        end
       end
     end
   end

data/lib/kumonos/envoy.rb

@@ -2,49 +2,113 @@ module Kumonos
   # Generate envoy configuration.
   module Envoy
     class << self
-      # @param [Kumonos::EnvoyDefinition] definition
-      # @return [Hash] envoy configuration hash
       def generate(definition)
-        out = {
-          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(:cluster).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)
-          },
-          cluster_manager: {
-            clusters: [],
-            cds: {
-              cluster: definition.ds.fetch(:cluster),
-              refresh_delay_ms: definition.ds.fetch(:refresh_delay_ms)
+        EnvoyConfig.build(definition).to_h
+      end
+    end
+
+    EnvoyConfig = Struct.new(:version, :ds, :statsd, :listener, :admin) do
+      class << self
+        def build(h)
+          ds = DiscoverService.build(h.fetch('ds'))
+          new(
+            h.fetch('version'),
+            ds,
+            h['statsd'] ? Cluster.build(h['statsd']) : nil,
+            Listener.build(h.fetch('listener'), ds),
+            Admin.build(h.fetch('admin'))
+          )
+        end
+      end
+
+      def to_h
+        h = super
+        h.delete(:version)
+        h.delete(:ds)
+        h.delete(:statsd)
+        h.delete(:listener)
+        h[:admin] = admin.to_h
+        h[:listeners] = [listener.to_h]
+        h[:cluster_manager] = { cds: ds.to_h, clusters: [] }
+
+        if statsd
+          h[:statsd_tcp_cluster_name] = statsd.name
+          h[:cluster_manager][:clusters] << statsd.to_h
+        end
+
+        h
+      end
+    end
+
+    Listener = Struct.new(:address, :access_log_path, :ds) do
+      class << self
+        def build(h, ds)
+          new(h.fetch('address'), h.fetch('access_log_path'), ds)
+        end
+      end
+
+      def to_h
+        h = super
+        h.delete(:ds)
+        h.delete(:access_log_path)
+        h[:filters] = [
+          {
+            type: 'read',
+            name: 'http_connection_manager',
+            config: {
+              codec_type: 'auto',
+              stat_prefix: 'ingress_http',
+              access_log: [{ path: access_log_path }],
+              rds: {
+                cluster: ds.cluster.name,
+                route_config_name: DEFAULT_ROUTE_NAME,
+                refresh_delay_ms: ds.refresh_delay_ms
+              },
+              filters: [{ type: 'decoder', name: 'router', config: {} }]
             }
           }
-        }
+        ]
+        h
+      end
+    end
 
-        unless definition.statsd.empty?
-          out[:statsd_tcp_cluster_name] = definition.statsd.fetch(:name)
-          out[:cluster_manager][:clusters] << definition.statsd
+    DiscoverService = Struct.new(:refresh_delay_ms, :cluster) do
+      class << self
+        def build(h)
+          new(h.fetch('refresh_delay_ms'), Cluster.build(h.fetch('cluster')))
         end
+      end
 
-        out
+      def to_h
+        h = super
+        h[:cluster] = cluster.to_h
+        h
+      end
+    end
+
+    Cluster = Struct.new(:name, :type, :tls, :connect_timeout_ms, :lb_type, :hosts) do
+      class << self
+        def build(h)
+          new(h.fetch('name'), h.fetch('type'), h.fetch('tls'), h.fetch('connect_timeout_ms'), h.fetch('lb_type'), h.fetch('hosts'))
+        end
+      end
+
+      def to_h
+        h = super
+        if tls
+          cluster[:ssl_context] = {}
+        else
+          h.delete(:tls)
+        end
+        h
+      end
+    end
+
+    Admin = Struct.new(:address, :access_log_path) do
+      class << self
+        def build(h)
+          new(h.fetch('address'), h.fetch('access_log_path'))
+        end
       end
     end
   end

data/lib/kumonos/routes.rb

@@ -5,34 +5,54 @@ module Kumonos
       def generate(definition)
         {
           validate_clusters: false,
-          virtual_hosts: definition['dependencies'].map { |s| service_to_vhost(s) }
+          virtual_hosts: definition['dependencies'].map { |s| Vhost.build(s).to_h }
         }
       end
+    end
 
-      private
+    Vhost = Struct.new(:name, :domains, :routes) do
+      class << self
+        def build(h)
+          name = h.fetch('name')
+          routes = h.fetch('routes').map { |r| Route.build(r, name) }
+          new(name, [name], routes)
+        end
+      end
 
-      def service_to_vhost(service)
-        name = service['name']
-        {
-          name: name,
-          domains: [name],
-          routes: service['routes'].flat_map { |r| split_route(r, name) }
-        }
+      def to_h
+        h = super
+        h[:routes] = routes.flat_map { |r| [r.to_h_with_retry, r.to_h] }
+        h
       end
+    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'],
-          auto_host_rewrite: true,
-          cluster: name
-        }
-        with_retry = base.merge(
-          retry_policy: route['retry_policy'],
-          headers: [{ name: ':method', value: '(GET|HEAD)', regex: true }]
-        )
-        [with_retry, base]
+    Route = Struct.new(:prefix, :cluster, :timeout_ms, :retry_policy) do
+      class << self
+        def build(h, cluster)
+          new(h.fetch('prefix'), cluster, h.fetch('timeout_ms'), RetryPolicy.build(h.fetch('retry_policy')))
+        end
+      end
+
+      def to_h
+        h = super
+        h.delete(:retry_policy)
+        h[:auto_host_rewrite] = true
+        h
+      end
+
+      def to_h_with_retry
+        h = to_h
+        h[:retry_policy] = retry_policy.to_h
+        h[:headers] = [{ name: ':method', value: '(GET|HEAD)', regex: true }]
+        h
+      end
+    end
+
+    RetryPolicy = Struct.new(:retry_on, :num_retries, :per_try_timeout_ms) do
+      class << self
+        def build(h)
+          new(h.fetch('retry_on'), h.fetch('num_retries'), h.fetch('per_try_timeout_ms'))
+        end
       end
     end
   end

data/lib/kumonos/version.rb

@@ -1,3 +1,3 @@
 module Kumonos
-  VERSION = '0.8.0'.freeze
+  VERSION = '0.8.1'.freeze
 end

data/lib/kumonos.rb

@@ -3,7 +3,6 @@ require 'yaml'
 
 require 'kumonos/version'
 require 'kumonos/schemas'
-require 'kumonos/envoy_definition'
 require 'kumonos/envoy'
 require 'kumonos/routes'
 require 'kumonos/clusters'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kumonos
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Taiki Ono
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-12 00:00:00.000000000 Z
+date: 2017-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -167,7 +167,6 @@ files:
 - lib/kumonos.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
@@ -194,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: A "control plane" for Microservices "service mesh".

data/lib/kumonos/envoy_definition.rb

@@ -1,36 +0,0 @@
-module Kumonos
-  EnvoyDefinition = Struct.new(:version, :ds, :statsd, :listener, :admin) do
-    class << self
-      def from_hash(h)
-        ds = symbolize_keys(h.fetch('ds'))
-        convert_tls_option!(ds.fetch(:cluster))
-
-        new(
-          h.fetch('version'),
-          ds,
-          convert_tls_option!(symbolize_keys(h.fetch('statsd', {}))),
-          symbolize_keys(h.fetch('listener')),
-          symbolize_keys(h.fetch('admin'))
-        )
-      end
-
-      private
-
-      def convert_tls_option!(cluster)
-        tls = cluster.delete(:tls)
-        cluster[:ssl_context] = {} if tls
-        cluster
-      end
-
-      def symbolize_keys(hash)
-        new = hash.map do |k, v|
-          [
-            k.to_sym,
-            v.is_a?(Hash) ? symbolize_keys(v) : v
-          ]
-        end
-        new.to_h
-      end
-    end
-  end
-end