bosh-director 1.3202.0 → 1.3213.0

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

@@ -16,11 +16,11 @@ module Bosh::Director
         version = safe_property(spec, "version", :class => String)
 
         if name.nil? && os.nil?
-          raise ValidationMissingField, "Required property `os' or `name' was not specified in object (#{spec})"
+          raise ValidationMissingField, "Required property 'os' or 'name' was not specified in object (#{spec})"
         end
 
         if !name.nil? && !os.nil?
-          raise StemcellBothNameAndOS, "Properties `os' and `name' are both specified for stemcell, choose one. (#{spec})"
+          raise StemcellBothNameAndOS, "Properties 'os' and 'name' are both specified for stemcell, choose one. (#{spec})"
         end
 
         new(name_alias, name, os, version)

data/lib/bosh/director/deployment_plan/steps/package_compile_step.rb

@@ -63,7 +63,7 @@ module Bosh::Director
             # Check if the package was compiled in a parallel deployment
             compiled_package = task.find_compiled_package(@logger, @event_log)
             if compiled_package.nil?
-              build = Models::CompiledPackage.generate_build_number(package, stemcell.model)
+              build = Models::CompiledPackage.generate_build_number(package, stemcell.model.operating_system, stemcell.model.version)
               task_result = nil
 
               prepare_vm(stemcell) do |instance|
@@ -82,7 +82,8 @@ module Bosh::Director
 
               compiled_package = Models::CompiledPackage.create do |p|
                 p.package = package
-                p.stemcell = stemcell.model
+                p.stemcell_os = stemcell.os
+                p.stemcell_version = stemcell.version
                 p.sha1 = task_result['sha1']
                 p.build = build
                 p.blobstore_id = task_result['blobstore_id']

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

@@ -1,6 +1,10 @@
+require 'bosh/template/property_helper'
+
 module Bosh::Director
   module DeploymentPlan
     class Template
+      include Bosh::Template::PropertyHelper
+      include ValidationHelper
 
       attr_reader :name
       attr_reader :release
@@ -8,6 +12,9 @@ module Bosh::Director
       attr_reader :model
       attr_reader :package_models
 
+      attr_reader :link_infos
+      attr_reader :template_scoped_properties
+
       # @param [DeploymentPlan::ReleaseVersion] release Release version
       # @param [String] name Template name
       def initialize(release, name)
@@ -16,6 +23,15 @@ module Bosh::Director
         @model = nil
         @package_models = []
         @logger = Config.logger
+        @link_infos = {}
+
+        # This hash will contain the properties specific to this template,
+        # it will be a hash where the keys are the deployment job name, and
+        # the value of each key will be the properties defined in template
+        # section of the deployment manifest. This way if a template is used
+        # in multiple deployment jobs, the properties will not be shared across
+        # jobs
+        @template_scoped_properties = {}
       end
 
       # Looks up template model and its package models in DB
@@ -24,7 +40,7 @@ module Bosh::Director
         @model = @release.get_template_model_by_name(@name)
 
         if @model.nil?
-          raise DeploymentUnknownTemplate, "Can't find template `#{@name}'"
+          raise DeploymentUnknownTemplate, "Can't find job '#{@name}'"
         end
 
         @package_models = @model.package_names.map do |name|
@@ -42,14 +58,14 @@ module Bosh::Director
         uuid = SecureRandom.uuid
         path = File.join(Dir.tmpdir, "template-#{uuid}")
 
-        @logger.debug("Downloading template `#{@name}' (#{blobstore_id})...")
+        @logger.debug("Downloading job '#{@name}' (#{blobstore_id})...")
         t1 = Time.now
 
         File.open(path, "w") do |f|
           App.instance.blobstores.blobstore.get(blobstore_id, f)
         end
 
