introduce new prefix column in ip addresses table

Author: fmoehler

src/bosh-director/lib/bosh/director/deployment_plan/dynamic_network.rb

@@ -94,7 +94,7 @@ def initialize(name, subnets, logger)
       def network_settings(reservation, default_properties = Network::REQUIRED_DEFAULTS, availability_zone = nil)
         unless reservation.dynamic?
           raise NetworkReservationWrongType,
-            "IP '#{format_ip(reservation.ip)}' on network '#{reservation.network.name}' does not belong to dynamic pool"
+            "IP '#{reservation.ip}' on network '#{reservation.network.name}' does not belong to dynamic pool"
         end
 
         if availability_zone.nil?

src/bosh-director/lib/bosh/director/deployment_plan/instance_group_networks_parser.rb

@@ -35,6 +35,9 @@ def parse_networks(instance_group_spec, instance_group_name, manifest_networks)
           default_for = safe_property(network_spec, 'default', class: Array, default: [])
           static_ips = parse_static_ips(network_spec['static_ips'], instance_group_name)
 
+          puts "static_ips"
+          puts static_ips
+
           deployment_network = look_up_deployment_network(manifest_networks, instance_group_name, network_name)
           deployment_network.validate_reference_from_job!(network_spec, instance_group_name)
 

src/bosh-director/lib/bosh/director/deployment_plan/ip_provider/ip_provider.rb

@@ -65,15 +65,8 @@ def reserve_manual(reservation)
           @logger.debug("Allocating dynamic ip for manual network '#{reservation.network.name}'")
 
           filter_subnet_by_instance_az(reservation).each do |subnet|
-            ip = if reservation.is_prefix_reservation
-              @ip_repo.allocate_dynamic_prefix(reservation, subnet)
-            else
-              @ip_repo.allocate_dynamic_ip(reservation, subnet)
-            end
-
-            @logger.debug("Reserving dynamic IP/prefix '#{ip}' for manual network '#{reservation.network.name}'")
-
-            if ip
+            if (ip = @ip_repo.allocate_dynamic_ip(reservation, subnet))
+              @logger.debug("Reserving dynamic IP '#{ip}' for manual network '#{reservation.network.name}'")
               reservation.resolve_ip(ip)
               reservation.resolve_type(:dynamic)
               break
@@ -82,13 +75,13 @@ def reserve_manual(reservation)
 
           if reservation.ip.nil?
             raise NetworkReservationNotEnoughCapacity,
-              "Failed to reserve IP/Prefix for '#{reservation.instance_model}' for manual network '#{reservation.network.name}': no more available"
+              "Failed to reserve IP for '#{reservation.instance_model}' for manual network '#{reservation.network.name}': no more available"
           end
         else
           @logger.debug("Reserving #{reservation.desc} for manual network '#{reservation.network.name}'")
 
           if (subnet = reservation.network.find_subnet_containing(reservation.ip))
-            if subnet.restricted_ips.include?(reservation.ip)
+            if subnet.restricted_ips.include?(reservation.ip.to_i)
               message = "Failed to reserve IP '#{format_ip(reservation.ip)}' for network '#{subnet.network_name}': IP belongs to reserved range"
               @logger.error(message)
               raise Bosh::Director::NetworkReservationIpReserved, message
@@ -106,7 +99,8 @@ def reserve_manual_with_subnet(reservation, subnet)
         @ip_repo.add(reservation)
 
         subnet_az_names = subnet.availability_zone_names.to_a.join(', ')
-        if subnet.static_ips.include?(reservation.ip)
+
+        if subnet.static_ips.include?(reservation.ip.to_i)
           reservation.resolve_type(:static)
           @logger.debug("Found subnet with azs '#{subnet_az_names}' for #{format_ip(reservation.ip)}. Reserved as static network reservation.")
         else

src/bosh-director/lib/bosh/director/deployment_plan/ip_provider/ip_repo.rb

@@ -3,6 +3,7 @@ class IpRepo
     include Bosh::Director::IpUtil
     class IpFoundInDatabaseAndCanBeRetried < StandardError; end
     class NoMoreIPsAvailableAndStopRetrying < StandardError; end
+    class PrefixOutOfRange < StandardError; end
 
     def initialize(logger)
       @logger = Bosh::Director::TaggedLogger.new(logger, 'network-configuration')
@@ -11,7 +12,7 @@ def initialize(logger)
     def delete(ip)
       ip_or_cidr = Bosh::Director::IpAddrOrCidr.new(ip)
 
