vcloud-edge_gateway 0.0.2 → 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+## 0.1.0 (2014-02-20)
+
+Features:
+
+  - Add LoadBalancerService configuration management
+
+## 0.0.2 (2014-02-14)
+
+  - First release of gem
+  - Supports configuration of Firewall Service and Nat Service
+

data/jenkins_integration_tests.sh

@@ -0,0 +1,8 @@
+#!/bin/bash -x
+set -e
+bundle install --path "${HOME}/bundles/${JOB_NAME}"
+
+./scripts/generate_fog_conf_file.sh
+export FOG_RC=fog_integration_test.config
+bundle exec rake integration
+rm fog_integration_test.config

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

@@ -197,13 +197,7 @@ module Vcloud
           vcloud_pool_healthcheck_entry = {
             Mode: default_mode,
           }
-          if protocol == :http
-            vcloud_pool_healthcheck_entry[:Uri] = ''
-          elsif ( protocol == :https ) &&
-                  input_pool_healthcheck_entry &&
-                  ( input_pool_healthcheck_entry[:protocol] == 'TCP' )
-            vcloud_pool_healthcheck_entry[:Uri] = ''
-          end
+          vcloud_pool_healthcheck_entry[:Uri] = ''
           vcloud_pool_healthcheck_entry[:HealthThreshold] = '2'
           vcloud_pool_healthcheck_entry[:UnhealthThreshold] = '3'
           vcloud_pool_healthcheck_entry[:Interval] = '5'

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

@@ -3,10 +3,9 @@ module Vcloud
     module ConfigurationGenerator
 
       class NatService
-        def initialize edge_gateway, input_config
-          @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(edge_gateway)
+        def initialize input_config, edge_gateway_interfaces
           @input_config = input_config
-          @interfaces_by_id = {}
+          @edge_gateway_interfaces = edge_gateway_interfaces
         end
 
         def generate_fog_config
@@ -35,9 +34,12 @@ module Vcloud
 
         def populate_gateway_nat_rule(rule)
           raise "Must supply a :network_id parameter" unless net_id = rule[:network_id]
-          @interfaces_by_id[net_id] ||= @edge_gateway.vcloud_gateway_interface_by_id(net_id)
-          raise "unable to find gateway network interface with id #{net_id}" unless @interfaces_by_id[net_id]
-          gateway_nat_rule = {:Interface => @interfaces_by_id[net_id][:Network]}
+          edge_gw_interface = @edge_gateway_interfaces.find do |interface|
+            interface.network_id == net_id
+          end
+          raise "unable to find gateway network interface with id #{net_id}" unless edge_gw_interface
+          gateway_nat_rule = {}
+          gateway_nat_rule[:Interface] = populate_nat_interface(edge_gw_interface)
           gateway_nat_rule[:OriginalIp] = rule[:original_ip]
           gateway_nat_rule[:TranslatedIp] = rule[:translated_ip]
           gateway_nat_rule[:OriginalPort] = rule[:original_port] if rule.key?(:original_port)
@@ -48,6 +50,14 @@ module Vcloud
           gateway_nat_rule
         end
 
+        def populate_nat_interface(edge_interface)
+          vcloud_interface = {}
+          vcloud_interface[:type] = 'application/vnd.vmware.admin.network+xml'
+          vcloud_interface[:name] = edge_interface.network_name
+          vcloud_interface[:href] = edge_interface.network_href
+          vcloud_interface
+        end
+
       end
     end
   end

data/lib/vcloud/edge_gateway/edge_gateway_configuration.rb

@@ -2,37 +2,62 @@ module Vcloud
   module EdgeGateway
     class EdgeGatewayConfiguration
 
-      def initialize(local_config)
+      def initialize(local_config, remote_config, edge_gateway_interfaces)
         @local_config = local_config
+        @remote_config = remote_config
+        @edge_gateway_interfaces = edge_gateway_interfaces
         @config = { }
+        @update_required = nil
       end
 
-      def update_required?(remote_config)
-        update_required = false
+      def update_required?
+        @update_required = false
 
         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::ConfigurationDiffer.new(firewall_service_config, @remote_config[:FirewallService])
           unless differ.diff.empty?
             @config[:FirewallService] = firewall_service_config
-            update_required = true
+            @update_required = true
           end
         end
 
-        nat_service_config = EdgeGateway::ConfigurationGenerator::NatService.new(@local_config[:gateway], @local_config[:nat_service]).generate_fog_config
+        nat_service_config = EdgeGateway::ConfigurationGenerator::NatService.new(
+          @local_config[:nat_service],
+          @edge_gateway_interfaces
+        ).generate_fog_config
 
         unless nat_service_config.nil?
