bosh-director 1.3160.0 → 1.3163.0

data/lib/bosh/director/deployment_plan/placement_planner/placed_desired_instances.rb

@@ -0,0 +1,40 @@
+module Bosh
+  module Director
+    module DeploymentPlan
+      module PlacementPlanner
+        class PlacedDesiredInstances
+          attr_reader :absent, :existing
+
+          def initialize(azs)
+            @placed = {}
+            (azs || []).each do |az|
+              @placed[az] = []
+            end
+
+            @absent = []
+            @existing = []
+          end
+
+          def record_placement(az, desired_instance, existing_instance_model)
+            desired_instance.az = az
+            @placed[az] = @placed.fetch(az, []) << desired_instance
+
+            if existing_instance_model
+              existing << {
+                desired_instance: desired_instance,
+                existing_instance_model: existing_instance_model
+              }
+            else
+              absent << desired_instance
+            end
+          end
+
+          def azs_with_fewest_instances
+            az_with_fewest = @placed.keys.min_by { |az|@placed[az].size }
+            @placed.keys.select { |az| (@placed[az].size == @placed[az_with_fewest].size) && az }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/placement_planner/plan.rb

@@ -0,0 +1,42 @@
+module Bosh
+  module Director
+    module DeploymentPlan
+      module PlacementPlanner
+        class Plan
+          def initialize(instance_plan_factory, network_planner, logger)
+            @instance_plan_factory = instance_plan_factory
+            @network_planner = network_planner
+            @logger = logger
+          end
+
+          def create_instance_plans(desired, existing, networks, availability_zones, job_name)
+            sorted_existing = existing.sort_by(&:index)
+            instance_plans = assign_zones(desired, sorted_existing, networks, availability_zones, job_name)
+
+            instance_plans.reject(&:obsolete?).each do |instance_plan|
+              @logger.debug("Assigning az '#{instance_plan.desired_instance.availability_zone}' to instance '#{instance_plan.instance}'")
+              instance_plan.instance.assign_availability_zone(instance_plan.desired_instance.az)
+            end
+            instance_plans
+          end
+
+          private
+
+          def assign_zones(desired, existing, networks, availability_zones, job_name)
+            if has_static_ips?(networks)
+              @logger.debug("Job '#{job_name}' has networks with static IPs, placing instances based on static IP distribution")
+              StaticIpsAvailabilityZonePicker.new(@instance_plan_factory, @network_planner, networks, job_name, availability_zones, @logger).place_and_match_in(desired, existing)
+            else
+              @logger.debug("Job '#{job_name}' does not have networks with static IPs, placing instances based on persistent disk allocation")
+              AvailabilityZonePicker.new(@instance_plan_factory, @network_planner, networks, availability_zones).place_and_match_in(desired, existing)
+            end
+          end
+
+          def has_static_ips?(networks)
+            !networks.nil? && networks.any? { |network| !! network.static_ips }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/placement_planner/static_ips_availability_zone_picker.rb