-      ip_address = Bosh::Director::Models::IpAddress.first(address_str: ip_or_cidr.to_i.to_s)
+      ip_address = Bosh::Director::Models::IpAddress.first(address_str: ip_or_cidr.to_cidr_s)
 
       if ip_address
         @logger.debug("Releasing ip '#{ip_or_cidr}'")
@@ -22,18 +23,19 @@ def delete(ip)
     end
 
     def add(reservation)
-      ip_or_cidr = Bosh::Director::IpAddrOrCidr.new(reservation.ip)
+      ip_or_cidr = Bosh::Director::IpAddrOrCidr.new(reservation.ip.to_cidr_s)
 
       reservation_type = reservation.network.ip_type(ip_or_cidr)
 
       reserve_with_instance_validation(
         reservation.instance_model,
-        ip_or_cidr,
+        ip_or_cidr.to_cidr_s,
         reservation,
         reservation_type.eql?(:static),
       )
 
       reservation.resolve_type(reservation_type)
+
       @logger.debug("Reserved ip '#{ip_or_cidr}' for #{reservation.network.name} as #{reservation_type}")
     end
 
@@ -51,24 +53,7 @@ def allocate_dynamic_ip(reservation, subnet)
       end
 
       @logger.debug("Allocated dynamic IP '#{ip_address}' for #{reservation.network.name}")
-      ip_address.to_i
-    end
-
-    def allocate_dynamic_prefix(reservation, subnet)
-      begin
-        cidr = try_to_allocate_dynamic_prefix(reservation, subnet)
-      rescue NoMoreIPsAvailableAndStopRetrying
-        @logger.debug('Failed to allocate dynamic prefix: no more available')
-        return nil
-      rescue IpFoundInDatabaseAndCanBeRetried
-        @logger.debug('Retrying to allocate dynamic prefix: probably a race condition with another deployment')
-        # IP can be taken by other deployment that runs in parallel
-        # retry until succeeds or out of range
-        retry
-      end
-
-      @logger.debug("Allocated dynamic cidr '#{cidr}' for #{reservation.network.name}")
-      cidr.to_i
+      ip_address
     end
 
     def allocate_vip_ip(reservation, subnet)
@@ -91,90 +76,120 @@ def allocate_vip_ip(reservation, subnet)
 
     private
 
+    def all_ip_addresses
+      Bosh::Director::Models::IpAddress.select(:address_str).all.map { |a| a.address }
+    end
+    
+    def get_prefix(ip)
+      if Bosh::Director::IpAddrOrCidr.new(ip).ipv6?
+        128
+      else
+        32
+      end
+    end
+
     def try_to_allocate_dynamic_ip(reservation, subnet)
       addresses_in_use = Set.new(all_ip_addresses)
 
-      first_range_address = subnet.range.to_range.first.to_i - 1
+
+      first_range_address = Bosh::Director::IpAddrOrCidr.new(subnet.range.to_range.first.to_i - 1)
+      
       addresses_we_cant_allocate = addresses_in_use
-      addresses_we_cant_allocate << first_range_address
 
-      addresses_we_cant_allocate.merge(subnet.restricted_ips.to_a) unless subnet.restricted_ips.empty?
-      addresses_we_cant_allocate.merge(subnet.static_ips.to_a) unless subnet.static_ips.empty?
-      addr = find_first_available_address(addresses_we_cant_allocate, first_range_address)
-      ip_address = Bosh::Director::IpAddrOrCidr.new(addr)
+      addresses_we_cant_allocate.merge(subnet.restricted_ips.map { |int_ip| Bosh::Director::IpAddrOrCidr.new(int_ip)}) unless subnet.restricted_ips.empty?
+      addresses_we_cant_allocate.merge(subnet.static_ips.map { |int_ip| Bosh::Director::IpAddrOrCidr.new(int_ip)}) unless subnet.static_ips.empty?
+
+      if subnet.range.ipv6?
+        addresses_we_cant_allocate.delete_if { |ipaddr| ipaddr.ipv4? }
+        if subnet.prefix.nil?
+          prefix = 128
+        else
+          prefix = subnet.prefix
+        end
+      else
+        addresses_we_cant_allocate.delete_if { |ipaddr| ipaddr.ipv6? }
+        if subnet.prefix.nil?
+          prefix = 32
+        else
+          prefix = subnet.prefix
+        end
+      end
+
+      ip_address = find_next_available_ip(addresses_we_cant_allocate, first_range_address, prefix)
 
       unless subnet.range == ip_address || subnet.range.include?(ip_address)
         raise NoMoreIPsAvailableAndStopRetrying
       end
 