-          differ = EdgeGateway::ConfigurationDiffer.new(nat_service_config, remote_config[:NatService])
+          differ = EdgeGateway::ConfigurationDiffer.new(nat_service_config, @remote_config[:NatService])
           unless differ.diff.empty?
             @config[:NatService] = nat_service_config
-            update_required = true
+            @update_required = true
           end
         end
 
-        update_required
+        load_balancer_service_config =
+          EdgeGateway::ConfigurationGenerator::LoadBalancerService.new(
+            @local_config[:gateway]
+          ).generate_fog_config(@local_config[:load_balancer_service])
+
+        unless load_balancer_service_config.nil?
+          differ = EdgeGateway::LoadBalancerConfigurationDiffer.new(
+                     load_balancer_service_config,
+                     @remote_config[:LoadBalancerService]
+                   )
+          unless differ.diff.empty?
+            @config[:LoadBalancerService] = load_balancer_service_config
+            @update_required = true
+          end
+        end
+
+        @update_required
       end
 
       def config
+        if @update_required.nil?
+          update_required?
+        end
         @config
       end
 

data/lib/vcloud/edge_gateway/load_balancer_configuration_differ.rb

@@ -0,0 +1,28 @@
+module Vcloud
+  module EdgeGateway
+    class LoadBalancerConfigurationDiffer
+
+        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) )
+          if deep_cloned_remote_config.key?(:Pool)
+            deep_cloned_remote_config[:Pool].each do |pool_entry|
+              pool_entry.delete(:Operational)
+            end
+          end
+          deep_cloned_remote_config
+        end
+
+    end
+  end
+
+end

data/lib/vcloud/edge_gateway/version.rb

@@ -1,6 +1,6 @@
 module Vcloud
   module EdgeGateway
-    VERSION = '0.0.2'
+    VERSION = '0.1.0'
   end
 end
 

data/lib/vcloud/edge_gateway.rb

@@ -18,6 +18,7 @@ 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/load_balancer_configuration_differ'
 require 'vcloud/edge_gateway/edge_gateway_configuration'
 
 

data/lib/vcloud/edge_gateway_services.rb

@@ -8,14 +8,19 @@ module Vcloud
     end
 
     def update(config_file = nil)
-      config = @config_loader.load_config(config_file, Vcloud::Schema::EDGE_GATEWAY_SERVICES)
+      local_config = @config_loader.load_config(config_file, Vcloud::Schema::EDGE_GATEWAY_SERVICES)
 
-      edge_gateway = Core::EdgeGateway.get_by_name config[:gateway]
+      edge_gateway = Core::EdgeGateway.get_by_name local_config[:gateway]
       remote_config = edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration]
+      edge_gateway_interface_list = edge_gateway.interfaces
 
-      proposed_config = EdgeGateway::EdgeGatewayConfiguration.new(config)
+      proposed_config = EdgeGateway::EdgeGatewayConfiguration.new(
+        local_config,
+        remote_config,
+        edge_gateway_interface_list
+      )
 
-      if proposed_config.update_required?(remote_config)
+      if proposed_config.update_required?
         edge_gateway.update_configuration proposed_config.config
       else
         Vcloud::EdgeGateway.logger.info("EdgeGatewayServices.update: Configuration is already up to date. Skipping.")

data/lib/vcloud/schema/edge_gateway.rb

@@ -7,7 +7,8 @@ module Vcloud
         internals: {
             gateway: { type: 'string' },
             firewall_service: FIREWALL_SERVICE,
-            nat_service: NAT_SERVICE
+            nat_service: NAT_SERVICE,
+            load_balancer_service: LOAD_BALANCER_SERVICE,
         }
     }
 

data/lib/vcloud/schema/load_balancer_service.rb

