bosh-director 1.5.0.pre.1113

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

@@ -0,0 +1,94 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module DeploymentPlan
+    class Template
+
+      attr_reader :name
+      attr_reader :release
+
+      attr_reader :model
+      attr_reader :package_models
+
+      # @param [DeploymentPlan::Release] release Release
+      # @param [String] name Template name
+      def initialize(release, name)
+        @release = release
+        @name = name
+        @model = nil
+        @package_models = []
+        @logger = Config.logger
+      end
+
+      # Looks up template model and its package models in DB
+      # @return [void]
+      def bind_models
+        @model = @release.get_template_model_by_name(@name)
+
+        if @model.nil?
+          raise DeploymentUnknownTemplate, "Can't find template `#{@name}'"
+        end
+
+        @package_models = @model.package_names.map do |name|
+          @release.get_package_model_by_name(name)
+        end
+      end
+
+      # Downloads template blob to a given path
+      # @return [String] Path to downloaded blob
+      def download_blob
+        uuid = SecureRandom.uuid
+        path = File.join(Dir.tmpdir, "template-#{uuid}")
+
+        @logger.debug("Downloading template `#{@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} " +
+                      "(took #{Time.now - t1}s)")
+
+        path
+      end
+
+      # @return [String]
+      def version
+        present_model.version
+      end
+
+      # @return [String]
+      def sha1
+        present_model.sha1
+      end
+
+      # @return [String]
+      def blobstore_id
+        present_model.blobstore_id
+      end
+
+      # @return [Array]
+      def logs
+        present_model.logs
+      end
+
+      # @return [Hash]
+      def properties
+        present_model.properties
+      end
+
+      private
+
+      # Returns model only if it's present, fails otherwise
+      # @return [Models::Template]
+      def present_model
+        if @model.nil?
+          raise DirectorError, "Template `#{@name}' model is unbound"
+        end
+        @model
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module DeploymentPlan
+    class UpdateConfig
+      include ValidationHelper
+
+      attr_accessor :canaries
+      attr_accessor :max_in_flight
+
+      attr_accessor :min_canary_watch_time
+      attr_accessor :max_canary_watch_time
+
+      attr_accessor :min_update_watch_time
+      attr_accessor :max_update_watch_time
+
+      # @param [Hash] update_config Raw update config from deployment manifest
+      # @param [optional, Hash] default_update_config Default update config
+      def initialize(update_config, default_update_config = nil)
+        optional = !default_update_config.nil?
+
+        @canaries = safe_property(update_config, "canaries",
+                                  :class => Integer, :optional => optional)
+
+        @max_in_flight = safe_property(update_config, "max_in_flight",
+                                       :class => Integer, :optional => optional,
+                                       :min => 1)
+
+        canary_watch_times = safe_property(update_config, "canary_watch_time",
+                                           :class => String,
+                                           :optional => optional)
+        update_watch_times = safe_property(update_config, "update_watch_time",
+                                           :class => String,
+                                           :optional => optional)
+
+        if canary_watch_times
+          @min_canary_watch_time, @max_canary_watch_time =
+            parse_watch_times(canary_watch_times)
+        end
+
+        if update_watch_times
+          @min_update_watch_time, @max_update_watch_time =
+            parse_watch_times(update_watch_times)
+        end
+
+        if optional
+          @canaries ||= default_update_config.canaries
+
+          @min_canary_watch_time ||= default_update_config.min_canary_watch_time
+          @max_canary_watch_time ||= default_update_config.max_canary_watch_time
+
+          @min_update_watch_time ||= default_update_config.min_update_watch_time
+          @max_update_watch_time ||= default_update_config.max_update_watch_time
+
+          @max_in_flight ||= default_update_config.max_in_flight
+        end
+      end
+
+      def parse_watch_times(value)
+        value = value.to_s
+
+        if value =~ /^\s*(\d+)\s*\-\s*(\d+)\s*$/
+          result = [$1.to_i, $2.to_i]
+        elsif value =~ /^\s*(\d+)\s*$/
+          result = [$1.to_i, $1.to_i]
+        else
+          raise UpdateConfigInvalidWatchTime,
+                "Watch time should be an integer or a range of two integers"
+        end
+
+        if result[0] > result[1]
+          raise UpdateConfigInvalidWatchTime,
+                "Min watch time cannot be greater than max watch time"
+        end
+
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Bosh::Director
+  module DeploymentPlan
+    class Updater
+      def initialize(job, event_log, resource_pools, assembler, deployment_plan)
+        @job = job
+        @logger = job.logger
+        @event_log = event_log
+        @resource_pools = resource_pools
+        @assembler = assembler
+        @deployment_plan = deployment_plan
+      end
+
+      def update
+        event_log.begin_stage('Preparing DNS', 1)
+        job.track_and_log('Binding DNS') do
+          if Config.dns_enabled?
+            assembler.bind_dns
+          end
+        end
+
+        logger.info('Updating resource pools')
+        resource_pools.update
+        job.task_checkpoint
+
+        logger.info('Binding instance VMs')
+        assembler.bind_instance_vms
+
+        event_log.begin_stage('Preparing configuration', 1)
+        job.track_and_log('Binding configuration') do
+          assembler.bind_configuration
+        end
+
+        logger.info('Deleting no longer needed VMs')
+        assembler.delete_unneeded_vms
+
+        logger.info('Deleting no longer needed instances')
+        assembler.delete_unneeded_instances
+
+        logger.info('Updating jobs')
+        deployment_plan.jobs.each do |bosh_job|
+          job.task_checkpoint
+          logger.info("Updating job: #{bosh_job.name}")
+          JobUpdater.new(deployment_plan, bosh_job).update
+        end
+
+        logger.info('Refilling resource pools')
+        resource_pools.refill
+      end
+
+      private
+
+      attr_reader :job, :event_log, :resource_pools, :logger, :assembler, :deployment_plan
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module DeploymentPlan
+    class VipNetwork < Network
+      include IpUtil
+
+      # @return [Hash] Network cloud properties
+      attr_reader :cloud_properties
+
+      ##
+      # 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
+        @cloud_properties = safe_property(network_spec, "cloud_properties",
+                                          :class => Hash)
+        @reserved_ips = Set.new
+      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.nil?
+          raise NetworkReservationIpMissing,
+                "Must have IP for static reservations"
+        elsif reservation.dynamic?
+          reservation.error = NetworkReservation::WRONG_TYPE
+        elsif @reserved_ips.include?(reservation.ip)
+          reservation.error = NetworkReservation::USED
+        else
+          reservation.reserved = true
+          reservation.type = NetworkReservation::STATIC
+          @reserved_ips.add(reservation.ip)
+        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
+        @reserved_ips.delete(reservation.ip)
+      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)
+        if default_properties && !default_properties.empty?
+          raise NetworkReservationVipDefaultProvided,
+                "Can't provide any defaults since this is a VIP network"
+        end
+
+        {
+          "type" => "vip",
+          "ip" => ip_to_netaddr(reservation.ip).ip,
+          "cloud_properties" => @cloud_properties
+        }
+      end
+    end
+  end
+end

