vcloud-edge_gateway 0.2.2 → 0.2.3

data/lib/vcloud/edge_gateway.rb

@@ -3,9 +3,6 @@ require 'vcloud/edge_gateway/version'
 require 'vcloud/core'
 require 'vcloud/fog'
 
-require 'vcloud/config_loader'
-require 'vcloud/config_validator'
-
 require 'vcloud/edge_gateway_services'
 
 require 'vcloud/schema/nat_service'
@@ -18,6 +15,8 @@ require 'vcloud/edge_gateway/configuration_generator/firewall_service'
 require 'vcloud/edge_gateway/configuration_generator/nat_service'
 require 'vcloud/edge_gateway/configuration_generator/load_balancer_service'
 require 'vcloud/edge_gateway/configuration_differ'
+require 'vcloud/edge_gateway/nat_configuration_differ'
+require 'vcloud/edge_gateway/firewall_configuration_differ'
 require 'vcloud/edge_gateway/load_balancer_configuration_differ'
 require 'vcloud/edge_gateway/edge_gateway_configuration'
 

data/lib/vcloud/edge_gateway/configuration_differ.rb

@@ -8,7 +8,19 @@ module Vcloud
         end
 
         def diff
-          ( @local == @remote ) ? [] : HashDiff.diff(@local, @remote)
+          ( stripped_local_config == stripped_remote_config ) ? [] : HashDiff.diff(stripped_local_config, stripped_remote_config)
+        end
+
+        def stripped_local_config
+          strip_fields_for_differ_to_ignore(@local) unless @local.nil?
+        end
+
+        def stripped_remote_config
+          strip_fields_for_differ_to_ignore(@remote) unless @remote.nil?
+        end
+
+        def strip_fields_for_differ_to_ignore(config)
+          config
         end
 
     end

data/lib/vcloud/edge_gateway/configuration_generator/nat_service.rb

@@ -19,16 +19,16 @@ module Vcloud
 
         def populate_nat_rules
           rules = @input_config[:nat_rules]
-            i = ID_RANGES::NAT_SERVICE[:min]
-            rules.collect do |rule|
-              new_rule = {}
-              new_rule[:Id] = rule.key?(:id) ? rule[:id] : i.to_s
-              new_rule[:IsEnabled] = rule.key?(:enabled) ? rule[:enabled].to_s : 'true'
-              new_rule[:RuleType] = rule[:rule_type]
-              gateway_nat_rule = populate_gateway_nat_rule(rule)
-              new_rule[:GatewayNatRule] = gateway_nat_rule
-              i += 1
-              new_rule
+          i = ID_RANGES::NAT_SERVICE[:min]
+          rules.collect do |rule|
+            new_rule = {}
+            new_rule[:Id] = rule.key?(:id) ? rule[:id] : i.to_s
+            new_rule[:IsEnabled] = rule.key?(:enabled) ? rule[:enabled].to_s : 'true'
+            new_rule[:RuleType] = rule[:rule_type]
+            gateway_nat_rule = populate_gateway_nat_rule(rule)
+            new_rule[:GatewayNatRule] = gateway_nat_rule
+            i += 1
+            new_rule
           end
         end
 

data/lib/vcloud/edge_gateway/edge_gateway_configuration.rb

@@ -15,7 +15,7 @@ module Vcloud
 
         firewall_service_config = EdgeGateway::ConfigurationGenerator::FirewallService.new.generate_fog_config(@local_config[:firewall_service])
         unless firewall_service_config.nil?
-          differ = EdgeGateway::ConfigurationDiffer.new(firewall_service_config, @remote_config[:FirewallService])
+          differ = EdgeGateway::FirewallConfigurationDiffer.new(firewall_service_config, @remote_config[:FirewallService])
           unless differ.diff.empty?
             @config[:FirewallService] = firewall_service_config
             @update_required = true
@@ -28,7 +28,7 @@ module Vcloud
         ).generate_fog_config
 
         unless nat_service_config.nil?
-          differ = EdgeGateway::ConfigurationDiffer.new(nat_service_config, @remote_config[:NatService])
+          differ = EdgeGateway::NatConfigurationDiffer.new(nat_service_config, @remote_config[:NatService])
           unless differ.diff.empty?
             @config[:NatService] = nat_service_config
             @update_required = true

data/lib/vcloud/edge_gateway/firewall_configuration_differ.rb