-        @logger.debug("Template `#{@name}' downloaded to #{path} " +
+        @logger.debug("Job '#{@name}' downloaded to #{path} " +
                       "(took #{Time.now - t1}s)")
 
         path
@@ -81,13 +97,82 @@ module Bosh::Director
       end
 
       # return [Array]
-      def required_links
-        present_model.requires.to_a.map { |l| TemplateLink.parse(l) }
+      def model_consumed_links
+        present_model.consumes.to_a.map { |l| TemplateLink.parse("consumes", l) }
       end
 
       # return [Array]
-      def provided_links
-        present_model.provides.to_a.map { |l| TemplateLink.parse(l) }
+      def model_provided_links
+        present_model.provides.to_a.map { |l| TemplateLink.parse('provides', l) }
+      end
+
+      # return [Array]
+      def consumed_links(job_name)
+        if @link_infos[job_name] != nil && @link_infos[job_name]["consumes"]  != nil
+          @link_infos[job_name]["consumes"].map { |_, link_info| TemplateLink.parse("consumes", link_info) }
+        else
+          return []
+        end
+      end
+
+      # return [Array]
+      def provided_links(job_name)
+        if @link_infos[job_name] != nil && @link_infos[job_name]["provides"] != nil
+          @link_infos[job_name]["provides"].map { |_, link_info| TemplateLink.parse("provides", link_info) }
+        else
+          return []
+        end
+      end
+
+      def add_link_info(job_name, kind, link_name, source)
+        @link_infos[job_name] ||= {}
+        @link_infos[job_name][kind] ||= {}
+        @link_infos[job_name][kind][link_name] ||= {}
+
+        if source.eql? 'nil'
+          # This is the case where the user set link source to nil explicitly in the deployment manifest
+          # We should skip the binding of this link, even if it exist. This is used only when the link
+          # is optional
+          @link_infos[job_name][kind][link_name]['skip_link'] = true
+        else
+          source.to_a.each do |key, value|
+            @link_infos[job_name][kind][link_name][key] = value
+          end
+        end
+      end
+
+      def consumes_link_info(job_name, link_name)
+        @link_infos.fetch(job_name, {}).fetch('consumes', {}).fetch(link_name, {})
+      end
+
+      def provides_link_info(job_name, link_name)
+        @link_infos.fetch(job_name, {}).fetch('provides', {}).each do |index, link|
+          if link['as'] == link_name
+            return link
+          end
+        end
+        return @link_infos.fetch(job_name, {}).fetch('provides', {}).fetch(link_name, {})
+      end
+
+      def add_template_scoped_properties(template_scoped_properties, deployment_job_name)
+        @template_scoped_properties[deployment_job_name] = template_scoped_properties
+      end
+
+      def has_template_scoped_properties(deployment_job_name)
+        return !@template_scoped_properties[deployment_job_name].nil?
+      end
+
+      def bind_template_scoped_properties(deployment_job_name)
+        bound_template_scoped_properties = {}
+        properties.each_pair do |name, definition|
+          copy_property(
+              bound_template_scoped_properties,
+              @template_scoped_properties[deployment_job_name],
+              name,
+              definition["default"]
+          )
+        end
+        @template_scoped_properties[deployment_job_name] = bound_template_scoped_properties
       end
 
       private
@@ -96,7 +181,7 @@ module Bosh::Director
       # @return [Models::Template]
       def present_model
         if @model.nil?
-          raise DirectorError, "Template `#{@name}' model is unbound"
+          raise DirectorError, "Job '#{@name}' model is unbound"
         end
         @model
       end

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

@@ -62,6 +62,16 @@ module Bosh::Director
         end
       end
 
+      def to_hash
+        {
+          'canaries' => @canaries,
+          'max_in_flight' => @max_in_flight,
+          'canary_watch_time' => "#{@min_canary_watch_time}-#{@max_canary_watch_time}",
+          'update_watch_time' => "#{@min_update_watch_time}-#{@max_update_watch_time}",
+          'serial' => @serial
+        }
+      end
+
       def parse_watch_times(value)
         value = value.to_s
 

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

@@ -0,0 +1,27 @@
+module Bosh::Director
+  module DeploymentPlan
+    class VmExtension
+      include ValidationHelper
+
+      attr_reader :name
+
+      attr_reader :cloud_properties
+
+      def initialize(spec)
+
+        @name = safe_property(spec, "name", class: String)
+
+        @cloud_properties =
+          safe_property(spec, "cloud_properties", class: Hash, default: {})
+
+      end
+
+      def spec
+        {
+          "name" => @name,
+          "cloud_properties" => @cloud_properties,
+        }
+      end
+    end
+  end
+end

data/lib/bosh/director/errand/runner.rb

@@ -18,7 +18,7 @@ module Bosh::Director
     # @return [String] short description of the errand result
     def run(&blk)
       unless instance
-        raise DirectorError, 'Must have at least one job instance to run an errand'
+        raise DirectorError, 'Must have at least one instance group instance to run an errand'
       end
 
       agent_task_result = nil

data/lib/bosh/director/errors.rb

@@ -78,6 +78,7 @@ module Bosh::Director
   ReleaseExistingJobFingerprintMismatch = err(30013)
   ReleaseVersionCommitHashMismatch = err(30014)
   ReleaseSha1DoesNotMatch = err(30015)
+  ReleasePackageDependencyKeyMismatch = err(30016)
 
   ValidationInvalidType = err(40000)
   ValidationMissingField = err(40001)
@@ -139,6 +140,8 @@ module Bosh::Director
   CompilationConfigInvalidAvailabilityZone = err(120002)
   CompilationConfigInvalidVmType = err(120003)
   CompilationConfigCloudPropertiesNotAllowed = err(120004)
+  CompilationConfigInvalidVmExtension = err(120005)
+  CompilationConfigVmTypeRequired = err(120004)
 
   # Manifest parsing: network section
   NetworkReservationInvalidIp = err(130001)
@@ -208,6 +211,7 @@ module Bosh::Director
   DeploymentDuplicateReleaseName = err(190002)
   DeploymentDuplicateResourcePoolName = err(190003)
   DeploymentDuplicateVmTypeName = err(190004)
+  DeploymentDuplicateVmExtensionName = err(190005)
   DeploymentCanonicalJobNameTaken = err(190006)
   DeploymentCanonicalNetworkNameTaken = err(190007)
   DeploymentNoNetworks = err(190008)
@@ -269,6 +273,12 @@ module Bosh::Director
   AttachDiskNoPersistentDisk =  err(520002)
   AttachDiskInvalidInstanceState = err(520003)
 
+  # Addons
+  RuntimeAmbiguousReleaseSpec = err(530000)
+  RuntimeInvalidReleaseVersion = err(530001)
+  RuntimeReleaseNotListedInReleases = err(530002)
+  RuntimeInvalidDeploymentRelease = err(530003)
+
   # Authorization errors
-  UnauthorizedToAccessDeployment = err(600000)
+  UnauthorizedToAccessDeployment = err(600000, UNAUTHORIZED)
 end

data/lib/bosh/director/instance_updater.rb

@@ -43,62 +43,63 @@ module Bosh::Director
       instance = instance_plan.instance
       @logger.info("Updating instance #{instance}, changes: #{instance_plan.changes.to_a.join(', ').inspect}")
 
-      @canary = options.fetch(:canary, false)
+      InstanceUpdater::InstanceState.with_instance_update(instance.model) do
+        # Optimization to only update DNS if nothing else changed.
+        if dns_change_only?(instance_plan)
+          @logger.debug('Only change is DNS configuration')
+          update_dns(instance_plan)
+          return
+        end
 
-      # Optimization to only update DNS if nothing else changed.
-      if dns_change_only?(instance_plan)
-        @logger.debug('Only change is DNS configuration')
-        update_dns(instance_plan)
-        return
-      end
+        unless instance_plan.currently_detached?
+          Preparer.new(instance_plan, agent(instance), @logger).prepare
 
-      unless instance_plan.currently_detached?
-        Preparer.new(instance_plan, agent(instance), @logger).prepare
+          stop(instance_plan)
+          take_snapshot(instance)
+        end
 
-        stop(instance_plan)
-        take_snapshot(instance)
-      end
+        if instance.state == 'detached'
+          @logger.info("Detaching instance #{instance}")
+          unless instance_plan.currently_detached?
+            @disk_manager.unmount_disk_for(instance_plan)
+            instance_model = instance_plan.new? ? instance_plan.instance.model : instance_plan.existing_instance
+            @vm_deleter.delete_for_instance(instance_model)
+          end
+          release_obsolete_ips(instance_plan)
+          instance.update_state
+          return
+        end
 
-      if instance.state == 'detached'
-        @logger.info("Detaching instance #{instance}")
-        unless instance_plan.currently_detached?
+        recreated = false
+        if needs_recreate?(instance_plan)
+          @logger.debug('Failed to update in place. Recreating VM')
           @disk_manager.unmount_disk_for(instance_plan)
-          instance_model = instance_plan.new? ? instance_plan.instance.model : instance_plan.existing_instance
-          @vm_deleter.delete_for_instance(instance_model)
+          @vm_recreator.recreate_vm(instance_plan, nil)
+          recreated = true
         end
-        release_obsolete_ips(instance_plan)
-        instance.update_state
-        return
-      end
-
-      recreated = false
-      if needs_recreate?(instance_plan)
-        @logger.debug('Failed to update in place. Recreating VM')
-        @disk_manager.unmount_disk_for(instance_plan)
-        @vm_recreator.recreate_vm(instance_plan, nil)
-        recreated = true
-      end
 
-      release_obsolete_ips(instance_plan)
+        release_obsolete_ips(instance_plan)
 
-      update_dns(instance_plan)
-      @disk_manager.update_persistent_disk(instance_plan, @vm_recreator)
+        update_dns(instance_plan)
+        @disk_manager.update_persistent_disk(instance_plan, @vm_recreator)
 
-      unless recreated
-        if instance.trusted_certs_changed?
-          @logger.debug('Updating trusted certs')
-          instance.update_trusted_certs
+        unless recreated
+          if instance.trusted_certs_changed?
+            @logger.debug('Updating trusted certs')
+            instance.update_trusted_certs
+          end
         end
-      end
 
-      cleaner = RenderedJobTemplatesCleaner.new(instance.model, @blobstore, @logger)
-      state_applier = InstanceUpdater::StateApplier.new(instance_plan, agent(instance), cleaner, @logger)
-      state_applier.apply
-
-      job = instance_plan.desired_instance.job
-      min_watch_time = get_min_watch_time(job.update)
-      max_watch_time = get_max_watch_time(job.update)
-      state_applier.post_start(min_watch_time, max_watch_time)
+        cleaner = RenderedJobTemplatesCleaner.new(instance.model, @blobstore, @logger)
+        state_applier = InstanceUpdater::StateApplier.new(
+          instance_plan,
+          agent(instance),
+          cleaner,
+          @logger,
+          canary: options[:canary]
+        )
+        state_applier.apply(instance_plan.desired_instance.job.update)
+      end
     end
 
     private
@@ -132,18 +133,6 @@ module Bosh::Director
       @dns_manager.flush_dns_cache
     end
 
-    def get_min_watch_time(update_config)
-      canary? ? update_config.min_canary_watch_time : update_config.min_update_watch_time
-    end
-
-    def get_max_watch_time(update_config)
-      canary? ? update_config.max_canary_watch_time : update_config.max_update_watch_time
-    end
-
-    def canary?
-      @canary
-    end
-
     def dns_change_only?(instance_plan)
       instance_plan.changes.include?(:dns) && instance_plan.changes.size == 1
     end

data/lib/bosh/director/instance_updater/instance_state.rb

@@ -0,0 +1,9 @@
+module Bosh::Director
+  class InstanceUpdater::InstanceState
+    def self.with_instance_update(instance_model)
+      instance_model.update(update_completed: false)
+      yield
+      instance_model.update(update_completed: true)
+    end
+  end
+end

data/lib/bosh/director/instance_updater/state_applier.rb

@@ -1,31 +1,45 @@
 module Bosh::Director
   class InstanceUpdater::StateApplier
-    def initialize(instance_plan, agent_client, rendered_job_templates_cleaner, logger)
+    def initialize(instance_plan, agent_client, rendered_job_templates_cleaner, logger, options)
       @instance_plan = instance_plan
       @instance = @instance_plan.instance
       @agent_client = agent_client
       @rendered_job_templates_cleaner = rendered_job_templates_cleaner
       @logger = logger
+      @is_canary = options.fetch(:canary, false)
     end
 
-    def apply
+    def apply(update_config)
       @instance.apply_vm_state(@instance_plan.spec)
       @instance.update_templates(@instance_plan.templates)
       @rendered_job_templates_cleaner.clean
 
       if @instance.state == 'started'
+        @logger.info("Running pre-start for #{@instance}")
         @agent_client.run_script('pre-start', {})
+
+        @logger.info("Starting instance #{@instance}")
         @agent_client.start
       end
+
+      # for backwards compatibility with instances that don't have update config
+      if update_config
+        min_watch_time = @is_canary ? update_config.min_canary_watch_time : update_config.min_update_watch_time
+        max_watch_time = @is_canary ? update_config.max_canary_watch_time : update_config.max_update_watch_time
+
+        post_start(min_watch_time, max_watch_time)
+      end
     end
 
+    private
+
     def post_start(min_watch_time, max_watch_time)
       current_state = wait_until_desired_state(min_watch_time, max_watch_time)
 
       if @instance.state == 'started'
         if current_state['job_state'] != 'running'
           failing_jobs = Array(current_state['processes']).map do |process|
-            process['name'] if process['state'] != 'starting' && process['state'] != 'running'
+            process['name'] if process['state'] != 'running'
           end.compact
 
           error_message = "`#{@instance}' is not running after update."
@@ -33,6 +47,7 @@ module Bosh::Director
 
           raise AgentJobNotRunning, error_message
         else
+          @logger.info("Running post-start for #{@instance}")
           @agent_client.run_script('post-start', {})
         end
       end
@@ -44,8 +59,6 @@ module Bosh::Director
       @instance.update_state
     end
 
-    private
-
     def wait_until_desired_state(min_watch_time, max_watch_time)
       current_state = {}
       watch_schedule(min_watch_time, max_watch_time).each do |watch_time|