bosh-director 1.3202.0 → 1.3213.0

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

@@ -5,14 +5,18 @@ module Bosh::Director
     class Link
       attr_reader :name
 
-      def initialize(name, source)
+      def initialize(name, source, template, network_name = nil)
         @name = name
         @source = source
+        @network_name = network_name
+        @template = template
       end
 
       def spec
         {
-          'nodes' => @source.needed_instance_plans.map do |instance_plan|
+          'networks' => @source.networks.map { |network| network.name },
+          'properties' => @template.provides_link_info(@source.name, @name)['mapped_properties'],
+          'instances' => @source.needed_instance_plans.map do |instance_plan|
             instance = instance_plan.instance
             availability_zone = instance.availability_zone.name if instance.availability_zone
             {
@@ -20,11 +24,12 @@ module Bosh::Director
               'index' => instance.index,
               'id' => instance.uuid,
               'az' => availability_zone,
-              'networks' => instance_plan.network_addresses
+              'address' => instance_plan.network_address(@network_name),
+              'addresses' => instance_plan.network_addresses,
             }
           end
         }
       end
     end
   end
-end
+end

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

@@ -3,16 +3,16 @@ module Bosh::Director
     # tested in link_resolver_spec
 
     class LinkLookupFactory
-      def self.create(required_link, link_path, deployment_plan)
+      def self.create(consumed_link, link_path, deployment_plan, link_network, consumes_job, consumes_template)
         if link_path.deployment == deployment_plan.name
-          PlannerLinkLookup.new(required_link, link_path, deployment_plan)
+          PlannerLinkLookup.new(consumed_link, link_path, deployment_plan, link_network)
         else
           deployment = Models::Deployment.find(name: link_path.deployment)
           unless deployment
-            raise DeploymentInvalidLink, "Link '#{required_link}' references unknown deployment '#{link_path.deployment}'"
+            raise DeploymentInvalidLink, "Link '#{consumed_link}' references unknown deployment '#{link_path.deployment}'"
           end
-
-          DeploymentLinkSpecLookup.new(required_link, link_path, deployment.link_spec)
+          
+          DeploymentLinkSpecLookup.new(consumed_link, link_path, deployment.link_spec, link_network)
         end
       end
     end
@@ -21,10 +21,11 @@ module Bosh::Director
 
     # Used to find link source from deployment plan
     class PlannerLinkLookup
-      def initialize(required_link, link_path, deployment_plan)
-        @required_link = required_link
+      def initialize(consumed_link, link_path, deployment_plan, link_network)
+        @consumed_link = consumed_link
         @link_path = link_path
         @jobs = deployment_plan.jobs
+        @link_network = link_network
       end
 
       def find_link_spec
@@ -34,19 +35,20 @@ module Bosh::Director
         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 }
+        found = template.provided_links(job.name).find { |p| p.name == @link_path.name && p.type == @consumed_link.type }
         return nil unless found
 
-        Link.new(@link_path.name, job).spec
+        Link.new(@link_path.name, job, template, @link_network).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
+      def initialize(consumed_link, link_path, deployment_link_spec, link_network)
+        @consumed_link = consumed_link
         @link_path = link_path
         @deployment_link_spec = deployment_link_spec
+        @link_network = link_network
       end
 
       def find_link_spec
@@ -56,11 +58,17 @@ module Bosh::Director
         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_spec = template.fetch(@link_path.name, {})[@consumed_link.type]
+        return nil unless link_spec
+
+        if @link_network
+          link_spec['instances'].each do |instance|
+            instance['address'] = instance['addresses'][@link_network]
+          end
+        end
 
-        link_path
+        link_spec
       end
     end
   end
-end
+end

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

@@ -1,27 +1,180 @@
 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('.')
+    class LinkPath
+      attr_reader :deployment, :job, :template, :name, :path, :skip
 
-        if parts.size == 3
-          logger.debug("Link '#{path}' does not specify deployment, using current deployment")
-          parts.unshift(current_deployment_name)
-        end
+      def initialize(deployment_plan, job_name, template_name)
+        @deployment_plan = deployment_plan
+        @consumes_job_name = job_name
+        @consumes_template_name = template_name
+        @deployment = nil
+        @job = nil
+        @template = nil
+        @name = nil
+        @path = nil
+        @skip = false
+      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"
+      def parse(link_info)
+        # in case the link was explicitly set to the string `nil', do not add it
+        # to the link paths, even if the link provider exist, since the user intent
+        # was explicitly set to not consume any link
+
+        if link_info["skip_link"] && link_info["skip_link"] == true
+          @skip = true
+          return
         end
 
-        new(*parts, path)
+        if link_info.has_key?("from")
+          link_path = fulfill_explicit_link(link_info)
+        else
+          link_path = fulfill_implicit_link(link_info)
+        end
+        if link_path != nil
+          @deployment, @job, @template, @name = link_path.values_at(:deployment, :job, :template, :name)
+          @path = "#{link_path[:deployment]}.#{link_path[:job]}.#{link_path[:template]}.#{link_path[:name]}"
+        else
+          @skip = true
+        end
       end
 
       def to_s