-      save_ip(ip_address, reservation, false)
+      unless prefix
+        if ip_address.ipv6?
+          host_bits = 128 - prefix
+        else
+          host_bits = 32 - prefix
+        end
+        no_of_addresses = 2**host_bits
+        if subnet.range.last < (ip_address.to_i + no_of_addresses)
+          raise NoMoreIPsAvailableAndStopRetrying
+        end
+      end
+
+      save_ip(ip_address.to_cidr_s, reservation, false)
 
       ip_address
     end
 
-    def try_to_allocate_dynamic_prefix(reservation, subnet)
-      @logger.debug("Allocating dynamic prefix for #{reservation.network.name}")
-      addresses_in_use = Set.new(all_ip_addresses)
-
-      first_range_address = subnet.range.to_range.first.to_i - 1
-      addresses_we_cant_allocate = addresses_in_use
-      addresses_we_cant_allocate << first_range_address
+    def find_next_available_ip(ip_entries, first_range_address, prefix)
+      filtered_ips = ip_entries.sort_by { |ip| ip.to_i }.reject { |ip| ip.to_i < first_range_address.to_i } #remove ips that are below subnet range
 
-      addresses_we_cant_allocate.merge(subnet.restricted_ips.to_a) unless subnet.restricted_ips.empty?
-      addresses_we_cant_allocate.merge(subnet.static_ips.to_a) unless subnet.static_ips.empty?
+      if prefix == 32 || prefix == 128
+          available_ip = filtered_ips.find { |ip| !filtered_ips.include?(Bosh::Director::IpAddrOrCidr.new(ip.to_i + 1)) }.to_i + 1
 
-      addr = Bosh::Director::IpAddrOrCidr.new(find_first_available_address(addresses_we_cant_allocate, first_range_address)).to_s
-      cidr_string = get_first_available_prefix(addr, subnet.prefix)
-
-      @logger.debug("FIRST AVAILABLE PREFIX '#{cidr_string}' for #{reservation.network.name}")
-
-      cidr = Bosh::Director::IpAddrOrCidr.new(cidr_string)
-
-      unless subnet.range == cidr || subnet.range.include?(cidr)
-        raise NoMoreIPsAvailableAndStopRetrying
+          found_cidr = Bosh::Director::IpAddrOrCidr.new("#{Bosh::Director::IpAddrOrCidr.new(available_ip)}/#{prefix}")
+      else
+        current_ip = Bosh::Director::IpAddrOrCidr.new(first_range_address.to_i + 1)
+        found = false
+
+        while found == false
+          current_prefix = Bosh::Director::IpAddrOrCidr.new("#{current_ip}/#{prefix}")
+
+          if filtered_ips.any? { |ip| current_prefix.include?(ip) }
+            current_ip = Bosh::Director::IpAddrOrCidr.new(current_ip.to_i + current_prefix.count)
+            filtered_ips.reject{ |ip| ip.to_i < current_ip.to_i }
+          else
+            found_cidr = current_prefix
+            found = true
+          end
+        end
       end
 
-      save_ip(cidr, reservation, false)
-
-      cidr
-    end
-
-    def find_first_available_address(addresses_we_cant_allocate, first_address)
-      last_address_we_cant_use = addresses_we_cant_allocate
-                                 .to_a
-                                 .reject { |a| a < first_address }
-                                 .sort
-                                 .find { |a| !addresses_we_cant_allocate.include?(a + 1) }
-      last_address_we_cant_use + 1
-    end
-
-    def get_first_available_prefix(first_available_addr, prefix)
-      "#{first_available_addr}/#{prefix}"
+      found_cidr
     end
 
     def try_to_allocate_vip_ip(reservation, subnet)
-      addresses_in_use = Set.new(all_ip_addresses)
+      addresses_in_use = Set.new(all_ip_addresses.map { |ip| ip.to_i })
+
+      if Bosh::Director::IpAddrOrCidr.new(subnet.static_ips.first.to_i).ipv6?
+        prefix = 128
+      else
+        prefix = 32
+      end
 
       available_ips = subnet.static_ips - addresses_in_use
 
       raise NoMoreIPsAvailableAndStopRetrying if available_ips.empty?
 
-      ip_address = Bosh::Director::IpAddrOrCidr.new(available_ips.first)
+      ip_address = Bosh::Director::IpAddrOrCidr.new("#{Bosh::Director::IpAddrOrCidr.new(available_ips.first)}/#{prefix}")
 
-      save_ip(ip_address, reservation, false)
+      save_ip(ip_address.to_cidr_s, reservation, false)
 
       ip_address
     end
 
