bosh-director 1.3160.0 → 1.3163.0

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

@@ -2,19 +2,15 @@ module Bosh
   module Director
     module DeploymentPlan
       class DeploymentRepo
-
-        def initialize(canonicalizer)
-          @canonicalizer = canonicalizer
-        end
-
         def find_or_create_by_name(name)
           deployment = Models::Deployment.find(name: name)
           return deployment if deployment
 
-          canonical_name = @canonicalizer.canonical(name)
-          Models::Deployment.db.transaction do
+          canonical_name = Canonicalizer.canonicalize(name)
+          transactor = Transactor.new
+          transactor.retryable_transaction(Models::Deployment.db) do
             Models::Deployment.each do |other|
-              if @canonicalizer.canonical(other.name) == canonical_name
+              if Canonicalizer.canonicalize(other.name) == canonical_name
                 raise DeploymentCanonicalNameTaken,
                   "Invalid deployment name `#{name}', canonical name already taken (`#{canonical_name}')"
               end

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

@@ -1,7 +1,6 @@
 module Bosh::Director
   module DeploymentPlan
     class DeploymentSpecParser
-      include DnsHelper
       include ValidationHelper
 
       def initialize(deployment, event_log, logger)
@@ -16,6 +15,7 @@ module Bosh::Director
         @deployment_manifest = deployment_manifest
         @job_states = safe_property(options, 'job_states', :class => Hash, :default => {})
 
+        parse_stemcells
         parse_properties
         parse_releases
         parse_update
@@ -26,6 +26,18 @@ module Bosh::Director
 
       private
 
+      def parse_stemcells
+        if @deployment_manifest.has_key?('stemcells')
+          safe_property(@deployment_manifest, 'stemcells', :class => Array).each do |stemcell_hash|
+            alias_val = safe_property(stemcell_hash, 'alias', :class=> String)
+            if @deployment.stemcells.has_key?(alias_val)
+              raise StemcellAliasAlreadyExists, "Duplicate stemcell alias '#{alias_val}'"
+            end
+            @deployment.add_stemcell(Stemcell.new(stemcell_hash))
+          end
+        end
+      end
+
       def parse_name
         safe_property(@deployment_manifest, 'name', :class => String)
       end

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

@@ -0,0 +1,17 @@
+module Bosh::Director
+  module DeploymentPlan
+    class DeploymentValidator
+      def validate(deployment)
+        if deployment.vm_types.any? || deployment.stemcells.any?
+          if deployment.resource_pools.any?
+            raise DeploymentInvalidResourceSpecification, "'resource_pools' cannot be specified along with 'stemcells' and/or 'vm_types'"
+          elsif deployment.stemcells.empty?
+            raise DeploymentInvalidResourceSpecification, "Both 'stemcells' and 'vm_types' need to be specified: 'stemcells' is missing"
+          elsif deployment.vm_types.empty?
+            raise DeploymentInvalidResourceSpecification, "Both 'stemcells' and 'vm_types' need to be specified: 'vm_types' is missing"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Bosh
+  module Director
+    module DeploymentPlan
+      class DesiredInstance < Struct.new(:job, :deployment, :az, :index)
+        def inspect
+          "<DesiredInstance az=#{self.az ? self.az.name : nil} index=#{self.index}>"
+        end
+
+        def availability_zone
+          self.az.name unless self.az.nil?
+        end
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/{disk_pool.rb → disk_type.rb}

@@ -1,24 +1,24 @@
 module Bosh::Director
   module DeploymentPlan
-    class DiskPool
+    class DiskType
 
-      # @return [String] Disk pool name
-      attr_accessor :name
+      # @return [String] Disk types name
+      attr_reader :name
 
       # @return [Integer] Disk size (or nil)
-      attr_accessor :disk_size
+      attr_reader :disk_size
 
       # @return [Hash] cloud properties to use when creating VMs.
-      attr_accessor :cloud_properties
+      attr_reader :cloud_properties
 
       def self.parse(dp_spec)
-        DiskPoolParser.new.parse(dp_spec)
+        DiskTypesParser.new.parse(dp_spec)
       end
 
