bosh-director 1.3160.0 → 1.3163.0

data/lib/bosh/director/deployment_plan/links/link.rb

@@ -0,0 +1,30 @@
+module Bosh::Director
+  module DeploymentPlan
+    # tested in links_resolver_spec
+
+    class Link
+      attr_reader :name
+
+      def initialize(name, source)
+        @name = name
+        @source = source
+      end
+
+      def spec
+        {
+          'nodes' => @source.needed_instance_plans.map do |instance_plan|
+            instance = instance_plan.instance
+            availability_zone = instance.availability_zone.name if instance.availability_zone
+            {
+              'name' => @source.name,
+              'index' => instance.index,
+              'id' => instance.uuid,
+              'az' => availability_zone,
+              'networks' => instance_plan.network_addresses
+            }
+          end
+        }
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/links/link_lookup.rb

@@ -0,0 +1,66 @@
+module Bosh::Director
+  module DeploymentPlan
+    # tested in link_resolver_spec
+
+    class LinkLookupFactory
+      def self.create(required_link, link_path, deployment_plan)
+        if link_path.deployment == deployment_plan.name
+          PlannerLinkLookup.new(required_link, link_path, deployment_plan)
+        else
+          deployment = Models::Deployment.find(name: link_path.deployment)
+          unless deployment
+            raise DeploymentInvalidLink, "Link '#{required_link}' references unknown deployment '#{link_path.deployment}'"
+          end
+
+          DeploymentLinkSpecLookup.new(required_link, link_path, deployment.link_spec)
+        end
+      end
+    end
+
+    private
+
+    # Used to find link source from deployment plan
+    class PlannerLinkLookup
+      def initialize(required_link, link_path, deployment_plan)
+        @required_link = required_link
+        @link_path = link_path
+        @jobs = deployment_plan.jobs
+      end
+
+      def find_link_spec
+        job = @jobs.find { |j| j.name == @link_path.job }
+        return nil unless job
+
+        template = job.templates.find { |t| t.name == @link_path.template }
+        return nil unless template
+
+        found = template.provided_links.find { |p| p.name == @link_path.name && p.type == @required_link.type }
+        return nil unless found
+
+        Link.new(@link_path.name, job).spec
+      end
+    end
+
+    # Used to find link source from link spec in deployment model (saved in DB)
+    class DeploymentLinkSpecLookup
+      def initialize(required_link, link_path, deployment_link_spec)
+        @required_link = required_link
+        @link_path = link_path
+        @deployment_link_spec = deployment_link_spec
+      end
+
+      def find_link_spec
+        job = @deployment_link_spec[@link_path.job]
+        return nil unless job
+
+        template = job[@link_path.template]
+        return nil unless template
+
+        link_path = template.fetch(@link_path.name, {})[@required_link.type]
+        return nil unless link_path
+
+        link_path
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/links/link_path.rb

@@ -0,0 +1,27 @@
+module Bosh::Director
+  module DeploymentPlan
+    class LinkPath < Struct.new(:deployment, :job, :template, :name, :path)
+      def self.parse(current_deployment_name, path, logger)
+        parts = path.split('.')
+
+        if parts.size == 3
+          logger.debug("Link '#{path}' does not specify deployment, using current deployment")
+          parts.unshift(current_deployment_name)
+        end
+
+        if parts.size != 4
+          logger.error("Invalid link format: #{path}")
+          raise DeploymentInvalidLink,
+            "Link '#{path}' is invalid. A link must have either 3 or 4 parts: " +
+              "[deployment_name.]job_name.template_name.link_name"
+        end
+
+        new(*parts, path)
+      end
+
+      def to_s
+        path
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/links/links_resolver.rb

