bosh-director 1.5.0.pre.1113

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

@@ -0,0 +1,137 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module DeploymentPlan
+    ##
+    # Represents a explicitly configured network.
+    class ManualNetwork < Network
+      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
+
+        @subnets = []
+        subnets = safe_property(network_spec, "subnets", :class => Array)
+
+        subnets.each do |subnet_spec|
+          new_subnet = NetworkSubnet.new(self, subnet_spec)
+          @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
+            end
+          end
+          unless reservation.reserved?
+            reservation.error = NetworkReservation::CAPACITY
+          end
+        end
+        reservation.reserved?
+      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
+      end
+
+      ##
+      # Returns the network settings for the specific reservation.
+      #
+      # @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)
+        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
+
+          config["dns"] = subnet.dns if subnet.dns
+          config["gateway"] = subnet.gateway.ip if subnet.gateway
+        end
+        config
+      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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module DeploymentPlan
+    ##
+    # Represents a logical deployment network.
+    class Network
+      include DnsHelper
+      include ValidationHelper
+
+      VALID_DEFAULTS = %w(dns gateway).sort
+
+      # @return [DeploymentPlan] associated deployment
+      attr_accessor :deployment
+
+      # @return [String] network name
+      attr_accessor :name
+
+      # @return [String] canonical network name
+      attr_accessor :canonical_name
+
+      ##
+      # Creates a new network.
+      #
+      # @param [DeploymentPlan] deployment associated deployment plan
+      # @param [Hash] network_spec parsed deployment manifest network section
+      def initialize(deployment, network_spec)
+        @deployment = deployment
+        @name = safe_property(network_spec, "name", :class => String)
+        @canonical_name = canonical(@name)
+      end
+
+      ##
+      # Reserves a network resource, raises an error if reservation failed
+      # @param [NetworkReservation] reservation Network reservation
+      # @param [String] origin Whoever is reserving
+      def reserve!(reservation, origin)
+        reserve(reservation)
+        unless reservation.reserved?
+          reservation.handle_error(origin)
+        end
+      end
+
+      ##
+      # Reserves a network resource.
+      #
+      # Will update the passed in reservation if it can be fulfilled.
+      # @param [NetworkReservation] reservation
+      # @return [Boolean] true if the reservation was fulfilled
+      def reserve(reservation)
+        raise NotImplementedError, "#reserve not implemented for #{self.class}"
+      end
+
+      ##
+      # Releases a previous reservation that had been fulfilled.
+      # @param [NetworkReservation] reservation
+      # @return [void]
+      def release(reservation)
+        raise NotImplementedError, "#release not implemented for #{self.class}"
+      end
+
+      ##
+      # Returns the network settings for the specific reservation.
+      #
+      # @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)
+        raise NotImplementedError,
+              "#network_settings not implemented for #{self.class}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module DeploymentPlan
+    class NetworkSubnet
+      include DnsHelper
+      include IpUtil
+      include ValidationHelper
+
+      # @return [DeploymentPlan::Network] Network this subnet belongs to
+      attr_reader :network
+
+      # @return [NetAddr::CIDR] Subnet range
+      attr_reader :range
+
+      # @return [NetAddr::CIDR] Subnet gateway IP address
+      attr_reader :gateway
+
+      # @return [Array<String>] Subnet DNS IP addresses
+      attr_reader :dns
+
+      # @return [Hash] Subnet cloud properties (VLAN etc.)
+      attr_reader :cloud_properties
+
+      # @return [String] Subnet netmask
+      attr_reader :netmask
+
+      # @param [DeploymentPlan::Network] network Network
+      # @param [Hash] subnet_spec Raw subnet spec from deployment manifest
+      def initialize(network, subnet_spec)
+        @network = network
+
+        range_property = safe_property(subnet_spec, "range", :class => String)
+        @range = NetAddr::CIDR.create(range_property)
+
+        if @range.size <= 1
+          raise NetworkInvalidRange,
+                "Invalid network range `#{range_property}', " +
+                "should include at least 2 IPs"
+        end
+
+        @netmask = @range.wildcard_mask
+        network_id = @range.network(:Objectify => true)
+        broadcast = @range.broadcast(:Objectify => true)
+
+        gateway_property = safe_property(subnet_spec, "gateway",
+                                         :class => String, :optional => true)
+        if gateway_property
+          @gateway = NetAddr::CIDR.create(gateway_property)
+          unless @gateway.size == 1
+            invalid_gateway("must be a single IP")
+          end
+          unless @range.contains?(@gateway)
+            invalid_gateway("must be inside the range")
+          end
+          if @gateway == network_id
+            invalid_gateway("can't be the network id")
+          end
+          if @gateway == broadcast
+            invalid_gateway("can't be the broadcast IP")
+          end
+        end
+
+        @dns = dns_servers(@network.name, subnet_spec)
+
+        @cloud_properties = safe_property(subnet_spec, "cloud_properties",
+                                          :class => Hash)
+
+        @available_dynamic_ips = Set.new
+        @available_static_ips = Set.new
+
+        first_ip = @range.first(:Objectify => true)
+        last_ip = @range.last(:Objectify => true)
+
+        (first_ip.to_i .. last_ip.to_i).each do |ip|
+          @available_dynamic_ips << ip
+        end
+
+        @available_dynamic_ips.delete(@gateway.to_i) if @gateway
+        @available_dynamic_ips.delete(network_id.to_i)
+        @available_dynamic_ips.delete(broadcast.to_i)
+
+        reserved_ips = safe_property(subnet_spec, "reserved", :optional => true)
+        static_ips = safe_property(subnet_spec, "static", :optional => true)
+
+        each_ip(reserved_ips) do |ip|
+          unless @available_dynamic_ips.delete?(ip)
+            raise NetworkReservedIpOutOfRange,
+                  "Reserved IP `#{format_ip(ip)}' is out of " +
+                  "network `#{@network.name}' range"
+          end
+        end
+
+        each_ip(static_ips) do |ip|
+          unless @available_dynamic_ips.delete?(ip)
+            raise NetworkStaticIpOutOfRange,
+                  "Static IP `#{format_ip(ip)}' is out of " +
+                  "network `#{@network.name}' range"
+          end
+          @available_static_ips.add(ip)
+        end
+
+        # Keeping track of initial pools to understand
+        # where to release no longer needed IPs
+        @dynamic_ip_pool = @available_dynamic_ips.dup
+        @static_ip_pool = @available_static_ips.dup
+      end
+
+      def overlaps?(subnet)
+        @range == subnet.range ||
+          @range.contains?(subnet.range) ||
+          subnet.range.contains?(@range)
+      end
+
+      def reserve_ip(ip)
+        ip = ip.to_i
+        if @available_static_ips.delete?(ip)
+          :static
+        elsif @available_dynamic_ips.delete?(ip)
+          :dynamic
+        else
+          nil
+        end
+      end
+
+      def release_ip(ip)
+        ip = ip.to_i
+        if @dynamic_ip_pool.include?(ip)
+          @available_dynamic_ips.add(ip)
+        elsif @static_ip_pool.include?(ip)
+          @available_static_ips.add(ip)
+        else
+          raise NetworkReservationIpNotOwned,
+                "Can't release IP `#{format_ip(ip)}' " +
+                "back to `#{@network.name}' network: " +
+                "it's' neither in dynamic nor in static pool"
+        end
+      end
+
+      def allocate_dynamic_ip
+        ip = @available_dynamic_ips.first
+        if ip
+          @available_dynamic_ips.delete(ip)
+        end
+        ip
+      end
+
+      def dynamic_ips_count
+        @available_dynamic_ips.size
+      end
+
+      def static_ips_count
+        @available_static_ips.size
+      end
+
+      private
+
+      # @param [String] reason
+      # @raise NetworkInvalidGateway
+      def invalid_gateway(reason)
+        raise NetworkInvalidGateway,
+              "Invalid gateway for network `#{@network.name}': #{reason}"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,288 @@
+module Bosh::Director
+  # Encapsulates essential director data structures retrieved
+  # from the deployment manifest and the running environment.
+  module DeploymentPlan
+    class Planner
+      include DnsHelper
+      include ValidationHelper
+
+      # @return [String] Deployment name
+      attr_reader :name
+      # @return [String] Deployment canonical name (for DNS)
+      attr_reader :canonical_name
+      # @return [Models::Deployment] Deployment DB model
+      attr_reader :model
+
+      attr_accessor :properties
+      attr_accessor :compilation
+      attr_accessor :update
+      attr_accessor :unneeded_instances
+      attr_accessor :unneeded_vms
+      attr_accessor :dns_domain
+
+      attr_reader :jobs
+      attr_reader :job_rename
+      attr_reader :recreate
+
+      def initialize(manifest, options = {})
+        @manifest = manifest
+        @recreate = !!options['recreate']
+        @job_states = safe_property(options, 'job_states',
+                                    :class => Hash, :default => {})
+
+        @job_rename = safe_property(options, 'job_rename',
+                                    :class => Hash, :default => {})
+        @unneeded_vms = []
+        @unneeded_instances = []
+        @dns_domain = nil
+
+        @name = nil
+        @canonical_name = nil
+        @model = nil
+      end
+
+      def parse
+        parse_name
+        parse_properties
+        parse_releases
+        parse_networks
+        parse_compilation
+        parse_update
+        parse_resource_pools
+        parse_jobs
+      end
+
+      # Looks up deployment model in DB or creates one if needed
+      # @return [void]
+      def bind_model
+        if @name.nil? || @canonical_name.nil?
+          raise DirectorError,
+                'Unable to bind model, name and/or canonical name unknown'
+        end
+
+        attrs = {:name => @name}
+
+        Models::Deployment.db.transaction do
+          deployment = Models::Deployment.find(attrs)
+          # Canonical uniqueness is not enforced in the DB
+          if deployment.nil?
+            Models::Deployment.each do |other|
+              if canonical(other.name) == @canonical_name
+                raise DeploymentCanonicalNameTaken,
+                      "Invalid deployment name `#{@name}', " +
+                        'canonical name already taken'
+              end
+            end
+            deployment = Models::Deployment.create(attrs)
+          end
+          @model = deployment
+        end
+      end
+
+      # Returns a list of VMs in the deployment (according to DB)
+      # @return [Array<Models::Vm>]
+      def vms
+        if @model.nil?
+          raise DirectorError, "Can't get VMs list, deployment model is unbound"
+        end
+        @model.vms
+      end
+
+      # Returns a named job
+      # @param [String] name Job name
+      # @return [Bosh::Director::DeploymentPlan::Job] Job
+      def job(name)
+        @jobs_name_index[name]
+      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
+
+      # 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
+
+      # Returns all releases in a deployment plan
+      # @return [Array<Bosh::Director::DeploymentPlan::Release>]
+      def releases
+        @releases.values
+      end
+
+      # Returns a named release
+      # @return [Bosh::Director::DeploymentPlan::Release]
+      def release(name)
+        @releases[name]
+      end
+
+      # Adds a VM to deletion queue
+      # @param [Bosh::Director::Models::Vm] vm VM DB model
+      #
+      def delete_vm(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
+        end
+      end
+
+      def rename_in_progress?
+        @job_rename['old_name'] && @job_rename['new_name']
+      end
+
+      def parse_name
+        @name = safe_property(@manifest, 'name', :class => String)
+        @canonical_name = canonical(@name)
+      end
+
+      def parse_properties
+        @properties = safe_property(@manifest, 'properties',
+                                    :class => Hash, :default => {})
+      end
+
+      def parse_releases
+        release_specs = []
+
+        if @manifest.has_key?('release')
+          if @manifest.has_key?('releases')
+            raise DeploymentAmbiguousReleaseSpec,
+                  "Deployment manifest contains both 'release' and 'releases' " +
+                    'sections, please use one of the two.'
+          end
+          release_specs << @manifest['release']
+        else
+          safe_property(@manifest, 'releases', :class => Array).each do |release|
+            release_specs << release
+          end
+        end
+
+        @releases = {}
+        release_specs.each do |release_spec|
+          release = Release.new(self, release_spec)
+          if @releases.has_key?(release.name)
+            raise DeploymentDuplicateReleaseName,
+                  "Duplicate release name `#{release.name}'"
+          end
+          @releases[release.name] = release
+        end
+      end
+
+      def parse_resource_pools
+        @resource_pools = {}
+        resource_pools = safe_property(@manifest, 'resource_pools',
+                                       :class => Array)
+        resource_pools.each do |spec|
+          resource_pool = ResourcePool.new(self, spec)
+          if @resource_pools[resource_pool.name]
+            raise DeploymentDuplicateResourcePoolName,
+                  "Duplicate resource pool name `#{resource_pool.name}'"
+          end
+          @resource_pools[resource_pool.name] = resource_pool
+        end
+
+        # Uncomment when integration test fixed
+        # raise "No resource pools specified." if @resource_pools.empty?
+      end
+
+      def parse_jobs
+        @jobs = []
+        @jobs_name_index = {}
+        @jobs_canonical_name_index = Set.new
+
+        jobs = safe_property(@manifest, 'jobs', :class => Array, :default => [])
+
+        jobs.each do |job|
+          state_overrides = @job_states[job['name']]
+
+          if state_overrides
+            job.recursive_merge!(state_overrides)
+          end
+
+          if rename_in_progress? && @job_rename['old_name'] == job['name']
+            raise DeploymentRenamedJobNameStillUsed,
+                  "Renamed job `#{job['name']}' is still referenced in " +
+                    'deployment manifest'
+          end
+
+          job = Job.parse(self, job)
+
+          if @jobs_canonical_name_index.include?(job.canonical_name)
+            raise DeploymentCanonicalJobNameTaken,
+                  "Invalid job name `#{job.name}', canonical name already taken"
+          end
+
+          @jobs << job
+          @jobs_name_index[job.name] = job
+          @jobs_canonical_name_index << job.canonical_name
+        end
+      end
+
+      def parse_networks
+        @networks = {}
+        @networks_canonical_name_index = Set.new
+        networks = safe_property(@manifest, 'networks', :class => Array)
+        networks.each do |network_spec|
+          type = safe_property(network_spec, 'type', :class => String,
+                               :default => 'manual')
+          case type
+            when 'manual'
+              network = ManualNetwork.new(self, network_spec)
+            when 'dynamic'
+              network = DynamicNetwork.new(self, network_spec)
+            when 'vip'
+              network = VipNetwork.new(self, network_spec)
+            else
+              raise DeploymentInvalidNetworkType,
+                    "Invalid network type `#{type}'"
+          end
+
+          if @networks_canonical_name_index.include?(network.canonical_name)
+            raise DeploymentCanonicalNetworkNameTaken,
+                  "Invalid network name `#{network.name}', " +
+                    'canonical name already taken'
+          end
+          @networks[network.name] = network
+          @networks_canonical_name_index << network.canonical_name
+        end
+
+        if @networks.empty?
+          raise DeploymentNoNetworks, 'No networks specified'
+        end
+      end
+
+      def parse_update
+        @update = UpdateConfig.new(
+          safe_property(@manifest, 'update', :class => Hash))
+      end
+
+      def parse_compilation
+        @compilation = CompilationConfig.new(self, safe_property(
+          @manifest, 'compilation', :class => Hash))
+      end
+    end
+  end
+end