-      def initialize(name)
+      def initialize(name, disk_size, cloud_properties)
         @name = name
-        @disk_size = 0
-        @cloud_properties = {}
+        @disk_size = disk_size
+        @cloud_properties = cloud_properties
       end
 
       def spec
@@ -31,27 +31,22 @@ module Bosh::Director
 
       private
 
-      class DiskPoolParser
+      class DiskTypesParser
         include ValidationHelper
 
         def parse(dp_spec)
           name = safe_property(dp_spec, 'name', class: String)
-          disk_pool = DiskPool.new(name)
-
           disk_size = safe_property(dp_spec, 'disk_size', class: Integer)
-
           if disk_size < 0
-            raise DiskPoolInvalidDiskSize,
-              "Disk pool `#{name}' references an invalid peristent disk size `#{disk_size}'"
+            raise DiskTypeInvalidDiskSize,
+              "Disk types `#{name}' references an invalid persistent disk size `#{disk_size}'"
           end
-          disk_pool.disk_size = disk_size
 
-          disk_pool.cloud_properties = safe_property(dp_spec, 'cloud_properties', class: Hash, default: {})
+          cloud_properties = safe_property(dp_spec, 'cloud_properties', class: Hash, default: {})
 
-          disk_pool
+          DiskType.new(name, disk_size, cloud_properties)
         end
       end
-
     end
   end
 end

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

@@ -1,74 +1,118 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
 module Bosh::Director
   module DeploymentPlan
-    class DynamicNetwork < Network
-      include DnsHelper
+    class DynamicNetwork < NetworkWithSubnets
+      include Bosh::Director::IpUtil
+      extend ValidationHelper
 
-      DYNAMIC_IP = NetAddr::CIDR.create("255.255.255.255").to_i
+      def self.parse(network_spec, availability_zones, logger)
+        name = safe_property(network_spec, 'name', :class => String)
+        Canonicalizer.canonicalize(name)
+        logger = TaggedLogger.new(logger, 'network-configuration')
+        dns_manager = DnsManager.create
 
-      # @!attribute [rw] cloud_properties
-      #   @return [Hash] Network cloud properties
-      attr_accessor :cloud_properties
+        validate_network_has_no_key('az', name, network_spec)
+        validate_network_has_no_key('azs', name, network_spec)
 
-      # @!attribute [rw] dns
-      #   @return [Array] an array of DNS servers
-      attr_accessor :dns
+        if network_spec.has_key?('subnets')
+          validate_network_has_no_key_while_subnets_present('dns', name, network_spec)
+          validate_network_has_no_key_while_subnets_present('cloud_properties', name, network_spec)
 
-      ##
-      # Creates a new network.
-      #
-      # @param [DeploymentPlan] deployment associated deployment plan
-      # @param [Hash] network_spec parsed deployment manifest network section
-      def initialize(deployment, network_spec)
-        super
-        @cloud_properties =
-          safe_property(network_spec, "cloud_properties", class: Hash, default: {})
-
-        @dns = dns_servers(network_spec["name"], network_spec)
+          subnets = network_spec['subnets'].map do |subnet_properties|
+            dns_spec = safe_property(subnet_properties, 'dns', :class => Array, :optional => true)
+            dns = dns_manager.dns_servers(subnet_properties['name'], dns_spec)
+            cloud_properties = safe_property(subnet_properties, 'cloud_properties', class: Hash, default: {})
+            subnet_availability_zones = parse_availability_zones(subnet_properties, availability_zones, name)
+            DynamicNetworkSubnet.new(dns, cloud_properties, subnet_availability_zones)
+          end
+        else
+          cloud_properties = safe_property(network_spec, 'cloud_properties', class: Hash, default: {})
+          dns_spec = safe_property(network_spec, 'dns', :class => Array, :optional => true)
+          dns = dns_manager.dns_servers(network_spec['name'], dns_spec)
+          subnets = [DynamicNetworkSubnet.new(dns, cloud_properties, nil)]
+        end
+
+        new(name, subnets, logger)
       end
 