-        path
+        "#{deployment}.#{job}.#{template}.#{name}"
+      end
+
+      private
+
+      def fulfill_implicit_link(link_info)
+        link_type = link_info["type"]
+        link_network = link_info["network"]
+        found_link_paths = []
+
+        @deployment_plan.jobs.each do |provides_job|
+          if !link_network || provides_job.has_network?(link_network)
+            provides_job.templates.each do |provides_template|
+              if provides_template.link_infos.has_key?(provides_job.name) && provides_template.link_infos[provides_job.name].has_key?('provides')
+                matching_links = provides_template.link_infos[provides_job.name]["provides"].select { |_,v| v["type"] == link_type }
+                matching_links.each do |_, matching_link_values|
+                  link_name = matching_link_values.has_key?("as") ? matching_link_values['as'] : matching_link_values['name']
+                  found_link_paths.push({:deployment => @deployment_plan.name, :job => provides_job.name, :template => provides_template.name, :name => link_name})
+                end
+              end
+            end
+          end
+        end
+
+        if found_link_paths.size == 1
+          return found_link_paths[0]
+        elsif found_link_paths.size > 1
+          all_link_paths = ""
+          found_link_paths.each do |link_path|
+            all_link_paths = all_link_paths + "\n   #{link_path[:deployment]}.#{link_path[:job]}.#{link_path[:template]}.#{link_path[:name]}"
+          end
+          raise "Multiple instance groups provide links of type '#{link_type}'. Cannot decide which one to use for instance group '#{@consumes_job_name}'.#{all_link_paths}"
+        else
+          # Only raise an exception if no linkpath was found, and the link is not optional
+          if !link_info["optional"]
+             raise "Can't find link with type: '#{link_type}' in deployment '#{@deployment_plan.name}'#{" and network '#{link_network}''" unless link_network.to_s.empty?}"
+          end
+        end
+      end
+
+      def fulfill_explicit_link(link_info)
+        from_where = link_info['from']
+        link_network = link_info['network']
+        parts = from_where.split('.') # the string might be formatted like 'deployment.link_name'
+        from_name = parts.shift
+
+        if parts.size >= 1  # given a deployment name
+          deployment_name = from_name
+          from_name = parts.shift
+          if parts.size >= 1
+            raise "From string #{from_where} is poorly formatted. It should look like 'link_name' or 'deployment_name.link_name'"
+          end
+
+          if deployment_name == @deployment_plan.name
+            link_path = get_link_path_from_deployment_plan(from_name, link_network)
+          else
+            link_path = find_deployment_and_get_link_path(deployment_name, from_name, link_network)
+          end
+        else  # given no deployment name
+          link_path = get_link_path_from_deployment_plan(from_name, link_network)   # search the jobs for the current deployment for a provides
+        end
+        link_path[:name] = from_name
+        return link_path
+      end
+
+      def get_link_path_from_deployment_plan(name, link_network)
+        found_link_paths = []
+        @deployment_plan.jobs.each do |job|
+          if !link_network || job.has_network?(link_network)
+            job.templates.each do |template|
+              if template.link_infos.has_key?(job.name) && template.link_infos[job.name].has_key?('provides')
+                template.link_infos[job.name]['provides'].to_a.each do |provides_name, source|
+                  link_name = source.has_key?("as") ? source['as'] : source['name']
+                  if link_name == name
+                    found_link_paths.push({:deployment => @deployment_plan.name, :job => job.name, :template => template.name, :name => name})
+                  end
+                end
+              end
+            end
+          end
+        end
+        if found_link_paths.size == 1
+          return found_link_paths[0]
+        elsif found_link_paths.size > 1
+          all_link_paths = ""
+          found_link_paths.each do |link_path|
+            all_link_paths = all_link_paths + "\n   #{link_path[:deployment]}.#{link_path[:job]}.#{link_path[:template]}.#{link_path[:name]}"
+          end
+          link_str = "#{@deployment_plan.name}.#{@consumes_job_name}.#{@consumes_template_name}.#{name}"
+          raise "Cannot resolve ambiguous link '#{link_str}' in deployment #{@deployment_plan.name}:#{all_link_paths}"
+        else
+          raise "Can't resolve link '#{name}' in instance group '#{@consumes_job_name}' on job '#{@consumes_template_name}' in deployment '#{@deployment_plan.name}'#{" and network '#{link_network}'" unless link_network.to_s.empty?}."
+        end
       end