@@ -109,17 +109,18 @@ module Vcloud
     LOAD_BALANCER_SERVICE = {
       type: Hash,
       allowed_empty: true,
+      required: false,
       internals: {
         enabled: { type: 'boolean', required: false },
         pools: {
           type: Array,
-          required: true,
+          required: false,
           allowed_empty: true,
           each_element_is: LOAD_BALANCER_POOL_ENTRY,
         },
         virtual_servers: {
           type: Array,
-          required: true,
+          required: false,
           allowed_empty: true,
           each_element_is: LOAD_BALANCER_VIRTUAL_SERVER_ENTRY,
         },

data/spec/erb_helper.rb

@@ -2,7 +2,7 @@ class ErbHelper
   def self.convert_erb_template_to_yaml test_namespace, input_erb_config
     input_erb_config = input_erb_config
     e = ERB.new(File.open(input_erb_config).read)
-    output_yaml_config = File.join(File.dirname(input_erb_config), "output_#{Time.now.strftime('%s')}.yaml")
+    output_yaml_config = File.join(File.dirname(input_erb_config), "output_#{Time.now.strftime('%s.%6N')}.yaml")
     File.open(output_yaml_config, 'w') { |f|
       f.write e.result(OpenStruct.new(test_namespace).instance_eval { binding })
     }

data/spec/integration/edge_gateway/data/load_balancer_config.yaml.erb

@@ -0,0 +1,24 @@
+---
+gateway: <%= edge_gateway_name %>
+load_balancer_service:
+  enabled: true
+  pools:
+  - name: 'integration-test-pool-1'
+    description: 'A pool'
+    service:
+      http:
+        enabled: true
+        port: 8080
+        algorithm: 'ROUND_ROBIN'
+    members:
+    - ip_address: 192.0.2.55
+    - ip_address: 192.0.2.56
+  virtual_servers:
+  - name: 'integration-test-vs-1'
+    description: 'A virtual server'
+    ip_address: <%= edge_gateway_ext_network_ip %>
+    network: <%= edge_gateway_ext_network_id %>
+    pool: 'integration-test-pool-1'
+    service_profiles:
+      http:
+        port: 8080

data/spec/integration/edge_gateway/data/load_balancer_empty.yaml.erb

@@ -0,0 +1,4 @@
+---
+gateway: <%= edge_gateway_name %>
+load_balancer_service:
+  enabled: true

data/spec/integration/edge_gateway/data/load_balancer_single_pool.yaml.erb

@@ -0,0 +1,15 @@
+---
+gateway: <%= edge_gateway_name %>
+load_balancer_service:
+  enabled: true
+  pools:
+  - name: 'integration-test-pool-1'
+    description: 'A pool'
+    service:
+      http:
+        enabled: true
+        port: 8080
+        algorithm: 'ROUND_ROBIN'
+    members:
+    - ip_address: 192.0.2.55
+    - ip_address: 192.0.2.56

data/spec/integration/edge_gateway/data/load_balancer_single_virtual_server_invalid_pool.yaml.erb

@@ -0,0 +1,13 @@
+---
+gateway: <%= edge_gateway_name %>
+load_balancer_service:
+  enabled: true
+  virtual_servers:
+  - name: 'integration-test-vs-1'
+    description: 'A virtual server'
+    ip_address: <%= edge_gateway_ext_network_ip %>
+    network: <%= edge_gateway_ext_network_id %>
+    pool: 'unconfigured-test-pool-1'
+    service_profiles:
+      http:
+        port: 8080

data/spec/integration/edge_gateway/data/load_balancer_single_virtual_server_missing_pool.yaml.erb

@@ -0,0 +1,12 @@
+---
+gateway: <%= edge_gateway_name %>
+load_balancer_service:
+  enabled: true
+  virtual_servers:
+  - name: 'integration-test-vs-1'
+    description: 'A virtual server'
+    ip_address: <%= edge_gateway_ext_network_ip %>
+    network: <%= edge_gateway_ext_network_id %>
+    service_profiles:
+      http:
+        port: 8080

data/spec/integration/edge_gateway/data/nat_and_firewall_plus_load_balancer_config.yaml.erb

@@ -0,0 +1,54 @@
+---
+gateway: <%= edge_gateway_name %>
+nat_service:
+  nat_rules:
+  - enabled: true
+    network_id: <%= network_id %>
+    rule_type: 'DNAT'
+    translated_ip: '10.10.1.2-10.10.1.3'
+    translated_port: '3412'
+    original_ip: <%= original_ip %>
+    original_port: '3412'
+    protocol: 'tcp'
+  - enabled: true
+    network_id: <%= network_id %>
+    rule_type: 'SNAT'
+    translated_ip: <%= original_ip %>
+    original_ip: '10.10.1.2-10.10.1.3'
+firewall_service:
+  policy: drop
+  log_default_action: true
+  firewall_rules:
+  - enabled: true
+    description: 'A rule'
+    policy: allow
+    protocols: 'tcp'
+    destination_port_range: Any
+    destination_ip: 10.10.1.2
+    source_port_range: Any
+    source_ip: 192.0.2.2
+  - enabled: true
+    destination_ip: '10.10.1.3-10.10.1.5'
+    source_ip: 192.0.2.2/24
+load_balancer_service:
+  enabled: true
+  pools:
+  - name: 'integration-test-pool-1'
+    description: 'A pool'
+    service:
+      http:
+        enabled: true
+        port: 8080
+        algorithm: 'ROUND_ROBIN'
+    members:
+    - ip_address: 10.10.1.2
+    - ip_address: 10.10.1.3
+  virtual_servers:
+  - name: 'integration-test-vs-1'
+    description: 'A virtual server'
+    ip_address: <%= edge_gateway_ext_network_ip %>
+    network: <%= edge_gateway_ext_network_id %>
+    pool: 'integration-test-pool-1'
+    service_profiles:
+      http:
+        port: 8080

data/spec/integration/edge_gateway/edge_gateway_services_spec.rb

@@ -36,55 +36,72 @@ module Vcloud
 
       before(:all) do
         reset_edge_gateway
-        @initial_config_file = generate_input_config_file('nat_and_firewall_config.yaml.erb', edge_gateway_erb_input)
+        @initial_config_file = generate_input_config_file(
+          'nat_and_firewall_config.yaml.erb',
+          edge_gateway_erb_input
+        )
+        @adding_load_balancer_config_file = generate_input_config_file(
+          'nat_and_firewall_plus_load_balancer_config.yaml.erb',
+          edge_gateway_erb_input
+        )
         @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@edge_name)
       end
 
       context "Check update is functional" do
 
         before(:all) do
-          local_config = ConfigLoader.new.load_config(@initial_config_file, Vcloud::Schema::EDGE_GATEWAY_SERVICES)
+          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
           expect(remote_vcloud_config[:NatService][:NatRule].empty?).to be_true
+          expect(remote_vcloud_config[:LoadBalancerService][:Pool].empty?).to be_true
+          expect(remote_vcloud_config[:LoadBalancerService][:VirtualServer].empty?).to be_true
         end
 
-        it "should only need to make one call to Core::EdgeGateway.update_configuration to update configuration" do
-          q = Query.new('edgeGateway', :filter => "name==#{@edge_name}")
-          result = q.get_all_results
-          latest_task = result.first[:task]
-
-          expect_any_instance_of(Core::EdgeGateway).to receive(:update_configuration).exactly(1).times.and_call_original
+        it "should only create one edgeGateway update task when updating the configuration" do
+          start_time = DateTime.now()
+          task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
           EdgeGatewayServices.new.update(@initial_config_file)
-
-          test_result = q.get_all_results
-          test_latest_task = test_result.first[:task]
-
-          # confirm that a task has been run on the EdgeGateway
-          expect(latest_task == test_latest_task).to be_false
+          task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
+          expect(task_list_after_update.size - task_list_before_update.size).to be(1)
         end
 
-        it "should now have nat and firewall rules configured" do
+        it "should now have nat and firewall rules configured, no load balancer yet" do
           remote_vcloud_config = @edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration]
           expect(remote_vcloud_config[:FirewallService][:FirewallRule].empty?).to be_false
           expect(remote_vcloud_config[:NatService][:NatRule].empty?).to be_false