@@ -0,0 +1,18 @@
+module Vcloud
+  module EdgeGateway
+    class FirewallConfigurationDiffer < ConfigurationDiffer
+
+        def strip_fields_for_differ_to_ignore(config)
+          deep_cloned_config = Marshal.load( Marshal.dump(config) )
+          if deep_cloned_config.key?(:FirewallRule)
+            deep_cloned_config[:FirewallRule].each do |firewall_rule|
+              firewall_rule.delete(:Id)
+            end
+          end
+          deep_cloned_config
+        end
+
+    end
+  end
+
+end

data/lib/vcloud/edge_gateway/load_balancer_configuration_differ.rb

@@ -1,19 +1,9 @@
 module Vcloud
   module EdgeGateway
-    class LoadBalancerConfigurationDiffer
+    class LoadBalancerConfigurationDiffer < ConfigurationDiffer
 
-        def initialize local, remote
-          @local = local
-          @remote = remote
-        end
-
-        def diff
-          ( @local == stripped_remote_config ) ? [] : HashDiff.diff(@local, stripped_remote_config)
-        end
-
-        def stripped_remote_config
-          return nil if @remote.nil?
-          deep_cloned_remote_config = Marshal.load( Marshal.dump(@remote) )
+        def strip_fields_for_differ_to_ignore(config)
+          deep_cloned_remote_config = Marshal.load( Marshal.dump(config) )
           if deep_cloned_remote_config.key?(:Pool)
             deep_cloned_remote_config[:Pool].each do |pool_entry|
               pool_entry.delete(:Operational)

data/lib/vcloud/edge_gateway/nat_configuration_differ.rb

@@ -0,0 +1,18 @@
+module Vcloud
+  module EdgeGateway
+    class NatConfigurationDiffer < ConfigurationDiffer
+
+        def strip_fields_for_differ_to_ignore(config)
+          deep_cloned_config = Marshal.load( Marshal.dump(config) )
+          if deep_cloned_config.key?(:NatRule)
+            deep_cloned_config[:NatRule].each do |nat_rule|
+              nat_rule.delete(:Id)
+            end
+          end
+          deep_cloned_config
+        end
+
+    end
+  end
+
+end

data/lib/vcloud/edge_gateway/version.rb

@@ -1,6 +1,6 @@
 module Vcloud
   module EdgeGateway
-    VERSION = '0.2.2'
+    VERSION = '0.2.3'
   end
 end
 

data/lib/vcloud/edge_gateway_services.rb

@@ -4,7 +4,7 @@ module Vcloud
   class EdgeGatewayServices
 
     def initialize
-      @config_loader = Vcloud::ConfigLoader.new
+      @config_loader = Vcloud::Core::ConfigLoader.new
     end
 
     def update(config_file = nil)

data/spec/integration/edge_gateway/edge_gateway_services_spec.rb

@@ -49,13 +49,6 @@ module Vcloud
 
       context "Check update is functional" do
 
-        before(:all) do
-          local_config = ConfigLoader.new.load_config(
-            @initial_config_file,
-            Vcloud::Schema::EDGE_GATEWAY_SERVICES
-          )
-        end
-
         it "should be starting our tests from an empty EdgeGateway" do
           remote_vcloud_config = @edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration]
           expect(remote_vcloud_config[:FirewallService][:FirewallRule].empty?).to be_true
@@ -65,7 +58,7 @@ module Vcloud
         end
 
         it "should only create one edgeGateway update task when updating the configuration" do
-          start_time = DateTime.now()
+          start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
           EdgeGatewayServices.new.update(@initial_config_file)
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
@@ -81,7 +74,7 @@ module Vcloud
         end
 
         it "should not update the EdgeGateway again if the config hasn't changed" do
-          start_time = DateTime.now()
+          start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
           EdgeGatewayServices.new.update(@initial_config_file)
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
@@ -89,7 +82,7 @@ module Vcloud
         end
 
         it "should only create one additional edgeGateway update task when adding the LoadBalancer config" do
-          start_time = DateTime.now()
+          start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
           EdgeGatewayServices.new.update(@adding_load_balancer_config_file)
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
@@ -97,7 +90,7 @@ module Vcloud
         end
 
         it "should not update the EdgeGateway again if we reapply the 'adding load balancer' config" do