-    def all_ip_addresses
-      Bosh::Director::Models::IpAddress.select(:address_str).all.map { |a| a.address_str.to_i }
-    end
-
     def reserve_with_instance_validation(instance_model, ip, reservation, is_static)
       # try to save IP first before validating its instance to prevent race conditions
       save_ip(ip, reservation, is_static)
     rescue IpFoundInDatabaseAndCanBeRetried
-      ip_address = Bosh::Director::Models::IpAddress.first(address_str: ip.to_i.to_s)
+      ip_address = Bosh::Director::Models::IpAddress.first(address_str: ip.to_s)
 
       retry unless ip_address
 
@@ -204,15 +219,17 @@ def validate_instance_and_update_reservation_type(instance_model, ip, ip_address
     end
 
     def save_ip(ip, reservation, is_static)
+      @logger.debug("Adding IP Address: #{ip} from reservation: #{reservation}")
       ip_address = Bosh::Director::Models::IpAddress.new(
-        address_str: ip.to_i.to_s,
+        address_str: ip.to_s,
         network_name: reservation.network.name,
         task_id: Bosh::Director::Config.current_job.task_id,
         static: is_static,
-      )
+        )
       reservation.instance_model.add_ip_address(ip_address)
     rescue Sequel::ValidationFailed, Sequel::DatabaseError => e
       error_message = e.message.downcase
+      @logger.debug("ERROR!!! #{error_message}")
       if error_message.include?('unique') || error_message.include?('duplicate')
         raise IpFoundInDatabaseAndCanBeRetried, e.inspect
       else

src/bosh-director/lib/bosh/director/deployment_plan/job_network.rb

@@ -1,13 +1,25 @@
 module Bosh::Director
   module DeploymentPlan
     class JobNetwork
-      attr_reader :name, :static_ips, :deployment_network
+      attr_reader :name, :static_ips, :deployment_network, :prefix
 
       def initialize(name, static_ips, default_for, deployment_network)
         @name = name
         @static_ips = static_ips
         @default_for = default_for
         @deployment_network = deployment_network
+        subnet = deployment_network.find_subnet_containing(static_ips.first)
+
+        if subnet.nil?
+          if Bosh::Director::IpAddrOrCidr.new(static_ips.first).ipv6?
+            @prefix = 128
+          else
+            @prefix = 32
+          end
+        else
+          @prefix = subnet.prefix
+        end
+
       end
 
       def availability_zones

src/bosh-director/lib/bosh/director/deployment_plan/manual_network.rb

@@ -52,9 +52,14 @@ def network_settings(reservation, default_properties = REQUIRED_DEFAULTS, availa
           raise NetworkReservationInvalidIp, "Provided IP '#{ip_or_cidr}' does not belong to any subnet"
         end
 
+        unless subnet.prefix == ip_or_cidr.prefix
+          raise NetworkReservationInvalidPRefix, "Subnet Prefix #{subnet.prefix} and ip reservation prefix #{ip_or_cidr.prefix} do not match"
+        end
+
         config = {
           "type" => "manual",
           "ip" => ip_or_cidr.to_s,
+          "prefix" => subnet.prefix.to_s,
           "netmask" => subnet.netmask,
           "cloud_properties" => subnet.cloud_properties
         }

src/bosh-director/lib/bosh/director/deployment_plan/manual_network_subnet.rb

@@ -77,8 +77,14 @@ def self.parse(network_name, subnet_spec, availability_zones, managed = false)
             static_ips.add(ip)
           end
 
-          unless prefix.nil?
-            if range.prefix > prefix
+          if prefix.nil?
+            if range.ipv6?
+              prefix = 128
+            else
+              prefix = 32
+            end
+          else
+            if range.prefix > prefix.to_i
               raise NetworkPrefixSizeTooBig, "Prefix size '#{prefix}' is larger than range prefix '#{range.prefix}'"
             end
           end
@@ -106,7 +112,7 @@ def self.parse(network_name, subnet_spec, availability_zones, managed = false)
         )
       end
 
-      def initialize(network_name, range, gateway, name_servers, cloud_properties, netmask, availability_zone_names, restricted_ips, static_ips, subnet_name = nil, netmask_bits = nil, prefix)
+      def initialize(network_name, range, gateway, name_servers, cloud_properties, netmask, availability_zone_names, restricted_ips, static_ips, subnet_name = nil, netmask_bits = nil, prefix = nil)
         @network_name = network_name
         @name = subnet_name
         @netmask_bits = netmask_bits