@@ -0,0 +1,237 @@
+module Bosh
+  module Director
+    module DeploymentPlan
+      module PlacementPlanner
+        class StaticIpsAvailabilityZonePicker
+          include IpUtil
+
+          def initialize(instance_plan_factory, network_planner, job_networks, job_name, desired_azs, logger)
+            @instance_plan_factory = instance_plan_factory
+            @network_planner = network_planner
+            @job_networks = job_networks
+            @job_name = job_name
+            @networks_to_static_ips = NetworksToStaticIps.create(@job_networks, desired_azs, job_name)
+            @desired_azs = desired_azs
+            @logger = logger
+          end
+
+          def place_and_match_in(desired_instances, existing_instance_models)
+            @networks_to_static_ips.validate_azs_are_declared_in_job_and_subnets(@desired_azs)
+            @networks_to_static_ips.validate_ips_are_in_desired_azs(@desired_azs)
+            desired_instances = desired_instances.dup
+
+            instance_plans = place_existing_instance_plans(desired_instances, existing_instance_models)
+            place_new_instance_plans(desired_instances, instance_plans)
+          end
+
+          private
+
+          def place_existing_instance_plans(desired_instances, existing_instance_models)
+            instance_plans = []
+            # create existing instance plans with network plans that use specified static IPs
+            existing_instance_models.each do |existing_instance_model|
+              instance_plan = create_instance_plan_based_on_existing_ips(desired_instances, existing_instance_model)
+              instance_plans << instance_plan if instance_plan
+            end
+
+            # create the rest existing instance plans
+            existing_instance_models.each do |existing_instance_model|
+              unless already_has_instance_plan?(existing_instance_model, instance_plans)
+                instance_plans << create_existing_instance_plan_with_az_validation(desired_instances, instance_plans, existing_instance_model)
+              end
+            end
+
+            # fulfill missing network plans
+            instance_plans.reject(&:obsolete?).each do |instance_plan|
+              @job_networks.each do |network|
+                unless network.static?
+                  instance_plan.network_plans << @network_planner.network_plan_with_dynamic_reservation(instance_plan, network)
+                  next
+                end
+
+                unless instance_plan.network_plan_for_network(network.deployment_network)
+                  instance_plan.network_plans << create_network_plan_with_az(instance_plan, network, instance_plans)
+                end
+              end
+            end
+
+            instance_plans
+          end
+
+          def place_new_instance_plans(desired_instances, instance_plans)
+            @networks_to_static_ips.distribute_evenly_per_zone
+
+            desired_instances.each do |desired_instance|
+              instance_plan = @instance_plan_factory.desired_new_instance_plan(desired_instance)
+              @job_networks.each do |network|
+                unless network.static?
+                  instance_plan.network_plans << @network_planner.network_plan_with_dynamic_reservation(instance_plan, network)
+                  next
+                end
+
+                instance_plan.network_plans << create_network_plan_with_az(instance_plan, network, instance_plans)
+              end
+
+              instance_plans << instance_plan
+            end
+
+            instance_plans
+          end
+
+          def create_network_plan_with_az(instance_plan, network, instance_plans)
+            desired_instance = instance_plan.desired_instance
+            instance = instance_plan.instance
+            if desired_instance.az.nil?
+              static_ip_to_azs = @networks_to_static_ips.next_ip_for_network(network)
+              if static_ip_to_azs.az_names.size == 1
+                az_name = static_ip_to_azs.az_names.first
+                @logger.debug("Assigning az '#{az_name}' to instance '#{instance}'")
+              else
+                az_name = find_az_name_with_least_number_of_instances(static_ip_to_azs.az_names, instance_plans)
+                @logger.debug("Assigning az '#{az_name}' to instance '#{instance}' based on least number of instances")
+              end
+              desired_instance.az = to_az(az_name)
+            else
+              static_ip_to_azs = @networks_to_static_ips.find_by_network_and_az(network, desired_instance.availability_zone)
+            end
+            if static_ip_to_azs.nil?
+              raise Bosh::Director::NetworkReservationError,
+                    'Failed to distribute static IPs to satisfy existing instance reservations'
+            end
+
+            @logger.debug("Claiming IP '#{format_ip(static_ip_to_azs.ip)}' on network #{network.name} and az '#{desired_instance.availability_zone}' for instance '#{instance}'")
+            @networks_to_static_ips.claim_in_az(static_ip_to_azs.ip, desired_instance.availability_zone)
+
+            @network_planner.network_plan_with_static_reservation(instance_plan, network, static_ip_to_azs.ip)
+          end
+
+          def create_instance_plan_based_on_existing_ips(desired_instances, existing_instance_model)
+            instance_plan = nil
+            @job_networks.each do |network|
+              next unless network.static?
+              instance_ips_on_network = find_instance_ips_on_network(existing_instance_model, network)
+              network_plan = nil
+
+              instance_ips_on_network.each do |instance_ip|
+                ip_address = instance_ip.address
+                # Instance is using IP in static IPs list, we have to use this instance
+                @logger.debug("Existing instance '#{instance_name(existing_instance_model)}' is using static IP '#{format_ip(ip_address)}' on network '#{network.name}'")
+                if instance_plan.nil?
+                  desired_instance = desired_instances.shift
+                  instance_plan = create_existing_instance_plan_with_az(desired_instance, existing_instance_model, network, ip_address)
+                  instance_plan
+                end
+
+                if network_plan.nil? && instance_plan.desired_instance
+                  create_network_plan_with_ip(instance_plan, network, ip_address)
+                end
+
+                if instance_plan.desired_instance.nil?
+                  # delete so that other instances not reusing ips of existing instance
+                  # obsolete instances should not affect distribution
+                  @networks_to_static_ips.delete(ip_address)
+                else
+                  # put ip in az where existing instance is so that
+                  # during distribution it will be taken into account
+                  @networks_to_static_ips.claim_in_az(ip_address, instance_plan.desired_instance.availability_zone)
+                end
+              end
+            end
+
+            instance_plan
+          end
+
+          def find_instance_ips_on_network(existing_instance_model, network)
+            existing_instance_model.ip_addresses.select { |ip_address| network.static_ips.include?(ip_address.address) }
+          end
+
+          def already_has_instance_plan?(existing_instance_model, instance_plans)
+            instance_plans.map(&:existing_instance).include?(existing_instance_model)
+          end
+
+          def create_existing_instance_plan_with_az(desired_instance, existing_instance_model, network, ip_address)
+            instance_plan = create_existing_instance_plan(desired_instance, existing_instance_model)
+            unless instance_plan.obsolete?
+              assign_az_based_on_ip(desired_instance, existing_instance_model, network, ip_address)
+            end
+            instance_plan
+          end
+
+          def assign_az_based_on_ip(desired_instance, existing_instance_model, network, ip_address)
+            ip_az_names = @networks_to_static_ips.find_by_network_and_ip(network, ip_address).az_names
+            if ip_az_names.include?(existing_instance_model.availability_zone)
+              az_name = existing_instance_model.availability_zone
+              @logger.debug("Instance '#{instance_name(existing_instance_model)}' belongs to az '#{az_name}' that is in subnet az list, reusing instance az.")
+            else
+              raise Bosh::Director::NetworkReservationError,
+                "Existing instance '#{instance_name(existing_instance_model)}' is using IP '#{format_ip(ip_address)}' in availability zone '#{existing_instance_model.availability_zone}'"
+            end
+            desired_instance.az = to_az(az_name)
+          end
+
+          def create_existing_instance_plan_with_az_validation(desired_instances, instance_plans, existing_instance_model)
+            if desired_instances.empty?
+              @logger.debug("Marking instance '#{instance_name(existing_instance_model)}' as obsolete")
+              @instance_plan_factory.obsolete_instance_plan(existing_instance_model)
+            else
+              # we can only reuse an instance if its AZ contains enough IPs for its networks
+
+              instance_az_name = existing_instance_model.availability_zone
+              @job_networks.each do |network|
+                next unless network.static?
+                static_ip_to_azs = @networks_to_static_ips.find_by_network_and_az(network, instance_az_name)
+                if static_ip_to_azs.nil?
+                  @logger.debug("Marking instance '#{instance_name(existing_instance_model)}' as obsolete, not enough IPs in instance az")
+                  return @instance_plan_factory.obsolete_instance_plan(existing_instance_model)
+                end
+              end
+
+              # we have enough IPs to fit an instance in its AZ
+              @logger.debug("Reusing instance '#{instance_name(existing_instance_model)}' with new IPs")
+              desired_instance = desired_instances.shift
+              desired_instance.az = to_az(instance_az_name)
+              instance_plan = @instance_plan_factory.desired_existing_instance_plan(existing_instance_model, desired_instance)
+              @job_networks.each do |network|
+                next unless network.static?
+                instance_plan.network_plans << create_network_plan_with_az(instance_plan, network, instance_plans)
+              end
+
+              instance_plan
+            end
+          end
+
+          def create_existing_instance_plan(desired_instance, existing_instance_model)
+            if desired_instance.nil?
+              @instance_plan_factory.obsolete_instance_plan(existing_instance_model, desired_instance)
+            else
+              @instance_plan_factory.desired_existing_instance_plan(existing_instance_model, desired_instance)
+            end
+          end
+
+          def create_network_plan_with_ip(instance_plan, network, ip_address)
+            instance_az = instance_plan.desired_instance.az
+            instance_az_name = instance_az.nil? ? nil : instance_az.name
+            ip_az_names = @networks_to_static_ips.find_by_network_and_ip(network, ip_address).az_names
+            if ip_az_names.include?(instance_az_name)
+              instance_plan.network_plans << @network_planner.network_plan_with_static_reservation(instance_plan, network, ip_address)
+            end
+          end
+
+          def find_az_name_with_least_number_of_instances(az_names, instance_plans)
+            az_names.sort_by do |az_name|
+              instance_plans.select { |instance_plan| instance_plan.desired_instance.availability_zone == az_name }.size
+            end.first
+          end
+
+          def to_az(az_name)
+            @desired_azs.to_a.find { |az| az.name == az_name }
+          end
+
+          def instance_name(existing_instance_model)
+            "#{existing_instance_model.job}/#{existing_instance_model.index}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/placement_planner/unplaced_existing_instances.rb