-          start_time = DateTime.now()
+          start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
           EdgeGatewayServices.new.update(@adding_load_balancer_config_file)
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
@@ -147,12 +140,13 @@ module Vcloud
 
       def get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(timestamp)
         vcloud_time = timestamp.strftime('%FT%T.000Z')
-        q = Query.new('task',
+        q = QueryRunner.new
+
+        q.run('task',
           :filter =>
             "name==networkConfigureEdgeGatewayServices;objectName==#{@edge_name};startDate=ge=#{vcloud_time}",
           :sortDesc => 'startDate',
         )
-        q.get_all_results
       end
 
     end

data/spec/integration/edge_gateway/firewall_service_spec.rb

@@ -41,20 +41,10 @@ module Vcloud
         @firewall_service = {}
       end
 
-      context "Check input schema checking is working" do
-
-        it "should raise exception if input yaml does not match with schema" do
-          config_yaml = File.expand_path('data/incorrect_firewall_config.yaml', File.dirname(__FILE__))
-          expect(Vcloud::EdgeGateway.logger).to receive(:fatal)
-          expect { EdgeGatewayServices.new.update(config_yaml) }.to raise_error('Supplied configuration does not match supplied schema')
-        end
-
-      end
-
       context "Check update is functional" do
 
         before(:all) do
-          local_config = ConfigLoader.new.load_config(@initial_firewall_config_file, Vcloud::Schema::EDGE_GATEWAY_SERVICES)
+          local_config = Core::ConfigLoader.new.load_config(@initial_firewall_config_file, Vcloud::Schema::EDGE_GATEWAY_SERVICES)
           @local_vcloud_config  = EdgeGateway::ConfigurationGenerator::FirewallService.new.generate_fog_config(local_config[:firewall_service])
         end
 
@@ -94,7 +84,7 @@ module Vcloud
         it "should highlight a difference if local firewall config has been updated" do
           input_config_file = generate_input_config_file('firewall_config_updated_rule.yaml.erb', edge_gateway_erb_input)
 
-          local_config = ConfigLoader.new.load_config(input_config_file, Vcloud::Schema::EDGE_GATEWAY_SERVICES)
+          local_config = Core::ConfigLoader.new.load_config(input_config_file, Vcloud::Schema::EDGE_GATEWAY_SERVICES)
           local_firewall_config = EdgeGateway::ConfigurationGenerator::FirewallService.new.generate_fog_config(local_config[:firewall_service])
 
           edge_gateway = Core::EdgeGateway.get_by_name local_config[:gateway]

data/spec/integration/edge_gateway/load_balancer_service_spec.rb

@@ -44,7 +44,7 @@ module Vcloud
       context "Check update is functional" do
 
         before(:all) do
-          local_config = ConfigLoader.new.load_config(
+          local_config = Core::ConfigLoader.new.load_config(
             @initial_load_balancer_config_file,
             Vcloud::Schema::EDGE_GATEWAY_SERVICES
           )
@@ -61,7 +61,7 @@ module Vcloud
         end
 
         it "should only make one EdgeGateway update task, to minimise EdgeGateway reload events" do
-          start_time = DateTime.now()
+          start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
           EdgeGatewayServices.new.update(@initial_load_balancer_config_file)
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
@@ -190,12 +190,12 @@ module Vcloud
 
       def get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(timestamp)
         vcloud_time = timestamp.strftime('%FT%T.000Z')
-        q = Query.new('task',
+        q = QueryRunner.new
+        q.run('task',
           :filter =>
             "name==networkConfigureEdgeGatewayServices;objectName==#{@edge_name};startDate=ge=#{vcloud_time}",
           :sortDesc => 'startDate',
         )
-        q.get_all_results
       end
 
     end

data/spec/integration/edge_gateway/nat_service_spec.rb

@@ -49,7 +49,7 @@ module Vcloud
       context "Check update is functional" do
 
         before(:all) do
-          local_config = ConfigLoader.new.load_config(
+          local_config = Core::ConfigLoader.new.load_config(
             @initial_nat_config_file, Vcloud::Schema::EDGE_GATEWAY_SERVICES
           )
           @local_vcloud_config  = EdgeGateway::ConfigurationGenerator::NatService.new(
@@ -64,7 +64,7 @@ module Vcloud
         end
 
         it "should only make one EdgeGateway update task, to minimise EdgeGateway reload events" do
-          start_time = DateTime.now()
+          start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
           EdgeGatewayServices.new.update(@initial_nat_config_file)
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
@@ -200,11 +200,11 @@ module Vcloud
 
       def get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(timestamp)
         vcloud_time = timestamp.strftime('%FT%T.000Z')
-        q = Query.new('task',
+        q = QueryRunner.new
+        q.run('task',
           :filter => "name==networkConfigureEdgeGatewayServices;objectName==#{@edge_name};startDate=ge=#{vcloud_time}",
           :sortDesc => 'startDate',
         )
-        q.get_all_results
       end
 
     end

data/spec/spec_helper.rb

@@ -18,9 +18,9 @@ require 'vcloud/edge_gateway'
 SimpleCov.at_exit do
   SimpleCov.result.format!
   # do not change the coverage percentage, instead add more unit tests to fix coverage failures.
-  if SimpleCov.result.covered_percent < 60
+  if SimpleCov.result.covered_percent < 90
     print "ERROR::BAD_COVERAGE\n"
-    print "Coverage is less than acceptable limit(71%). Please add more tests to improve the coverage"
+    print "Coverage is less than acceptable limit(90%). Please add more tests to improve the coverage\n"
     exit(1)
   end
 end

data/spec/vcloud/edge_gateway/configuration_differ_shared_examples.rb

@@ -0,0 +1,132 @@
+module Vcloud
+  module EdgeGateway
+
+    shared_examples "a configuration differ" do
+
+      let(:config_differ) { described_class }
+
+      it 'should return an empty array for two identical empty Hashes' do
+        local = { }
+        remote = { }
+        output = []
+        differ = config_differ.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should return an empty array for two identical simple Hashes' do
+        local = { testing: 'testing', one: 1, two: 'two', three: "3" }
+        remote = { testing: 'testing', one: 1, two: 'two', three: "3" }
+        output =  []
+        differ = config_differ.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should return an empty array for two identical deep Hashes' do
+        local = { testing: 'testing', one: 1, deep: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
+        ]}
+        remote = { testing: 'testing', one: 1, deep: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
+        ]}
+        output = []
+        differ = config_differ.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should highlight a simple addition' do
+        local = { foo: '1' }
+        remote = { foo: '1', bar: '2' }
+        output = [["+", "bar", "2"]]
+        differ = config_differ.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should highlight a simple subtraction' do
+        local = { foo: '1', bar: '2' }
+        remote = { foo: '1' }
+        output = [["-", "bar", "2"]]
+        differ = config_differ.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should highlight a deep addition' do
+        local = { testing: 'testing', one: 1, deep: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
+        ]}
+        remote = { testing: 'testing', one: 1, deep: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5, 6 ] },
+          { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
+        ]}
+        output = [["+", "deep[0].deeper[5]", 6]]
+        differ = config_differ.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should highlight a deep subtraction' do
+        local = { testing: 'testing', one: 1, deep: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
+        ]}
+        remote = { testing: 'testing', one: 1, deep: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 6, 5, 3, 2 ] },
+        ]}
+        output =  [["-", "deep[1].deeper[2]", 4]]
+        differ = config_differ.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should return an empty array when hash params are reordered' do
+        local = { one: 1, testing: 'testing', deep: [
+          { deeper: [ 1, 2, 3, 4, 5 ], foo: 'bar' },
+          { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
+        ]}
+        remote = { testing: 'testing', one: 1, deep: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
+        ]}
+        output = []
+        differ = config_differ.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should highlight when array elements are reordered' do
+        local = { testing: 'testing', one: 1, deep: [
+          { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+        ]}
+        remote = { testing: 'testing', one: 1, deep: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
+        ]}
+        output = [
+          ["+", "deep[0]", {:foo=>"bar", :deeper=>[1, 2, 3, 4, 5]}],
+          ["-", "deep[2]", {:foo=>"bar", :deeper=>[1, 2, 3, 4, 5]}],
+        ]
+        differ = config_differ.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should highlight when deep array elements are reordered' do
+        local = { testing: 'testing', one: 1, deep: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 5, 6, 4, 3, 2 ] },
+        ]}
+        remote = { testing: 'testing', one: 1, deep: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
+        ]}
+        output =  [
+          ["+", "deep[1].deeper[0]", 6],
+          ["-", "deep[1].deeper[2]", 6]
+        ]
+        differ = config_differ.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+   end
+
+  end
+end