bosh-director 1.5.0.pre.1113

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

@@ -0,0 +1,52 @@
+module Bosh::Director
+  module DeploymentPlan
+    class Preparer
+      def initialize(job, compiler)
+        @job = job
+        @assembler = compiler
+      end
+
+      def prepare
+        job.track_and_log('Binding deployment') do
+          @assembler.bind_deployment
+        end
+
+        job.track_and_log('Binding releases') do
+          @assembler.bind_releases
+        end
+
+        job.track_and_log('Binding existing deployment') do
+          @assembler.bind_existing_deployment
+        end
+
+        job.track_and_log('Binding resource pools') do
+          @assembler.bind_resource_pools
+        end
+
+        job.track_and_log('Binding stemcells') do
+          @assembler.bind_stemcells
+        end
+
+        job.track_and_log('Binding templates') do
+          @assembler.bind_templates
+        end
+
+        job.track_and_log('Binding properties') do
+          @assembler.bind_properties
+        end
+
+        job.track_and_log('Binding unallocated VMs') do
+          @assembler.bind_unallocated_vms
+        end
+
+        job.track_and_log('Binding instance networks') do
+          @assembler.bind_instance_networks
+        end
+      end
+
+      private
+
+      attr_reader :job
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module DeploymentPlan
+    class Release
+      include ValidationHelper
+
+      # @return [String] Release name
+      attr_reader :name
+      # @return [String] Release version
+      attr_reader :version
+      # @return [Models::ReleaseVersion] Release version model
+      attr_reader :model
+
+      # @param [DeploymentPlan] deployment_plan Deployment plan
+      # @param [Hash] spec Raw release spec from the deployment
+      #   manifest
+      def initialize(deployment_plan, spec)
+        @deployment_plan = deployment_plan
+
+        @name = safe_property(spec, "name", :class => String)
+        @version = safe_property(spec, "version", :class => String)
+
+        @model = nil
+        @templates = {}
+
+        @logger = Config.logger
+        @manager = Api::ReleaseManager.new
+      end
+
+      # Looks up release version in database and binds it to the deployment
+      # @return [void]
+      def bind_model
+        deployment = @deployment_plan.model
+        if deployment.nil?
+          raise DirectorError, "Deployment not bound in the deployment plan"
+        end
+
+        release = @manager.find_by_name(@name)
+        @model = @manager.find_version(release, @version)
+        @logger.debug("Found release `#{@name}/#{@version}'")
+
+        unless deployment.release_versions.include?(@model)
+          @logger.debug("Binding release `#{@name}/#{@version}' " +
+                        "to deployment `#{deployment.name}'")
+          deployment.add_release_version(@model)
+        end
+      end
+
+      # Looks up package and template models in DB and binds them to this
+      # release spec
+      # @return [void]
+      def bind_templates
+        # Release version model needs to be known so we can look up its
+        # templates
+        if @model.nil?
+          raise DirectorError, "Release model not bound in release spec"
+        end
+
+        # By now job specs from the deployment manifest should
+        # have been parsed, so we can assume @templates contains
+        # the list of templates that need to be bound
+        @templates.each_value do |template|
+          @logger.debug("Binding template `#{template.name}'")
+          template.bind_models
+          @logger.debug("Bound template `#{template.name}'")
+        end
+      end
+
+      # @return [Hash] Hash representation
+      def spec
+        {
+          "name" => @name,
+          "version" => @version
+        }
+      end
+
+      # Looks up up template model by template name
+      # @param [String] name Template name
+      # @return [Models::Template]
+      def get_template_model_by_name(name)
+        @all_templates ||= @model.templates.inject({}) do |hash, template|
+          hash[template.name] = template
+          hash
+        end
+
+        @all_templates[name]
+      end
+
+      # Looks up up package model by package name
+      # @param [String] name Package name
+      # @return [Models::Package]
+      def get_package_model_by_name(name)
+        @all_packages ||= @model.packages.inject({}) do |hash, package|
+          hash[package.name] = package
+          hash
+        end
+
+        @all_packages[name]
+      end
+
+      # Adds template to a list of templates used by this release for the
+      # current deployment
+      # @param [String] template_name Template name
+      def use_template_named(template_name)
+        @templates[template_name] ||= Template.new(self, template_name)
+      end
+
+      # @param [String] name Template name
+      # @return [DeploymentPlan::Template] Template with given name used by this
+      #   release (if any)
+      def template(name)
+        @templates[name]
+      end
+
+      # Returns a list of job templates that need to be included into this
+      # release. Note that this is not just a list of all templates existing
+      # in the release but rather a list of templates for jobs that are included
+      # into current deployment plan.
+      # @return [Array<DeploymentPlan::Template>] List of job templates
+      def templates
+        @templates.values
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module DeploymentPlan
+    class ResourcePool
+      include ValidationHelper
+
+      # @return [String] Resource pool name
+      attr_reader :name
+
+      # @return [Integer] Expected resource pool size (in VMs)
+      attr_reader :size
+
+      # @return [DeploymentPlan] Deployment plan
+      attr_reader :deployment_plan
+
+      # @return [DeploymentPlan::Stemcell] Stemcell spec
+      attr_reader :stemcell
+
+      # @return [DeploymentPlan::Network] Network spec
+      attr_reader :network
+
+      # @return [Hash] Cloud properties
+      attr_reader :cloud_properties
+
+      # @return [Hash] Resource pool environment
+      attr_reader :env
+
+      # @return [Array<DeploymentPlan::IdleVm>] List of idle VMs
+      attr_reader :idle_vms
+
+      # @return [Array<DeploymentPlan::IdleVm] List of allocated idle VMs
+      attr_reader :allocated_vms
+
+      # @return [Integer] Number of active resource pool VMs
+      attr_reader :active_vm_count
+
+      # @param [DeploymentPlan] deployment_plan Deployment plan
+      # @param [Hash] spec Raw resource pool spec from the deployment manifest
+      def initialize(deployment_plan, spec)
+        @deployment_plan = deployment_plan
+
+        @name = safe_property(spec, "name", :class => String)
+        @size = safe_property(spec, "size", :class => Integer)
+
+        @cloud_properties =
+          safe_property(spec, "cloud_properties", :class => Hash)
+
+        stemcell_spec = safe_property(spec, "stemcell", :class => Hash)
+        @stemcell = Stemcell.new(self, stemcell_spec)
+
+        network_name = safe_property(spec, "network", :class => String)
+        @network = @deployment_plan.network(network_name)
+
+        if @network.nil?
+          raise ResourcePoolUnknownNetwork,
+                "Resource pool `#{@name}' references " +
+                "an unknown network `#{network_name}'"
+        end
+
+        @env = safe_property(spec, "env", :class => Hash, :default => {})
+
+        @idle_vms = []
+        @allocated_vms = []
+        @active_vm_count = 0
+        @required_capacity = 0
+      end
+
+      # Returns resource pools spec as Hash (usually for agent to serialize)
+      # @return [Hash] Resource pool spec
+      def spec
+        {
+          "name" => @name,
+          "cloud_properties" => @cloud_properties,
+          "stemcell" => @stemcell.spec
+        }
+      end
+
+      # Creates IdleVm objects for any missing resource pool VMs and reserves
+      # dynamic networks for all idle VMs.
+      # @return [void]
+      def process_idle_vms
+        # First, see if we need any data structures to balance the pool size
+        missing_vm_count.times { add_idle_vm }
+
+        # Second, see if some of idle VMs still need network reservations
+        idle_vms.each do |idle_vm|
+          unless idle_vm.has_network_reservation?
+            idle_vm.use_reservation(reserve_dynamic_network)
+          end
+        end
+      end
+
+      # Tries to obtain one dynamic reservation in its own network
+      # @raise [NetworkReservationError]
+      # @return [NetworkReservation] Obtained reservation
+      def reserve_dynamic_network
+        reservation = NetworkReservation.new_dynamic
+        @network.reserve!(reservation, "Resource pool `#{@name}'")
+        reservation
+      end
+
+      # Returns a number of VMs that need to be created in order to bring
+      # this resource pool to a desired size
+      # @return [Integer]
+      def missing_vm_count
+        @size - @active_vm_count - @idle_vms.size
+      end
+
+      # Adds a new VM to a list of managed idle VMs
+      def add_idle_vm
+        idle_vm = IdleVm.new(self)
+        @idle_vms << idle_vm
+        idle_vm
+      end
+
+      def allocate_vm
+        allocated_vm = @idle_vms.pop
+        @allocated_vms << allocated_vm
+        allocated_vm
+      end
+
+      # "Active" VM is a VM that is currently running a job
+      # @return [void]
+      def mark_active_vm
+        @active_vm_count += 1
+      end
+
+      # Checks if there is enough capacity to run extra N VMs,
+      # raise error if not enough capacity
+      # @raise [ResourcePoolNotEnoughCapacity]
+      # @return [void]
+      def reserve_capacity(n)
+        @required_capacity += n
+        if @required_capacity > @size
+          raise ResourcePoolNotEnoughCapacity,
+                "Resource pool `#{@name}' is not big enough: " +
+                "#{@required_capacity} VMs needed, capacity is #{@size}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Bosh::Director
+  module DeploymentPlan
+    class ResourcePools
+      def initialize(event_log, resource_pool_updaters)
+        @event_log = event_log
+        @resource_pool_updaters = resource_pool_updaters
+      end
+
+      def update
+        ThreadPool.new(:max_threads => Config.max_threads).wrap do |thread_pool|
+          # Delete extra VMs across resource pools
+          event_log.begin_stage('Deleting extra VMs', sum_across_pools(:extra_vm_count))
+          resource_pool_updaters.each do |updater|
+            updater.delete_extra_vms(thread_pool)
+          end
+          thread_pool.wait
+
+          # Delete outdated idle vms across resource pools, outdated allocated
+          # VMs are handled by instance updater
+          event_log.begin_stage('Deleting outdated idle VMs', sum_across_pools(:outdated_idle_vm_count))
+
+          resource_pool_updaters.each do |updater|
+            updater.delete_outdated_idle_vms(thread_pool)
+          end
+          thread_pool.wait
+
+          # Create missing VMs across resource pools phase 1:
+          # only creates VMs that have been bound to instances
+          # to avoid refilling the resource pool before instances
+          # that are no longer needed have been deleted.
+          event_log.begin_stage('Creating bound missing VMs', sum_across_pools(:bound_missing_vm_count))
+          resource_pool_updaters.each do |updater|
+            updater.create_bound_missing_vms(thread_pool)
+          end
+        end
+      end
+
+      def refill
+        # Instance updaters might have added some idle vms
+        # so they can be returned to resource pool. In that case
+        # we need to pre-allocate network settings for all of them.
+        resource_pool_updaters.each do |resource_pool_updater|
+          resource_pool_updater.reserve_networks
+        end
+
+        event_log.begin_stage('Refilling resource pools', sum_across_pools(:missing_vm_count))
+        ThreadPool.new(:max_threads => Config.max_threads).wrap do |thread_pool|
+          # Create missing VMs across resource pools phase 2:
+          # should be called after all instance updaters are finished to
+          # create additional VMs in order to balance resource pools
+          resource_pool_updaters.each do |resource_pool_updater|
+            resource_pool_updater.create_missing_vms(thread_pool)
+          end
+        end
+      end
+
+      private
+
+      attr_reader :event_log, :resource_pool_updaters
+
+      def sum_across_pools(counting_method)
+        resource_pool_updaters.inject(0) do |sum, updater|
+          sum + updater.send(counting_method.to_sym)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module DeploymentPlan
+    class Stemcell
+      include ValidationHelper
+
+      # @return [DeploymentPlan::ResourcePool] Resource pool
+      attr_reader :resource_pool
+
+      # @return [String] Stemcell name
+      attr_reader :name
+
+      # @return [String] Stemcell version
+      attr_reader :version
+
+      # @return [Models::Stemcell] Stemcell DB model
+      attr_reader :model
+
+      # @param [DeploymentPlan::ResourcePool] resource_pool Resource pool
+      #   this stemcell belongs to
+      # @param [Hash] spec Raw stemcell spec according to deployment manifest
+      def initialize(resource_pool, spec)
+        @resource_pool = resource_pool
+        @name = safe_property(spec, "name", :class => String)
+        @version = safe_property(spec, "version", :class => String)
+
+        @manager = Api::StemcellManager.new
+        @model = nil
+      end
+
+      # Looks up the stemcell matching provided spec
+      # @return [void]
+      def bind_model
+        deployment = @resource_pool.deployment_plan.model
+        if deployment.nil?
+          raise DirectorError, "Deployment not bound in the deployment plan"
+        end
+
+        @model = @manager.find_by_name_and_version(@name, @version)
+
+        unless @model.deployments.include?(deployment)
+          @model.add_deployment(deployment)
+        end
+      end
+
+      def spec
+        {
+          "name" => @name,
+          "version" => @version
+        }
+      end
+
+    end
+  end
+end