bosh-director 1.3160.0 → 1.3163.0

data/lib/bosh/director/deployment_plan/manual_network_subnet.rb

@@ -0,0 +1,148 @@
+module Bosh::Director
+  module DeploymentPlan
+    class ManualNetworkSubnet
+      extend ValidationHelper
+      extend IpUtil
+
+      attr_reader :network_name, :range, :gateway, :dns, :cloud_properties,
+        :netmask, :availability_zone_names, :restricted_ips, :static_ips
+
+      def self.parse(network_name, subnet_spec, availability_zones, legacy_reserved_ranges)
+        @logger = Config.logger
+
+        @logger.debug("reserved ranges #{legacy_reserved_ranges.inspect}")
+        range_property = safe_property(subnet_spec, "range", :class => String)
+        range = NetAddr::CIDR.create(range_property)
+
+        if range.size <= 1
+          raise NetworkInvalidRange,
+            "Invalid network range `#{range_property}', " +
+              "should include at least 2 IPs"
+        end
+
+        netmask = range.wildcard_mask
+        network_id = range.network(:Objectify => true)
+        broadcast = range.broadcast(:Objectify => true)
+
+        ignore_missing_gateway = Bosh::Director::Config.ignore_missing_gateway
+        gateway_property = safe_property(subnet_spec, "gateway", class: String, optional: ignore_missing_gateway)
+        if gateway_property
+          gateway = NetAddr::CIDR.create(gateway_property)
+          unless gateway.size == 1
+            invalid_gateway(network_name, "must be a single IP")
+          end
+          unless range.contains?(gateway)
+            invalid_gateway(network_name, "must be inside the range")
+          end
+          if gateway == network_id
+            invalid_gateway(network_name, "can't be the network id")
+          end
+          if gateway == broadcast
+            invalid_gateway(network_name, "can't be the broadcast IP")
+          end
+        end
+
+        dns_manager = DnsManager.create
+        dns_spec = safe_property(subnet_spec, 'dns', :class => Array, :optional => true)
+        dns = dns_manager.dns_servers(network_name, dns_spec)
+
+        availability_zone_names = parse_availability_zones(subnet_spec, network_name, availability_zones)
+
+        cloud_properties = safe_property(subnet_spec, "cloud_properties", class: Hash, default: {})
+
+        reserved_property = safe_property(subnet_spec, "reserved", :optional => true)
+        static_property = safe_property(subnet_spec, "static", :optional => true)
+
+        restricted_ips = Set.new
+        restricted_ips.add(gateway.to_i) if gateway
+        restricted_ips.add(network_id.to_i)
+        restricted_ips.add(broadcast.to_i)
+
+        each_ip(reserved_property) do |ip|
+          unless range.contains?(ip)
+            raise NetworkReservedIpOutOfRange,
+              "Reserved IP `#{format_ip(ip)}' is out of " +
+                "network `#{network_name}' range"
+          end
+          restricted_ips.add(ip)
+        end
+
+        static_ips = Set.new
+        each_ip(static_property) do |ip|
+          unless range.contains?(ip) && !restricted_ips.include?(ip)
+            raise NetworkStaticIpOutOfRange,
+              "Static IP `#{format_ip(ip)}' is out of " +
+                "network `#{network_name}' range"
+          end
+          static_ips.add(ip)
+        end
+
+        legacy_reserved_ranges.each do |cidr_range|
+          cidr_range.range(0, nil, Objectify: true).each do |ip|
+            restricted_ips.add(ip.to_i) unless static_ips.include?(ip.to_i)
+          end
+        end
+
+        new(network_name, range, gateway, dns, cloud_properties, netmask, availability_zone_names, restricted_ips, static_ips)
+      end
+
+      def initialize(network_name, range, gateway, dns, cloud_properties, netmask, availability_zone_names, restricted_ips, static_ips)
+        @network_name = network_name
+        @range = range
+        @gateway = gateway
+        @dns = dns
+        @cloud_properties = cloud_properties
+        @netmask = netmask
+        @availability_zone_names = availability_zone_names
+        @restricted_ips = restricted_ips
+        @static_ips = static_ips
+      end
+
+      def overlaps?(subnet)
+        range == subnet.range ||
+          range.contains?(subnet.range) ||
+          subnet.range.contains?(range)
+      end
+
+      def is_reservable?(ip)
+        range.contains?(ip) && !restricted_ips.include?(ip.to_i)
+      end
+
+      private
+
+      def self.parse_availability_zones(subnet_spec, network_name, availability_zones)
+        has_availability_zones_key = subnet_spec.has_key?('azs')
+        has_availability_zone_key = subnet_spec.has_key?('az')
+        if has_availability_zones_key && has_availability_zone_key
+          raise Bosh::Director::NetworkInvalidProperty, "Network '#{network_name}' contains both 'az' and 'azs'. Choose one."
+        end
+
+        if has_availability_zones_key
+          zones = safe_property(subnet_spec, 'azs', class: Array, optional: true)
+          if zones.empty?
+            raise Bosh::Director::NetworkInvalidProperty, "Network '#{network_name}' refers to an empty 'azs' array"
+          end
+          zones.each do |zone|
+            check_validity_of_subnet_availability_zone(zone, availability_zones, network_name)
+          end
+          zones
+        else
+          availability_zone_name = safe_property(subnet_spec, 'az', class: String, optional: true)
+          check_validity_of_subnet_availability_zone(availability_zone_name, availability_zones, network_name)
+          availability_zone_name.nil? ? nil : [availability_zone_name]
+        end
+      end
+
+      def self.invalid_gateway(network_name, reason)
+        raise NetworkInvalidGateway,
+              "Invalid gateway for network `#{network_name}': #{reason}"
+      end
+
+      def self.check_validity_of_subnet_availability_zone(availability_zone_name, availability_zones, network_name)
+        unless availability_zone_name.nil? || availability_zones.any? { |az| az.name == availability_zone_name }
+          raise Bosh::Director::NetworkSubnetUnknownAvailabilityZone, "Network '#{network_name}' refers to an unknown availability zone '#{availability_zone_name}'"
+        end
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/network.rb