+          expect(remote_vcloud_config[:LoadBalancerService][:Pool].empty?).to be(true)
+          expect(remote_vcloud_config[:LoadBalancerService][:VirtualServer].empty?).to be(true)
         end
 
         it "should not update the EdgeGateway again if the config hasn't changed" do
-          q = Query.new('edgeGateway', :filter => "name==#{@edge_name}")
-          result = q.get_all_results
-          latest_task = result.first[:task]
-
+          start_time = DateTime.now()
+          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)
+          expect(task_list_after_update.size - task_list_before_update.size).to be(0)
+        end
 
-          test_result = q.get_all_results
-          test_latest_task = result.first[:task]
+        it "should only create one additional edgeGateway update task when adding the LoadBalancer config" do
+          start_time = DateTime.now()
+          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)
+          expect(task_list_after_update.size - task_list_before_update.size).to be(1)
+        end
 
-          # No task has been run on the EdgeGateway since the one before update was called
-          expect(latest_task == test_latest_task).to be_true
+        it "should not update the EdgeGateway again if we reapply the 'adding load balancer' config" do
+          start_time = DateTime.now()
+          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)
+          expect(task_list_after_update.size - task_list_before_update.size).to be(0)
         end
 
       end
@@ -123,9 +140,21 @@ module Vcloud
           edge_gateway_name: @edge_name,
           network_id: @ext_net_id,
           original_ip: @ext_net_ip,
+          edge_gateway_ext_network_id: @ext_net_id,
+          edge_gateway_ext_network_ip: @ext_net_ip,
         }
       end
 
+      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',
+          :filter =>
+            "name==networkConfigureEdgeGatewayServices;objectName==#{@edge_name};startDate=ge=#{vcloud_time}",
+          :sortDesc => 'startDate',
+        )
+        q.get_all_results
+      end
+
     end
 
   end