hako 0.20.3 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba8b0ebf80ac149aacdc2fdda96cae6d5bdb37d3
-  data.tar.gz: adc2f83e9bd04929c48a530861c596bbf9d1bf50
+  metadata.gz: 7c6e02b9939541f56711b9225a74381d7473376b
+  data.tar.gz: a43209df25791df32037b123f21255c8f4ed98d5
 SHA512:
-  metadata.gz: 2b4dfda736f5618b1ac8ef9f56f411cfb464ec8ac2bbe0e306080b480f6d2f86357074e31b37d564245a910e6ae06fbff58947c5ff898d7a8931b0570d27450c
-  data.tar.gz: 52c931cf43b541ab9390c910dde191561b63b695ba30275667ace0d65a91b20d041e74d787d58976415b0ece28c8fc2f9acd06438eae506f9e07344b6915374f
+  metadata.gz: a727aaff0caded43aeda3477d6f2819c44d9285e7f296c4d1eb4738ffab649326e966377c59c7cf1d1e932fe480465663387e1e14191cc5da8c652e223130a73
+  data.tar.gz: affac360aeef705b05799af8dbd66a9af5b093ab1f8847227c886bed2e52dce52bd02900c84d6c91f49b346b62dfdfda835b1d37c569e32aecacc8f605ba7d71

data/lib/hako/schedulers/ecs_definition_comparator.rb

@@ -1,75 +1,76 @@
 # frozen_string_literal: true
+require 'hako/schema'
+
 module Hako
   module Schedulers
     class EcsDefinitionComparator
       # @param [Hash] expected_container
       def initialize(expected_container)
         @expected_container = expected_container
+        @schema = definition_schema
       end
 
-      CONTAINER_KEYS = %i[image cpu memory memory_reservation links docker_labels user log_configuration].freeze
-      PORT_MAPPING_KEYS = %i[container_port host_port protocol].freeze
-      ENVIRONMENT_KEYS = %i[name value].freeze
-      MOUNT_POINT_KEYS = %i[source_volume container_path read_only].freeze
-      VOLUMES_FROM_KEYS = %i[source_container read_only].freeze
-
       # @param [Aws::ECS::Types::ContainerDefinition] actual_container
       # @return [Boolean]
       def different?(actual_container)
-        unless actual_container
-          return true
-        end
-        actual_container = actual_container.to_h
-        if different_members?(@expected_container, actual_container, CONTAINER_KEYS)
-          return true
-        end
-        if different_array?(@expected_container, actual_container, :port_mappings, PORT_MAPPING_KEYS)
-          return true
-        end
-        if different_array?(@expected_container, actual_container, :environment, ENVIRONMENT_KEYS)
-          return true
-        end
-        if different_array?(@expected_container, actual_container, :mount_points, MOUNT_POINT_KEYS)
-          return true
-        end
-        if different_array?(@expected_container, actual_container, :volumes_from, VOLUMES_FROM_KEYS)
-          return true
+        !@schema.same?(actual_container.to_h, @expected_container)
+      end
+
+      private
+
+      def definition_schema
+        Schema::Structure.new.tap do |struct|
+          struct.member(:image, Schema::String.new)
+          struct.member(:cpu, Schema::Integer.new)
+          struct.member(:memory, Schema::Integer.new)
+          struct.member(:memory_reservation, Schema::Nullable.new(Schema::Integer.new))
+          struct.member(:links, Schema::UnorderedArray.new(Schema::String.new))
+          struct.member(:port_mappings, Schema::UnorderedArray.new(port_mapping_schema))
+          struct.member(:environment, Schema::UnorderedArray.new(environment_schema))
+          struct.member(:docker_labels, Schema::Table.new(Schema::String.new, Schema::String.new))
+          struct.member(:mount_points, Schema::UnorderedArray.new(mount_point_schema))
+          struct.member(:command, Schema::Nullable.new(Schema::OrderedArray.new(Schema::String.new)))
+          struct.member(:volumes_from, Schema::UnorderedArray.new(volumes_from_schema))
+          struct.member(:user, Schema::Nullable.new(Schema::String.new))
+          struct.member(:log_configuration, Schema::Nullable.new(log_configuration_schema))
         end
+      end
 
-        false
+      def port_mapping_schema
+        Schema::Structure.new.tap do |struct|
+          struct.member(:container_port, Schema::Integer.new)
+          struct.member(:host_port, Schema::Integer.new)
+          struct.member(:protocol, Schema::String.new)
+        end
       end
 
-      private
+      def environment_schema
+        Schema::Structure.new.tap do |struct|
+          struct.member(:name, Schema::String.new)
+          struct.member(:value, Schema::String.new)
+        end
+      end
 
-      # @param [Hash<String, Object>] expected
-      # @param [Hash<String, Object>] actual
-      # @param [Array<String>] keys
-      # @return [Boolean]
-      def different_members?(expected, actual, keys)
-        keys.each do |key|
-          if actual[key] != expected[key]
-            return true
-          end
+      def mount_point_schema
+        Schema::Structure.new.tap do |struct|
+          struct.member(:source_volume, Schema::String.new)
+          struct.member(:container_path, Schema::String.new)
+          struct.member(:read_only, Schema::Boolean.new)
         end
-        false
       end
 
-      # @param [Hash<String, Array<Object>>] expected
-      # @param [Hash<String, Array<Object>>] actual
-      # @param [Array<String>] keys
-      # @return [Boolean]
-      def different_array?(expected, actual, key, keys)
-        if expected[key].size != actual[key].size
-          return true
+      def volumes_from_schema
+        Schema::Structure.new.tap do |struct|
+          struct.member(:source_container, Schema::String.new)
+          struct.member(:read_only, Schema::Boolean.new)
         end