@@ -0,0 +1,53 @@
+module Bosh
+  module Director
+    module DeploymentPlan
+      module PlacementPlanner
+        class UnplacedExistingInstances
+          def initialize(existing_instance_models)
+            @instances = existing_instance_models.sort_by { |instance_model| instance_model.index }
+            @az_name_to_existing_instances  = initialize_azs_to_instances
+          end
+
+          def instances_with_persistent_disk
+            @instances.select do |instance_model|
+              instance_model.persistent_disks && instance_model.persistent_disks.count > 0
+            end
+          end
+
+          def azs_sorted_by_existing_instance_count_descending(azs)
+            return nil if azs.nil?
+            azs.sort_by { |az| - @az_name_to_existing_instances.fetch(az.name, []).size }
+          end
+
+          def claim_instance(existing_instance)
+            @az_name_to_existing_instances[existing_instance.availability_zone].delete(existing_instance)
+          end
+
+          def claim_instance_for_az(az)
+            az_name = az.nil? ? nil : az.name
+            instances = @az_name_to_existing_instances[az_name]
+            unless instances.nil? || instances.empty?
+              instances.shift
+            end
+          end
+
+          def unclaimed
+            @az_name_to_existing_instances.values.flatten
+          end
+
+          private
+
+          def initialize_azs_to_instances
+            az_name_to_existing_instances = {}
+            @instances.each do |instance|
+              instances = az_name_to_existing_instances.fetch(instance.availability_zone, [])
+              instances << instance
+              az_name_to_existing_instances[instance.availability_zone] = instances
+            end
+            az_name_to_existing_instances
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 require 'bosh/director/deployment_plan/deployment_spec_parser'
 require 'bosh/director/deployment_plan/cloud_manifest_parser'