@@ -5,14 +5,10 @@ module Bosh::Director
     ##
     # Represents a logical deployment network.
     class Network
-      include DnsHelper
       include ValidationHelper
 
       VALID_DEFAULTS = %w(dns gateway).sort
 
-      # @return [DeploymentPlan] associated deployment
-      attr_accessor :deployment
-
       # @return [String] network name
       attr_accessor :name
 
@@ -24,39 +20,10 @@ module Bosh::Director
       #
       # @param [DeploymentPlan] deployment associated deployment plan
       # @param [Hash] network_spec parsed deployment manifest network section
-      def initialize(deployment, network_spec)
-        @deployment = deployment
-        @name = safe_property(network_spec, "name", :class => String)
-        @canonical_name = canonical(@name)
-      end
-
-      ##
-      # Reserves a network resource, raises an error if reservation failed
-      # @param [NetworkReservation] reservation Network reservation
-      # @param [String] origin Whoever is reserving
-      def reserve!(reservation, origin)
-        reserve(reservation)
-        unless reservation.reserved?
-          reservation.handle_error(origin)
-        end
-      end
-
-      ##
-      # Reserves a network resource.
-      #
-      # Will update the passed in reservation if it can be fulfilled.
-      # @param [NetworkReservation] reservation
-      # @return [Boolean] true if the reservation was fulfilled
-      def reserve(reservation)
-        raise NotImplementedError, "#reserve not implemented for #{self.class}"
-      end
-
-      ##
-      # Releases a previous reservation that had been fulfilled.
-      # @param [NetworkReservation] reservation
-      # @return [void]
-      def release(reservation)
-        raise NotImplementedError, "#release not implemented for #{self.class}"
+      def initialize(name, logger)
+        @name = name
+        @canonical_name = Canonicalizer.canonicalize(@name)
+        @logger = logger
       end
 
       ##
@@ -65,10 +32,54 @@ module Bosh::Director
       # @param [NetworkReservation] reservation
       # @param [Array<String>] default_properties
       # @return [Hash] network settings that will be passed to the BOSH Agent