data/lib/bosh/director/dns_helper.rb

@@ -0,0 +1,204 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module DnsHelper
+
+    # primary_ns contact serial refresh retry expire minimum
+    SOA = "localhost hostmaster@localhost 0 10800 604800 30"
+    TTL_5M = 300
+    TTL_4H = 3600 * 4
+
+    # @param [String] ip IP address
+    # @return [String] reverse dns domain name for an IP
+    def reverse_domain(ip)
+      reverse(ip, 2)
+    end
+
+    # @param [String] ip IP address
+    # @return [String] reverse dns name for an IP used for a PTR record
+    def reverse_host(ip)
+      reverse(ip, 3)
+    end
+
+    def canonical(string)
+      # a-z, 0-9, -, case insensitive, and must start with a letter
+      string = string.downcase.gsub(/_/, "-").gsub(/[^a-z0-9-]/, "")
+      if string =~ /^(\d|-)/
+        raise DnsInvalidCanonicalName,
+              "Invalid DNS canonical name `#{string}', must begin with a letter"
+      end
+      if string =~ /-$/
+        raise DnsInvalidCanonicalName,
+              "Invalid DNS canonical name `#{string}', can't end with a hyphen"
+      end
+      string
+    end
+
+    # build a list of dns servers to use
+    def dns_servers(network, spec, add_default_dns = true)
+      servers = nil
+      dns_property = safe_property(spec, "dns",
+                                   :class => Array, :optional => true)
+      if dns_property
+        servers = []
+        dns_property.each do |dns|
+          dns = NetAddr::CIDR.create(dns)
+          unless dns.size == 1
+            invalid_dns(network, "must be a single IP")
+          end
+
+          servers << dns.ip
+        end
+      end
+
+      return servers unless add_default_dns
+
+      add_default_dns_server(servers)
+    end
+
+    # returns the default DNS server
+    def default_dns_server
+      Config.dns["server"] if Config.dns
+    end
+
+    # add default dns server to an array of dns servers
+    def add_default_dns_server(servers)
+      return servers unless Config.dns_enabled?
+
+      default_server = default_dns_server
+      if default_server && default_server != "127.0.0.1"
+        (servers ||= []) << default_server
+        servers.uniq!
+      end
+
+      servers
+    end
+
+    # returns the DNS domain name
+    def dns_domain_name
+      Config.dns_domain_name
+    end
+
+    # returns the DNS name server record
+    def dns_ns_record
+      "ns.#{dns_domain_name}"
+    end
+
+    # create/update DNS A record
+    def update_dns_a_record(domain, name, ip_address)
+      record = Models::Dns::Record.find(:domain_id => domain.id,
+                                        :name => name)
+      if record.nil?
+        record = Models::Dns::Record.new(:domain_id => domain.id,
+                                         :name => name, :type => "A",
+                                         :ttl => TTL_5M)
+      end
+      record.content = ip_address
+      record.change_date = Time.now.to_i
+      record.save
+    end
+
+    # create/update DNS PTR records (for reverse lookups)
+    def update_dns_ptr_record(name, ip_address)
+      reverse_domain = reverse_domain(ip_address)
+      reverse_host = reverse_host(ip_address)
+
+      rdomain = Models::Dns::Domain.safe_find_or_create(:name => reverse_domain,
+                                                        :type => "NATIVE")
+      Models::Dns::Record.find_or_create(:domain_id => rdomain.id,
+                                         :name => reverse_domain,
+                                         :type =>'SOA', :content => SOA,
+                                         :ttl => TTL_4H)
+
+      Models::Dns::Record.find_or_create(:domain_id => rdomain.id,
+                                         :name => reverse_domain,
+                                         :type =>'NS', :ttl => TTL_4H,
+                                         :content => dns_ns_record)
+
+      record = Models::Dns::Record.find(:content => name, :type =>'PTR')
+
+      # delete the record if the IP address changed
+      if record && record.name != reverse_host
+        id = record.domain_id
+        record.destroy
+        record = nil
+
+        # delete the domain if the domain id changed and it's empty
+        if id != rdomain.id
+          delete_empty_domain(Models::Dns::Domain[id])
+        end
+      end
+
+      unless record
+        record = Models::Dns::Record.new(:domain_id => rdomain.id,
+                                         :name => reverse_host,
+                                         :type =>'PTR', :ttl => TTL_5M)
+      end
+      record.content = name
+      record.change_date = Time.now.to_i
+      record.save
+    end
+
+    # deletes all DNS records matching the pattern
+    # @param [String] record_pattern SQL pattern
+    # @param [Integer] domain_id domain record id
+    def delete_dns_records(record_pattern, domain_id=nil)
+      records = Models::Dns::Record.filter(:name.like(record_pattern))
+      if domain_id
+        records = records.filter(:domain_id => domain_id)
+      end
+
+      # delete A records and collect all IPs for later
+      ips = []
+      records.each do |record|
+        ips << record.content
+        @logger.info("Deleting DNS record: #{record.name}")
+        record.destroy
+      end
+
+      # delete PTR records from IP list
+      ips.each do |ip|
+        records = Models::Dns::Record.filter(:name.like(reverse_host(ip)))
+        records.each do |record|
+          @logger.info("Deleting reverse DNS record: #{record.name}")
+          record.destroy
+        end
+      end
+
+      # see if any of the reverse domains are empty and should be deleted
+      ips.each do |ip|
+        reverse = reverse_domain(ip)
+        rdomain = Models::Dns::Domain.filter(:name => reverse,
+                                             :type => "NATIVE")
+        rdomain.each do |domain|
+          delete_empty_domain(domain)
+        end
+      end
+    end
+
+    # if the count is 2, it means we only have the NS & SOA record
+    # and the domain is "empty" and can be deleted
+    def delete_empty_domain(domain)
+      if domain.records.size == 2
+        @logger.info("Deleting empty reverse domain #{domain.name}")
+        domain.destroy # cascaded - all records are removed
+      end
+    end
+
+    # @param [String] network name
+    # @param [String] reason
+    # @raise NetworkInvalidDns
+    def invalid_dns(network, reason)
+      raise NetworkInvalidDns,
+            "Invalid DNS for network `#{network}': #{reason}"
+    end
+
+    private
+
+    def reverse(ip, n)
+      octets = ip.split(/\./)
+      "#{octets[0..n].reverse.join(".")}.in-addr.arpa"
+    end
+
+  end
+end