-require 'bosh/director/deployment_plan/disk_pool'
+require 'bosh/director/deployment_plan/disk_type'
 require 'forwardable'
 require 'common/deep_copy'
 
@@ -10,7 +10,6 @@ module Bosh::Director
   module DeploymentPlan
     class Planner
       include LockHelper
-      include DnsHelper
       include ValidationHelper
       extend Forwardable
 
@@ -25,6 +24,11 @@ module Bosh::Director
 
       attr_accessor :properties
 
+      # Hash of resolved links spec provided by deployment
+      # in format job_name > template_name > link_name > link_type
+      # used by LinksResolver
+      attr_accessor :link_spec
+
       # @return [Bosh::Director::DeploymentPlan::UpdateConfig]
       #   Default job update configuration
       attr_accessor :update
@@ -33,59 +37,134 @@ module Bosh::Director
       #   All jobs in the deployment
       attr_reader :jobs
 
+      # Stemcells in deployment by alias
+      attr_reader :stemcells
+
       # Job instances from the old manifest that are not in the new manifest
-      attr_accessor :unneeded_instances
+      attr_reader :unneeded_instances
 
       # VMs from the old manifest that are not in the new manifest
       attr_accessor :unneeded_vms
 
-      attr_accessor :dns_domain
-
       attr_reader :job_rename
 
       # @return [Boolean] Indicates whether VMs should be recreated
       attr_reader :recreate
 