-      ##
-      # Reserves a network resource.
-      #
-      # This is either an already used reservation being verified or a new one
-      # waiting to be fulfilled.
-      # @param [NetworkReservation] reservation
-      # @return [Boolean] true if the reservation was fulfilled
-      def reserve(reservation)
-        reservation.reserved = false
-        if reservation.static?
-          reservation.error = NetworkReservation::WRONG_TYPE
+      def self.validate_network_has_no_key_while_subnets_present(key, name, network_spec)
+        if network_spec.has_key?(key)
+          raise NetworkInvalidProperty, "Network '#{name}' must not specify '#{key}' when also specifying 'subnets'. " +
+              "Instead, '#{key}' should be specified on subnet entries."
+        end
+      end
+
+      def self.validate_network_has_no_key(key, name, network_spec)
+        if network_spec.has_key?(key)
+          raise NetworkInvalidProperty, "Network '#{name}' must not specify '#{key}'."
+        end
+      end
+
+      def self.parse_availability_zones(spec, availability_zones, name)
+
+        has_availability_zones_key = spec.has_key?('azs')
+        has_availability_zone_key = spec.has_key?('az')
+
+        if has_availability_zone_key && has_availability_zones_key
+          raise Bosh::Director::NetworkInvalidProperty, "Network '#{name}' contains both 'az' and 'azs'. Choose one."
+        end
+
+        if has_availability_zones_key
+          subnet_availability_zones = safe_property(spec, 'azs', class: Array, optional: true)
+          if subnet_availability_zones.empty?
+            raise Bosh::Director::NetworkInvalidProperty, "Network '#{name}' refers to an empty 'azs' array"
+          end
+          subnet_availability_zones.each do |zone|
+            check_validity_of_availability_zone(zone, availability_zones, name)
+          end
+          subnet_availability_zones
         else
-          reservation.ip = DYNAMIC_IP
-          reservation.reserved = true
-          reservation.type = NetworkReservation::DYNAMIC
+          availability_zone = safe_property(spec, 'az', class: String, optional: true)
+          check_validity_of_availability_zone(availability_zone, availability_zones, name)
+          availability_zone.nil? ? nil : [availability_zone]
         end
-        reservation.reserved?
       end
 
-      ##
-      # Releases a previous reservation that had been fulfilled.
-      # @param [NetworkReservation] reservation
-      # @return [void]
-      def release(reservation)
-        validate_ip(reservation)
+      def self.check_validity_of_availability_zone(availability_zone, availability_zones, name)
+        unless availability_zone.nil? || availability_zones.any? { |az| az.name == availability_zone }
+          raise Bosh::Director::NetworkSubnetUnknownAvailabilityZone, "Network '#{name}' refers to an unknown availability zone '#{availability_zone}'"
+        end
       end
 
+      def initialize(name, subnets, logger)
+        super(name, logger)
+        @subnets = subnets
+      end
+
+      attr_reader :subnets
+
       ##
       # Returns the network settings for the specific reservation.
       #
       # @param [NetworkReservation] reservation
       # @param [Array<String>] default_properties
+      # @param [AvailabilityZone] availability zone
       # @return [Hash] network settings that will be passed to the BOSH Agent