+
+      def find_deployment_and_get_link_path(deployment_name, name, link_network)
+        deployment_model = Models::Deployment.where(:name => deployment_name)
+
+        # get the link path from that deployment
+        if deployment_model.count != 0
+          return find_link_path_with_name(deployment_model.first, name, link_network)
+        else
+          raise "Can't find deployment #{deployment_name}"
+        end
+      end
+
+      def find_link_path_with_name(deployment, name, link_network)
+        deployment_link_spec = deployment.link_spec
+        found_link_paths = []
+        deployment_link_spec.keys.each do |job|
+          deployment_link_spec[job].keys.each do |template|
+            deployment_link_spec[job][template].keys.each do |link|
+              if link == name
+                deployment_link_spec[job][template][link].keys.each do |type|
+                  if !link_network || (deployment_link_spec[job][template][link][type]['networks'].include? link_network)
+                    found_link_paths.push({:deployment => deployment.name, :job => job, :template => template, :name => name})
+                  end
+                end
+              end
+            end
+          end
+        end
+        if found_link_paths.size == 1
+          return found_link_paths[0]
+        elsif found_link_paths.size > 1
+          all_link_paths = ""
+          found_link_paths.each do |link_path|
+            all_link_paths = all_link_paths + "\n   #{link_path[:deployment]}.#{link_path[:job]}.#{link_path[:template]}.#{link_path[:name]}"
+          end
+          link_str = "#{@deployment_plan.name}.#{@consumes_job_name}.#{@consumes_template_name}.#{name}"
+          raise "Cannot resolve ambiguous link '#{link_str}' in deployment #{deployment.name}:#{all_link_paths}"
+        else
+          raise "Can't resolve link '#{name}' in instance group '#{@consumes_job_name}' on job '#{@consumes_template_name}' in deployment '#{@deployment_plan.name}'#{" and network '#{link_network}''" unless link_network.to_s.empty?}. Please make sure the link was provided and shared."
+        end
+      end
+
     end
   end
-end
+end

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

@@ -7,61 +7,63 @@ module Bosh::Director
       end
 
       def resolve(job)
-        @logger.debug("Resolving links for job '#{job.name}'")
+        @logger.debug("Resolving links for instance group '#{job.name}'")
 
         job.templates.each do |template|
-          resolve_required_links(job, template)
+          resolve_consumed_links(job, template)
+          ensure_all_links_in_consumes_block_are_mentioned_in_spec(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}'")
+      def resolve_consumed_links(job, template)
+        template.model_consumed_links.each do |consumed_link|
+          link_name = consumed_link.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
+          if link_path.nil?
+            # Only raise an exception when the link_path is nil, and it is not optional
+            if !consumed_link.optional
+              raise JobMissingLink, "Link path was not provided for required link '#{link_name}' in instance group '#{job.name}'"
+            end
+          else
+            link_network = template.consumes_link_info(job.name, link_name)['network']
+            link_lookup = LinkLookupFactory.create(consumed_link, link_path, @deployment_plan, link_network, job.name, template.name)
+            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
+            unless link_spec
+              raise DeploymentInvalidLink, "Cannot resolve link path '#{link_path}' required for link '#{link_name}' in instance group '#{job.name}' on job '#{template.name}'"
+            end
 
-          job.add_resolved_link(link_name, link_spec)
-        end
+            link_spec['instances'].each do |instance|
+              instance.delete('addresses')
+            end
 
-        ensure_provided_links_are_used(job, template)
+            job.add_resolved_link(link_name, link_spec)
+          end
+        end
       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
+        template.provided_links(job.name).each do |provided_link|
+          if provided_link.shared
+            link_spec = Link.new(provided_link.name, job, template).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
       end
 
-      def ensure_provided_links_are_used(job, template)
+      def ensure_all_links_in_consumes_block_are_mentioned_in_spec(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)
+          unless template.model_consumed_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."
+              "Job '#{template.name}' in instance group '#{job.name}' specifies link '#{link_name}', " +
+                "but the release job does not consume it."
           end
         end
       end

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

@@ -1,20 +1,40 @@
 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)
+    class TemplateLink < Struct.new(:name, :type, :optional, :shared)
+      def self.parse(kind, link_def)
+        if kind == "consumes"
+          return self.parse_consumes_link(link_def)
+        elsif kind == "provides"
+          return self.parse_provides_link(link_def)
         end
+      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'])
+      def self.parse_consumes_link(link_def)
+        if link_def.is_a?(Hash) && link_def.has_key?('type') && link_def.has_key?('name')
+          if link_def.has_key?('from')
+            return new(link_def['from'].split(".")[-1], link_def['type'], link_def['optional'] || false)
+          else
+            return new(link_def['name'], link_def['type'], link_def['optional'] || false)
+          end
         end
+        raise JobInvalidLinkSpec, "Link '#{link_def}' must be a hash with name and type"
+      end
 
-        raise JobInvalidLinkSpec, "Link '#{link_def}' must be either string or hash with name and type"
+      def self.parse_provides_link(link_def)
+        if link_def.is_a?(Hash) && link_def.has_key?('type') && link_def.has_key?('name')
+          if link_def.has_key?('optional')
+            raise JobInvalidLinkSpec, "Link '#{link_def['name']}' of type '#{link_def['type']}' is a provides link, not allowed to have `optional' key"
+          elsif link_def.has_key?('as')
+            return new(link_def['as'], link_def['type'], false, link_def['shared'] || false)
+          else
+            return new(link_def['name'], link_def['type'], false, link_def['shared'] || false)
+          end
+        end
+        raise JobInvalidLinkSpec, "Link '#{link_def}' must be a hash with name and type"
       end
 
       def to_s
-        "name: #{name}, type: #{type}"
+        "name: #{name}, type: #{type}, shared: #{shared || false}"
       end
     end
   end