+      attr_writer :cloud_planner
+
       # @return [Boolean] Indicates whether VMs should be drained
       attr_reader :skip_drain
 
       def initialize(attrs, manifest_text, cloud_config, deployment_model, options = {})
+        @cloud_config = cloud_config
+
         @name = attrs.fetch(:name)
         @properties = attrs.fetch(:properties)
         @releases = {}
 
         @manifest_text = Bosh::Common::DeepCopy.copy(manifest_text)
         @cloud_config = cloud_config
-        @cloud_planner = CloudPlanner.new(cloud_config)
         @model = deployment_model
 
+        @stemcells = {}
         @jobs = []
         @jobs_name_index = {}
         @jobs_canonical_name_index = Set.new
 
         @unneeded_vms = []
         @unneeded_instances = []
-        @dns_domain = nil
 
         @job_rename = safe_property(options, 'job_rename',
           :class => Hash, :default => {})
 
         @recreate = !!options['recreate']
+
+        @link_spec = Hash.new{ |h,k| h[k] = Hash.new(&h.default_proc) }
         @skip_drain = SkipDrain.new(options['skip_drain'])
+
+        @logger = Config.logger
       end
 
-      def_delegators :@cloud_planner, :add_network, :networks, :network,
-        :add_resource_pool, :resource_pools, :resource_pool,
-        :add_disk_pool, :disk_pools, :disk_pool,
-        :compilation, :compilation=
+      def_delegators :@cloud_planner,
+        :networks,
+        :network,
+        :deleted_network,
+        :availability_zone,
+        :availability_zones,
+        :resource_pools,
+        :resource_pool,
+        :vm_types,
+        :vm_type,
+        :add_resource_pool,
+        :disk_types,
+        :disk_type,
+        :compilation,
+        :ip_provider
 
       def canonical_name
-        canonical(@name)
+        Canonicalizer.canonicalize(@name)
+      end
+
+      def bind_models
+        stemcell_manager = Api::StemcellManager.new
+        dns_manager = DnsManager.create
+        assembler = DeploymentPlan::Assembler.new(
+          self,
+          stemcell_manager,
+          dns_manager,
+          Config.cloud,
+          @logger
+        )
+
+        assembler.bind_models
+      end
+
+      def compile_packages
+        validate_packages
+
+        cloud = Config.cloud
+        vm_deleter = VmDeleter.new(cloud, @logger)
+        disk_manager = DiskManager.new(cloud, @logger)
+        job_renderer = JobRenderer.create
+        vm_creator = Bosh::Director::VmCreator.new(cloud, @logger, vm_deleter, disk_manager, job_renderer)
+        dns_manager = DnsManager.create
+        instance_deleter = Bosh::Director::InstanceDeleter.new(ip_provider, dns_manager, disk_manager)
+        compilation_instance_pool = CompilationInstancePool.new(InstanceReuser.new, vm_creator, self, @logger, instance_deleter)
+        package_compile_step = DeploymentPlan::Steps::PackageCompileStep.new(
+          jobs,
+          compilation,
+          compilation_instance_pool,
+          @logger,
+          Config.event_log,
+          nil
+        )
+        package_compile_step.perform
+      end
+
+      # Returns a list of Instances in the deployment (according to DB)
+      # @return [Array<Models::Instance>]
+      def instance_models
+        @model.instances
+      end
+
+      def existing_instances
+        instance_models
+      end
+
+      def candidate_existing_instances
+        desired_job_names = jobs.map(&:name)
+        migrating_job_names = jobs.map(&:migrated_from).flatten.map(&:name)
+
+        existing_instances.select do |instance|
+          desired_job_names.include?(instance.job) ||
+            migrating_job_names.include?(instance.job)
+        end
       end
 