-      def network_settings(reservation, default_properties = VALID_DEFAULTS)
-        validate_ip(reservation)
+      def network_settings(reservation, default_properties = Network::VALID_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"
+        end
+
+        if availability_zone.nil?
+          subnet = subnets.first
+        else
+          subnet = find_subnet_for_az(availability_zone.name)
+          unless subnet
+            raise NetworkSubnetInvalidAvailabilityZone,
+              "Network '#{name}' has no matching subnet for availability zone '#{availability_zone.name}'"
+          end
+        end
 
         config = {
           "type" => "dynamic",
-          "cloud_properties" => @cloud_properties
+          "cloud_properties" => subnet.cloud_properties
         }
-        config["dns"] = @dns if @dns
+        config["dns"] = subnet.dns if subnet.dns
 
         if default_properties
           config["default"] = default_properties.sort
@@ -77,14 +121,22 @@ module Bosh::Director
         config
       end
 
+      def validate_reference_from_job!(job_network_spec, job_name)
+        if job_network_spec.has_key?('static_ips')
+          raise JobStaticIPNotSupportedOnDynamicNetwork,
+            "Job '#{job_name}' using dynamic network '#{name}' cannot specify static IP(s)"
+        end
+      end
+
+      def find_az_names_for_ip(ip)
+        # On dynamic network ip does not belong to any subnet
+        availability_zones
+      end
+
       private
 
-      def validate_ip(reservation)
-        unless reservation.ip == DYNAMIC_IP
-          raise NetworkReservationInvalidIp,
-                "Invalid IP: `%s', did not match magic DYNAMIC IP" % [
-                  reservation.ip]
-        end
+      def find_subnet_for_az(az_name)
+        @subnets.find { |subnet| subnet.availability_zone_names.include?(az_name) }
       end
     end
   end

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

@@ -0,0 +1,13 @@
+module Bosh::Director
+  module DeploymentPlan
+    class DynamicNetworkSubnet
+      def initialize(dns, cloud_properties, availability_zone_names)
+        @dns = dns
+        @cloud_properties = cloud_properties
+        @availability_zone_names = availability_zone_names.nil? ? nil : availability_zone_names
+      end
+
+      attr_reader :dns, :cloud_properties, :availability_zone_names
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Bosh::Director
+  module DeploymentPlan
+    class Env
+      include ValidationHelper
+
+      # @return [Hash]
+      attr_reader :env
+
+      def initialize(spec)
+        @env = spec
+      end
+
+      def spec
+        @env
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Bosh::Director
+  module DeploymentPlan
+    class NullGlobalNetworkResolver
+      def reserved_legacy_ranges(something)
+        []
+      end
+    end
+
+    class GlobalNetworkResolver
+      include Bosh::Director::ValidationHelper
+      include IpUtil
+
+      def initialize(current_deployment)
+        @current_deployment = current_deployment
+      end
+
+      def reserved_legacy_ranges(network_name)
+        return Set.new unless @current_deployment.using_global_networking?
+        legacy_ranges.fetch(network_name, Set.new)
+      end
+
+      private
+
+      def legacy_ranges
+        @reserved_legacy_ranges ||= begin
+          reserved_legacy_ranges = {}
+
+          other_deployments = Models::Deployment.where(cloud_config_id: nil).
+            exclude(name: @current_deployment.name).
+            exclude(manifest: nil).all
+
+          other_deployments.each do |deployment|
+            add_networks_from_deployment(deployment, reserved_legacy_ranges)
+          end
+
+          reserved_legacy_ranges
+        end
+      end
+
+      def add_networks_from_deployment(deployment, ranges)
+        networks = safe_property(Psych.load(deployment.manifest), 'networks', :class => Array, :default => [])
+        networks.each do |network_spec|
+          add_network(network_spec, ranges)
+        end
+      end
+
+      def add_network(network_spec, ranges)
+        name = safe_property(network_spec, 'name', :class => String)
+        ranges[name] ||= Set.new
+
+        type = safe_property(network_spec, 'type', :class => String, :default => 'manual')
+        return unless type == 'manual'
+
+        subnets = safe_property(network_spec, 'subnets', :class => Array)
+        subnets.each do |subnet_spec|
+          range_property = safe_property(subnet_spec, 'range', :class => String)
+          range = NetAddr::CIDR.create(range_property)
+          reserved_property = safe_property(subnet_spec, 'reserved', :optional => true)
+
+          reserved_ranges = Set.new([range])
+
+          each_ip(reserved_property) do |ip|
+            addr = NetAddr::CIDRv4.new(ip)
+            range_with_ip = reserved_ranges.find { |r| r.contains?(addr) || r == addr }
+            reserved_ranges.delete(range_with_ip)
+            if range_with_ip != addr
+              remainder = range_with_ip.remainder(addr, Objectify: true)
+              reserved_ranges += Set.new(remainder)
+            end
+          end
+
+          ranges[name] += reserved_ranges
+        end
+      end
+    end
+  end
+end