-      def network_settings(reservation, default_properties = VALID_DEFAULTS)
+      def network_settings(reservation, default_properties = VALID_DEFAULTS, availability_zone = nil)
         raise NotImplementedError,
               "#network_settings not implemented for #{self.class}"
       end
+
+      def has_azs?(az_names)
+        raise NotImplementedError
+      end
+
+      def find_az_names_for_ip(ip)
+        raise NotImplementedError
+      end
+
+      def validate_reference_from_job!(job_network_spec, job_name)
+      end
+
+      def supports_azs?
+        false
+      end
+
+      def manual?
+        false
+      end
+    end
+
+    class NetworkWithSubnets < Network
+      def has_azs?(az_names)
+        az_names = [az_names].flatten
+
+        if az_names.compact.empty? && availability_zones.empty?
+          return true
+        end
+
+        unreferenced_zones = az_names - availability_zones
+        if unreferenced_zones.empty?
+          return true
+        end
+
+        false
+      end
+
+      def supports_azs?
+        true
+      end
+
+      def availability_zones
+        @subnets.map(&:availability_zone_names).flatten.uniq
+      end
     end
   end
-end
+end

data/lib/bosh/director/deployment_plan/network_planner.rb

@@ -0,0 +1,4 @@
+require 'bosh/director/deployment_plan/network_planner/plan'
+require 'bosh/director/deployment_plan/network_planner/planner'
+require 'bosh/director/deployment_plan/network_planner/reservation_reconciler'
+require 'bosh/director/deployment_plan/network_planner/vip_static_ips_planner'

data/lib/bosh/director/deployment_plan/network_planner/plan.rb

@@ -0,0 +1,26 @@
+module Bosh::Director::DeploymentPlan
+  module NetworkPlanner
+    class Plan
+      def initialize(attrs)
+        @reservation = attrs.fetch(:reservation)
+        @obsolete = attrs.fetch(:obsolete, false)
+        @existing = attrs.fetch(:existing, false)
+      end
+
+      attr_reader :reservation
+      attr_accessor :existing
+
+      def obsolete?
+        !!@obsolete
+      end
+
+      def desired?
+        !existing? && !obsolete?
+      end
+
+      def existing?
+        !!@existing
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/network_planner/planner.rb

@@ -0,0 +1,21 @@
+module Bosh::Director::DeploymentPlan
+  module NetworkPlanner
+    class Planner
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def network_plan_with_dynamic_reservation(instance_plan, job_network)
+        reservation = Bosh::Director::DesiredNetworkReservation.new_dynamic(instance_plan.instance, job_network.deployment_network)
+        @logger.debug("Creating new dynamic reservation #{reservation} for instance '#{instance_plan.instance}'")
+        Plan.new(reservation: reservation)
+      end
+
+      def network_plan_with_static_reservation(instance_plan, job_network, static_ip)
+        reservation = Bosh::Director::DesiredNetworkReservation.new_static(instance_plan.instance, job_network.deployment_network, static_ip)
+        @logger.debug("Creating new static reservation #{reservation} for instance '#{instance_plan.instance}'")
+        Plan.new(reservation: reservation)
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/network_planner/reservation_reconciler.rb