-      # Returns a list of VMs in the deployment (according to DB)
+      # Returns a list of Vms in the deployment (according to DB)
       # @return [Array<Models::Vm>]
-      def vms
+      def vm_models
         @model.vms
       end
 
@@ -93,6 +172,14 @@ module Bosh::Director
         @skip_drain.nil? ? false : @skip_drain.for_job(name)
       end
 
+      def add_stemcell(stemcell)
+        @stemcells[stemcell.alias] = stemcell
+      end
+
+      def stemcell(name)
+        @stemcells[name]
+      end
+
       # Adds a release by name
       # @param [Bosh::Director::DeploymentPlan::ReleaseVersion] release
       def add_release(release)
@@ -117,20 +204,20 @@ module Bosh::Director
 
       # Adds a VM to deletion queue
       # @param [Bosh::Director::Models::Vm] vm VM DB model
-      def delete_vm(vm)
+      def mark_vm_for_deletion(vm)
         @unneeded_vms << vm
       end
 
-      # Adds instance to deletion queue
-      # @param [Bosh::Director::Models::Instance] instance Instance DB model
-      def delete_instance(instance)
-        if @jobs_name_index.has_key?(instance.job)
-          @jobs_name_index[instance.job].unneeded_instances << instance
-        else
-          @unneeded_instances << instance
+      def instance_plans_with_missing_vms
+        jobs_starting_on_deploy.collect_concat do |job|
+          job.instance_plans_with_missing_vms
         end
       end
 
+      def mark_instance_for_deletion(instance)
+        @unneeded_instances << instance
+      end
+
       # Adds a job by name
       # @param [Bosh::Director::DeploymentPlan::Job] job
       def add_job(job)
@@ -157,10 +244,6 @@ module Bosh::Director
         @jobs_name_index[name]
       end
 
-      def reset_jobs
-        @jobs = []
-      end
-
       def jobs_starting_on_deploy
         @jobs.select(&:starts_on_deploy?)
       end
@@ -182,96 +265,125 @@ module Bosh::Director
 
         model.manifest = Psych.dump(@manifest_text)
         model.cloud_config = @cloud_config
+        model.link_spec = @link_spec
         model.save
       end
 
       def update_stemcell_references!
         current_stemcell_models = resource_pools.map { |pool| pool.stemcell.model }
+        @stemcells.values.map(&:model).each do |stemcell|
+          current_stemcell_models << stemcell
+        end
         model.stemcells.each do |deployment_stemcell|
           deployment_stemcell.remove_deployment(model) unless current_stemcell_models.include?(deployment_stemcell)
         end
       end
+
+      def using_global_networking?
+        !@cloud_config.nil?
+      end
+
+      private
+
+      def validate_packages
+        release_manager = Bosh::Director::Api::ReleaseManager.new
+        validator = DeploymentPlan::PackageValidator.new(@logger)
+        jobs.each do |job|
+          job.templates.each do |template|
+            release_model = release_manager.find_by_name(template.release.name)
+            release_version_model = release_manager.find_version(release_model, template.release.version)
+
+            validator.validate(release_version_model, job.stemcell.model)
+          end
+        end
+        validator.handle_faults
+      end
     end
 
     class CloudPlanner
-      # @return [Bosh::Director::DeploymentPlan::CompilationConfig]
-      #   Resource pool and other configuration for compilation workers
       attr_accessor :compilation
 