@@ -0,0 +1,70 @@
+module Bosh::Director
+  module DeploymentPlan
+    class LinksResolver
+      def initialize(deployment_plan, logger)
+        @deployment_plan = deployment_plan
+        @logger = logger
+      end
+
+      def resolve(job)
+        @logger.debug("Resolving links for job '#{job.name}'")
+
+        job.templates.each do |template|
+          resolve_required_links(job, template)
+          save_provided_links(job, template)
+        end
+      end
+
+      private
+
+      def resolve_required_links(job, template)
+        template.required_links.each do |required_link|
+          link_name = required_link.name
+
+          @logger.debug("Looking for link '#{link_name}' for job '#{job.name}'")
+
+          link_path = job.link_path(template.name, link_name)
+          unless link_path
+            raise JobMissingLink,
+              "Link path was not provided for required link '#{link_name}' in job '#{job.name}'"
+          end
+
+          link_lookup = LinkLookupFactory.create(required_link, link_path, @deployment_plan)
+          link_spec = link_lookup.find_link_spec
+
+          unless link_spec
+            raise DeploymentInvalidLink,
+              "Cannot resolve link path '#{link_path}' required for link '#{link_name}' " +
+                "in job '#{job.name}' on template '#{template.name}'"
+          end
+
+          job.add_resolved_link(link_name, link_spec)
+        end
+
+        ensure_provided_links_are_used(job, template)
+      end
+
+      def save_provided_links(job, template)
+        template.provided_links.each do |provided_link|
+          link_spec = Link.new(provided_link.name, job).spec
+
+          @logger.debug("Saving link spec for job '#{job.name}', template: '#{template.name}', " +
+              "link: '#{provided_link}', spec: '#{link_spec}'")
+
+          @deployment_plan.link_spec[job.name][template.name][provided_link.name][provided_link.type] = link_spec
+        end
+      end
+
+      def ensure_provided_links_are_used(job, template)
+        return if job.link_paths.empty?
+        job.link_paths[template.name].to_a.each do |link_name, _|
+          unless template.required_links.map(&:name).include?(link_name)
+            raise Bosh::Director::UnusedProvidedLink,
+              "Template '#{template.name}' in job '#{job.name}' specifies link '#{link_name}', " +
+                "but the release job does not require it."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/links/template_link.rb

@@ -0,0 +1,21 @@
+module Bosh::Director
+  module DeploymentPlan
+    class TemplateLink < Struct.new(:name, :type)
+      def self.parse(link_def)
+        if link_def.is_a?(String)
+          return new(link_def, link_def)
+        end
+
+        if link_def.is_a?(Hash) && link_def.has_key?('name') && link_def.has_key?('type')
+          return new(link_def['name'], link_def['type'])
+        end
+
+        raise JobInvalidLinkSpec, "Link '#{link_def}' must be either string or hash with name and type"
+      end
+
+      def to_s
+        "name: #{name}, type: #{type}"
+      end
+    end
+  end
+end

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

@@ -6,21 +6,17 @@ module Bosh
           migrate_releases(manifest_hash)
 
           if cloud_config.nil?
-            cloud_manifest = cloud_manifest_from_deployment_manifest(manifest_hash)
-          else
-            verify_deployment_without_cloud_config(manifest_hash)
-            cloud_manifest = cloud_config.manifest
+            cloud_config = cloud_manifest_from_deployment_manifest(manifest_hash)
           end
 
-          [manifest_hash, cloud_manifest]
+          [manifest_hash, cloud_config]
         end
 
         private
 
-        CLOUD_MANIFEST_KEYS = ['resource_pools','compilation','disk_pools','networks']
         def cloud_manifest_from_deployment_manifest(deployment_manifest)
           cloud_manifest = {}
-          CLOUD_MANIFEST_KEYS.each do |key|
+          ManifestValidator::CLOUD_MANIFEST_KEYS.each do |key|
             cloud_manifest[key] = deployment_manifest[key] if deployment_manifest.has_key? key
           end
           cloud_manifest
@@ -37,16 +33,6 @@ module Bosh
             manifest_hash['releases'] = [legacy_release].compact
           end
         end