@@ -0,0 +1,81 @@
+module Bosh::Director::DeploymentPlan
+  module NetworkPlanner
+    class ReservationReconciler
+      def initialize(instance_plan, logger)
+        @instance_plan = instance_plan
+        @logger = logger
+      end
+
+      def reconcile(existing_reservations)
+        unplaced_existing_reservations = Set.new(existing_reservations)
+        existing_network_plans = []
+        desired_reservations = @instance_plan.network_plans.map{ |np| np.reservation }
+
+        desired_network_plans = desired_reservations.map do |reservation|
+          Plan.new(reservation: reservation)
+        end
+
+        existing_reservations.each do |existing_reservation|
+          unless az_is_desired(existing_reservation)
+            @logger.debug("Can't reuse reservation #{existing_reservation}, existing reservation az does not match desired az '#{@instance_plan.desired_instance.availability_zone}'")
+            next
+          end
+
+          desired_reservation = desired_reservations.find do |reservation|
+              reservation.network == existing_reservation.network &&
+                (reservation.dynamic? || reservation.ip == existing_reservation.ip)
+          end
+
+          if desired_reservation && existing_reservation.reserved?
+            @logger.debug("For desired reservation #{desired_reservation} found existing reservation on the same network #{existing_reservation}")
+
+            if both_are_dynamic_reservations(existing_reservation, desired_reservation) ||
+              both_are_static_reservations_with_same_ip(existing_reservation, desired_reservation)
+
+              @logger.debug("Reusing existing reservation #{existing_reservation} for '#{desired_reservation}'")
+              existing_network_plans << Plan.new(reservation: existing_reservation, existing: true)
+              unplaced_existing_reservations.delete(existing_reservation)
+              desired_network_plans.delete_if { |plan| plan.reservation == desired_reservation }
+            else
+              @logger.debug("Can't reuse reservation #{existing_reservation} for #{desired_reservation}")
+            end
+          else
+            @logger.debug("Unneeded reservation #{existing_reservation}")
+          end
+        end
+
+        obsolete_network_plans = unplaced_existing_reservations.map do |reservation|
+          Plan.new(reservation: reservation, obsolete: true)
+        end
+
+        existing_network_plans + desired_network_plans + obsolete_network_plans
+      end
+
+      private
+
+      def both_are_dynamic_reservations(existing_reservation, reservation)
+        existing_reservation.type == reservation.type &&
+          reservation.dynamic?
+      end
+
+      def both_are_static_reservations_with_same_ip(existing_reservation, reservation)
+        existing_reservation.type == reservation.type &&
+          reservation.static? &&
+          reservation.ip == existing_reservation.ip
+      end
+
+      def az_is_desired(existing_reservation)
+        return true unless existing_reservation.network.supports_azs?
+
+        ip_az_names = existing_reservation.network.find_az_names_for_ip(existing_reservation.ip)
+        @logger.debug("Reservation #{existing_reservation} belongs to azs: #{ip_az_names}")
+
+        desired_az = @instance_plan.desired_instance.az
+        return true if ip_az_names.to_a.compact.empty? && desired_az.nil?
+        return false if desired_az.nil?
+
+        ip_az_names.to_a.include?(desired_az.name)
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/network_planner/vip_static_ips_planner.rb

@@ -0,0 +1,50 @@
+module Bosh::Director::DeploymentPlan
+  module NetworkPlanner
+    class VipStaticIpsPlanner
+      def initialize(network_planner, logger)
+        @network_planner = network_planner
+        @logger = logger
+      end
+
+      def add_vip_network_plans(instance_plans, vip_networks)
+        vip_networks.each do |vip_network|
+          static_ips = vip_network.static_ips.dup
+
+          unplaced_instance_plans = []
+          instance_plans.each do |instance_plan|
+            static_ip = get_instance_static_ip(instance_plan.existing_instance, vip_network.name, static_ips)
+            if static_ip
+              instance_plan.network_plans << @network_planner.network_plan_with_static_reservation(instance_plan, vip_network, static_ip)
+            else
+              unplaced_instance_plans << instance_plan
+            end
+          end
+
+          unplaced_instance_plans.each do |instance_plan|
+            static_ip = static_ips.shift
+            instance_plan.network_plans << @network_planner.network_plan_with_static_reservation(instance_plan, vip_network, static_ip)
+          end
+        end
+      end
+
+      private
+
+      def get_instance_static_ip(existing_instance, network_name, static_ips)
+        if existing_instance
+          existing_instance_ip = find_ip_for_network(existing_instance, network_name)
+          if existing_instance_ip && static_ips.include?(existing_instance_ip)
+            static_ips.delete(existing_instance_ip)
+            return existing_instance_ip
+          end
+        end
+      end
+
+      def find_ip_for_network(existing_instance, network_name)
+        ip_address = existing_instance.ip_addresses.find do |ip_address|
+          ip_address.network_name == network_name
+        end
+        ip_address.address if ip_address
+      end
+    end
+  end
+end