-      def initialize(cloud_config)
-        @cloud_config = cloud_config
-        @networks_canonical_name_index = Set.new
+      def initialize(options)
+        @networks = self.class.index_by_name(options.fetch(:networks))
+        @global_network_resolver = options.fetch(:global_network_resolver)
+        @resource_pools = self.class.index_by_name(options.fetch(:resource_pools))
+        @vm_types = self.class.index_by_name(options.fetch(:vm_types, {}))
+        @disk_types = self.class.index_by_name(options.fetch(:disk_types))
+        @availability_zones = options.fetch(:availability_zones_list)
+        @compilation = options.fetch(:compilation)
+        @ip_provider_factory = options.fetch(:ip_provider_factory)
+        @logger = options.fetch(:logger)
+      end
 
-        @networks = {}
-        @resource_pools = {}
-        @disk_pools = {}
+      def ip_provider
+        @ip_provider ||= @ip_provider_factory.new_ip_provider(@networks)
       end
 
-      # Adds a resource pool by name
-      # @param [Bosh::Director::DeploymentPlan::ResourcePool] resource_pool
-      def add_resource_pool(resource_pool)
-        if @resource_pools[resource_pool.name]
-          raise DeploymentDuplicateResourcePoolName,
-            "Duplicate resource pool name `#{resource_pool.name}'"
-        end
-        @resource_pools[resource_pool.name] = resource_pool
+      def model
+        nil
+      end
+
+      def deleted_network(name)
+        ManualNetwork.parse(
+          {'subnets' => [], 'name' => name},
+          [],
+          @global_network_resolver,
+          @logger
+        )
+      end
+
+      def availability_zone(name)
+        @availability_zones[name]
+      end
+
+      def availability_zones
+        @availability_zones.values
       end
 
-      # Returns all resource pools in a deployment plan
-      # @return [Array<Bosh::Director::DeploymentPlan::ResourcePool>]
       def resource_pools
         @resource_pools.values
       end
 
-      # Returns a named resource pool spec
-      # @param [String] name Resource pool name
-      # @return [Bosh::Director::DeploymentPlan::ResourcePool]
       def resource_pool(name)
         @resource_pools[name]
       end
 
-      # Adds a network by name
-      # @param [Bosh::Director::DeploymentPlan::Network] network
-      def add_network(network)
-        if @networks_canonical_name_index.include?(network.canonical_name)
-          raise DeploymentCanonicalNetworkNameTaken,
-            "Invalid network name `#{network.name}', " +
-              'canonical name already taken'
-        end
+      def vm_types
+        @vm_types.values
+      end
+
+      def vm_type(name)
+        @vm_types[name]
+      end
 
-        @networks[network.name] = network
-        @networks_canonical_name_index << network.canonical_name
+      def add_resource_pool(resource_pool)
+        @resource_pools[resource_pool.name] = resource_pool
       end
 
-      # Returns all networks in a deployment plan
-      # @return [Array<Bosh::Director::DeploymentPlan::Network>]
       def networks
         @networks.values
       end
 
-      # Returns a named network
-      # @param [String] name
-      # @return [Bosh::Director::DeploymentPlan::Network]
       def network(name)
         @networks[name]
       end
 
-      # Adds a disk pool by name
-      # @param [Bosh::Director::DeploymentPlan::DiskPool] disk_pool
-      def add_disk_pool(disk_pool)
-        if @disk_pools[disk_pool.name]
-          raise DeploymentDuplicateDiskPoolName,
-            "Duplicate disk pool name `#{disk_pool.name}'"
-        end
-        @disk_pools[disk_pool.name] = disk_pool
+      def disk_types
+        @disk_types.values
       end
 
-      def disk_pools
-        @disk_pools.values
+      def using_global_networking?
+        false
       end
 
-      def disk_pool(name)
-        @disk_pools[name]
+      def disk_type(name)
+        @disk_types[name]
+      end
+
+      def self.index_by_name(collection)
+        collection.inject({}) do |index, item|
+          index.merge(item.name => item)
+        end
       end
     end
   end