-
-        def verify_deployment_without_cloud_config(manifest_hash)
-          deployment_cloud_properties = manifest_hash.keys & CLOUD_MANIFEST_KEYS
-          if deployment_cloud_properties.any?
-            raise(
-              Bosh::Director::DeploymentInvalidProperty,
-              "Deployment manifest should not contain cloud config properties: #{deployment_cloud_properties}"
-            )
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,46 @@
+module Bosh
+  module Director
+    module DeploymentPlan
+      class ManifestValidator
+
+        CLOUD_MANIFEST_KEYS = ['resource_pools', 'compilation', 'disk_pools', 'networks']
+
+        def validate(manifest, cloud_config)
+          raise_if_has_key(manifest, 'vm_types')
+          raise_if_has_key(manifest, 'azs')
+          raise_if_has_key(manifest, 'disk_types')
+
+          if cloud_config.nil?
+            if manifest.has_key?('jobs')
+              manifest['jobs'].each do |job|
+                if job.has_key?('migrated_from')
+                  raise Bosh::Director::DeploymentInvalidProperty,
+                    "Deployment manifest jobs contain 'migrated_from', but it can only be used with cloud-config."
+                end
+              end
+            end
+
+            raise_if_has_key(manifest, 'stemcells')
+          else
+            deployment_cloud_properties = manifest.keys & CLOUD_MANIFEST_KEYS
+            if deployment_cloud_properties.any?
+              raise(
+                Bosh::Director::DeploymentInvalidProperty,
+                "Deployment manifest should not contain cloud config properties: #{deployment_cloud_properties}"
+              )
+            end
+          end
+        end
+
+        private
+
+        def raise_if_has_key(manifest, property)
+          if manifest.has_key?(property)
+            raise Bosh::Director::DeploymentInvalidProperty,
+              "Deployment manifest contains '#{property}' section, but it can only be used in cloud-config."
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,93 +1,35 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
 module Bosh::Director
   module DeploymentPlan
     ##
     # Represents a explicitly configured network.
-    class ManualNetwork < Network
+    class ManualNetwork < NetworkWithSubnets
+      extend ValidationHelper
       include IpUtil
-      include DnsHelper
-      include ValidationHelper
 
-      ##
-      # 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
+      attr_reader :subnets
 
-        @subnets = []
-        subnets = safe_property(network_spec, "subnets", :class => Array)
+      def self.parse(network_spec, availability_zones, global_network_resolver, logger)
+        name = safe_property(network_spec, "name", :class => String)
 
-        subnets.each do |subnet_spec|
-          new_subnet = NetworkSubnet.new(self, subnet_spec)
-          @subnets.each do |subnet|
+        reserved_ranges = global_network_resolver.reserved_legacy_ranges(name)
+        subnet_specs = safe_property(network_spec, 'subnets', :class => Array)
+        subnets = []
+        subnet_specs.each do |subnet_spec|
+          new_subnet = ManualNetworkSubnet.parse(name, subnet_spec, availability_zones, reserved_ranges)
+          subnets.each do |subnet|
             if subnet.overlaps?(new_subnet)
-              raise NetworkOverlappingSubnets,
-                    "Network `#{name}' has overlapping subnets"
-            end
-          end
-          @subnets << new_subnet
-        end
-
-        # Uncomment line below when integration tests is fixed
-        # raise "Must specify at least one subnet" if @subnets.empty?
-      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.ip
-          find_subnet(reservation.ip) do |subnet|
-            type = subnet.reserve_ip(reservation.ip)
-            if type.nil?
-              reservation.error = NetworkReservation::USED
-            elsif reservation.type && reservation.type != type
-              reservation.error = NetworkReservation::WRONG_TYPE
-            else
-              reservation.type = type
-              reservation.reserved = true
-            end
-          end
-        else
-          unless reservation.dynamic?
-            raise NetworkReservationInvalidType,
-                  "New reservations without IPs must be dynamic"
-          end
-          @subnets.each do |subnet|
-            reservation.ip = subnet.allocate_dynamic_ip
-            if reservation.ip
-              reservation.reserved = true
-              break
+              raise NetworkOverlappingSubnets, "Network `#{name}' has overlapping subnets"
             end
           end