-        sorted_expected = expected[key].sort_by { |e| keys.map { |k| e[k] }.join('') }
-        sorted_actual = actual[key].sort_by { |a| keys.map { |k| a[k] }.join('') }
-        sorted_expected.zip(sorted_actual) do |e, a|
-          if different_members?(e, a, keys)
-            return true
-          end
+      end
+
+      def log_configuration_schema
+        Schema::Structure.new.tap do |struct|
+          struct.member(:log_driver, Schema::String.new)
+          struct.member(:options, Schema::Table.new(Schema::String.new, Schema::String.new))
         end
-        false
       end
     end
   end

data/lib/hako/schema.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require 'hako/schema/boolean'
+require 'hako/schema/integer'
+require 'hako/schema/nullable'
+require 'hako/schema/ordered_array'
+require 'hako/schema/string'
+require 'hako/schema/structure'
+require 'hako/schema/table'
+require 'hako/schema/unordered_array'

data/lib/hako/schema/boolean.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Hako
+  module Schema
+    class Boolean
+      def valid?(object)
+        object.is_a?(FalseClass) || object.is_a?(TrueClass)
+      end
+
+      def same?(x, y)
+        x == y
+      end
+    end
+  end
+end

data/lib/hako/schema/integer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Hako
+  module Schema
+    class Integer
+      def valid?(object)
+        object.is_a?(::Integer)
+      end
+
+      def same?(x, y)
+        x == y
+      end
+    end
+  end
+end

data/lib/hako/schema/nullable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Hako
+  module Schema
+    class Nullable
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def valid?(object)
+        object.nil? || @schema.valid?(object)
+      end
+
+      def same?(x, y)
+        if x.nil? && y.nil?
+          true
+        elsif x.nil? || y.nil?
+          false
+        else
+          @schema.same?(x, y)
+        end
+      end
+    end
+  end
+end

data/lib/hako/schema/ordered_array.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Hako
+  module Schema
+    class OrderedArray
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def valid?(object)
+        object.is_a?(Array) && object.all? { |e| @schema.valid?(e) }
+      end
+
+      def same?(xs, ys)
+        if xs.size != ys.size
+          return false
+        end
+
+        xs.zip(ys) do |x, y|
+          unless @schema.same?(x, y)
+            return false
+          end
+        end
+        true
+      end
+    end
+  end
+end

data/lib/hako/schema/string.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Hako
+  module Schema
+    class String
+      def valid?(object)
+        object.is_a?(::String)
+      end
+
+      def same?(x, y)
+        x == y
+      end
+    end
+  end
+end

data/lib/hako/schema/structure.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Hako
+  module Schema
+    class Structure
+      def initialize
+        @members = {}
+      end
+
+      def valid?(object)
+        unless object.is_a?(::Hash)
+          return false
+        end
+        @members.each do |key, val_schema|
+          unless val_schema.valid?(object[key])
+            return false
+          end
+        end
+        true
+      end
+
+      def same?(x, y)
+        @members.each do |key, val_schema|
+          unless val_schema.same?(x[key], y[key])
+            return false
+          end
+        end
+        true
+      end
+
+      def member(key, schema)
+        @members[key] = schema
+      end
+    end
+  end
+end

data/lib/hako/schema/table.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Hako
+  module Schema
+    class Table
+      def initialize(key_schema, val_schema)
+        @key_schema = key_schema
+        @val_schema = val_schema
+      end
+
+      def valid?(object)
+        object.is_a?(::Hash) && object.all? { |k, v| @key_schema.valid?(k) && @val_schema.valid?(v) }
+      end
+
+      def same?(xs, ys)
+        if xs.size != ys.size
+          return false
+        end
+
+        t = xs.dup
+        ys.each do |yk, yv|
+          xk, = xs.find { |k, v| @key_schema.same?(k, yk) && @val_schema.same?(v, yv) }
+          if xk
+            t.delete(xk)
+          else
+            return false
+          end
+        end
+
+        t.empty?
+      end
+    end
+  end
+end

data/lib/hako/schema/unordered_array.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Hako
+  module Schema
+    class UnorderedArray
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def valid?(object)
+        object.is_a?(Array) && object.all? { |e| @schema.valid?(e) }
+      end
+
+      def same?(xs, ys)
+        if xs.size != ys.size
+          return false
+        end
+
+        t = xs.dup
+        ys.each do |y|
+          i = t.index { |x| @schema.same?(x, y) }
+          if i
+            t.delete_at(i)
+          else
+            return false
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/hako/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Hako
-  VERSION = '0.20.3'
+  VERSION = '0.21.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hako
 version: !ruby/object:Gem::Version
-  version: 0.20.3
+  version: 0.21.0
 platform: ruby
 authors:
 - Kohei Suzuki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-30 00:00:00.000000000 Z
+date: 2016-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -144,6 +144,15 @@ files:
 - lib/hako/schedulers/ecs_definition_comparator.rb
 - lib/hako/schedulers/ecs_elb.rb
 - lib/hako/schedulers/ecs_elb_v2.rb
+- lib/hako/schema.rb
+- lib/hako/schema/boolean.rb
+- lib/hako/schema/integer.rb
+- lib/hako/schema/nullable.rb
+- lib/hako/schema/ordered_array.rb
+- lib/hako/schema/string.rb
+- lib/hako/schema/structure.rb
+- lib/hako/schema/table.rb
+- lib/hako/schema/unordered_array.rb
 - lib/hako/script.rb
 - lib/hako/scripts.rb
 - lib/hako/scripts/nginx_front.rb