-          unless reservation.reserved?
-            reservation.error = NetworkReservation::CAPACITY
-          end
+          subnets << new_subnet
         end
-        reservation.reserved?
+        validate_all_subnets_use_azs(subnets, name)
+        new(name, subnets, logger)
       end
 
-      ##
-      # Releases a previous reservation that had been fulfilled.
-      # @param [NetworkReservation] reservation
-      # @return [void]
-      def release(reservation)
-        unless reservation.ip
-          raise NetworkReservationIpMissing,
-                "Can't release reservation without an IP"
-        end
-
-        find_subnet(reservation.ip) do |subnet|
-          subnet.release_ip(reservation.ip)
-        end
+      def initialize(name, subnets, logger)
+        super(name, TaggedLogger.new(logger, 'network-configuration'))
+        @subnets = subnets
       end
 
       ##
@@ -96,41 +38,72 @@ 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)
         unless reservation.ip
           raise NetworkReservationIpMissing,
                 "Can't generate network settings without an IP"
         end
 
-        config = nil
-        find_subnet(reservation.ip) do |subnet|
-          ip = ip_to_netaddr(reservation.ip)
-          config = {
-              "ip" => ip.ip,
-              "netmask" => subnet.netmask,
-              "cloud_properties" => subnet.cloud_properties
-          }
-
-          if default_properties
-            config["default"] = default_properties.sort
-          end
+        ip = ip_to_netaddr(reservation.ip)
+        subnet = find_subnet_containing(reservation.ip)
+        unless subnet
+          raise NetworkReservationInvalidIp, "Provided IP '#{ip}' does not belong to any subnet"
+        end
 
-          config["dns"] = subnet.dns if subnet.dns
-          config["gateway"] = subnet.gateway.ip if subnet.gateway
+        config = {
+          "ip" => ip.ip,
+          "netmask" => subnet.netmask,
+          "cloud_properties" => subnet.cloud_properties
+        }
+
+        if default_properties
+          config["default"] = default_properties.sort
         end
+
+        config["dns"] = subnet.dns if subnet.dns
+        config["gateway"] = subnet.gateway.ip if subnet.gateway
         config
       end
 
-      ##
+      def ip_type(cidr_ip)
+        static_ips = @subnets.map { |subnet| subnet.static_ips.to_a }.flatten
+        static_ips.include?(cidr_ip.to_i) ? :static : :dynamic
+      end
+
+      def find_az_names_for_ip(ip)
+        subnet = find_subnet_containing(ip)
+        if subnet
+          return subnet.availability_zone_names
+        end
+      end
+
+      def manual?
+        true
+      end
+
       # @param [Integer, NetAddr::CIDR, String] ip
       # @yield the subnet that contains the IP.
-      def find_subnet(ip)
-        @subnets.each do |subnet|
-          if subnet.range.contains?(ip)
-            yield subnet
-            break
+      def find_subnet_containing(ip)
+        @subnets.find { |subnet| subnet.range.contains?(ip) }
+      end
+
+      private
+
+      def self.validate_all_subnets_use_azs(subnets, network_name)
+        subnets_with_azs = []
+        subnets_without_azs = []
+        subnets.each do |subnet|
+          if subnet.availability_zone_names.to_a.empty?
+            subnets_without_azs << subnet
+          else
+            subnets_with_azs << subnet
           end
         end
+
+        if subnets_with_azs.size > 0 && subnets_without_azs.size > 0
+          raise JobInvalidAvailabilityZone,
+            "Subnets on network '#{network_name}' must all either specify availability zone or not"
+        end
       end
     end
   end