bosh_deployer 0.1.4

data/lib/deployer/config.rb

@@ -0,0 +1,137 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh; end
+
+module Bosh::Deployer
+  class Config
+
+    class << self
+
+      attr_accessor :logger, :db, :uuid, :resources, :cloud_options, :spec_properties, :bosh_ip
+
+      def configure(config)
+        if config["cloud"].nil?
+          raise ConfigError, "No cloud properties defined"
+        end
+        if config["cloud"]["plugin"].nil?
+          raise ConfigError, "No cloud plugin defined"
+        end
+
+        config = deep_merge(load_defaults(config["cloud"]["plugin"]), config)
+
+        @base_dir = config["dir"]
+        FileUtils.mkdir_p(@base_dir)
+
+        @cloud_options = config["cloud"]
+        @net_conf = config["network"]
+        @bosh_ip = @net_conf["ip"]
+        @resources = config["resources"]
+
+        @logger = Logger.new(config["logging"]["file"] || STDOUT)
+        @logger.level = Logger.const_get(config["logging"]["level"].upcase)
+        @logger.formatter = ThreadFormatter.new
+
+        @spec_properties = config["apply_spec"]["properties"]
+
+        @db = Sequel.sqlite
+
+        @db.create_table :vsphere_disk do
+          primary_key :id
+          column :path, :text
+          column :datacenter, :text
+          column :datastore, :text
+          column :size, :integer
+        end
+
+        @db.create_table :instances do
+          primary_key :id
+          column :name, :text, :unique => true, :null => false
+          column :uuid, :text
+          column :stemcell_cid, :text
+          column :stemcell_name, :text
+          column :vm_cid, :text
+          column :disk_cid, :text
+        end
+
+        Sequel::Model.plugin :validation_helpers
+
+        Bosh::Clouds::Config.configure(self)
+
+        require "deployer/models/instance"
+
+        @cloud_options["properties"]["agent"]["mbus"] ||=
+          "http://vcap:b00tstrap@0.0.0.0:6868"
+
+        @disk_model = nil
+        @cloud = nil
+        @networks = nil
+      end
+
+      def disk_model
+        if @disk_model.nil?
+          case @cloud_options["plugin"]
+          when "vsphere"
+            require "cloud/vsphere"
+            @disk_model = VSphereCloud::Models::Disk
+          else
+          end
+        end
+        @disk_model
+      end
+
+      def cloud
+        if @cloud.nil?
+          @cloud = Bosh::Clouds::Provider.create(@cloud_options["plugin"],
+                                                 @cloud_options["properties"])
+        end
+        @cloud
+      end
+
+      def agent
+        uri = URI.parse(@cloud_options["properties"]["agent"]["mbus"])
+        uri.host = bosh_ip
+        user, password = uri.userinfo.split(":", 2)
+        uri.userinfo = nil
+        Bosh::Agent::HTTPClient.new(uri.to_s,
+                                    { "user" => user,
+                                      "password" => password,
+                                      "reply_to" => uuid })
+      end
+
+      def networks
+        @networks ||= {
+          "bosh" => {
+            "cloud_properties" => @net_conf["cloud_properties"],
+            "netmask"          => @net_conf["netmask"],
+            "gateway"          => @net_conf["gateway"],
+            "ip"               => @net_conf["ip"],
+            "dns"              => @net_conf["dns"],
+            "type"             => @net_conf["type"],
+            "default"          => ["dns", "gateway"]
+          }
+        }
+      end
+
+      private
+
+      def deep_merge(src, dst)
+        src.merge(dst) do |key, old, new|
+          if new.respond_to?(:blank) && new.blank?
+            old
+          elsif old.kind_of?(Hash) and new.kind_of?(Hash)
+            deep_merge(old, new)
+          elsif old.kind_of?(Array) and new.kind_of?(Array)
+            old.concat(new).uniq
+          else
+            new
+          end
+        end
+      end
+
+      def load_defaults(provider)
+        file = File.join(File.dirname(File.expand_path(__FILE__)), "../../config/#{provider}_defaults.yml")
+        YAML.load_file(file)
+      end
+    end
+  end
+end

data/lib/deployer/errors.rb

@@ -0,0 +1,11 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh
+  module Deployer
+
+    class Error < StandardError; end
+
+    class ConfigError < StandardError; end
+
+  end
+end

data/lib/deployer/instance_manager.rb

@@ -0,0 +1,452 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Deployer
+  class InstanceManager
+
+    DEPLOYMENTS_FILE = "bosh-deployments.yml"
+
+    attr_reader :state
+    attr_accessor :renderer
+
+    class LoggerRenderer
+      attr_accessor :stage, :total, :index
+
+      def initialize
+        enter_stage("Deployer", 0)
+      end
+
+      def enter_stage(stage, total)
+        @stage = stage
+        @total = total
+        @index = 0
+      end
+
+      def update(state, task)
+        Config.logger.info("#{@stage} - #{state} #{task}")
+        @index += 1 if state == :finished
+      end
+    end
+
+    def initialize(config)
+      Config.configure(config)
+
+      @state_yml = File.join(config["dir"], DEPLOYMENTS_FILE)
+      load_state(config["name"])
+
+      Config.uuid = state.uuid
+
+      @renderer = LoggerRenderer.new
+    end
+
+    def cloud
+      Config.cloud
+    end
+
+    def agent
+      Config.agent
+    end
+
+    def logger
+      Config.logger
+    end
+
+    def disk_model
+      Config.disk_model
+    end
+
+    def instance_model
+      Models::Instance
+    end
+
+    def exists?
+      state.vm_cid != nil
+    end
+
+    def step(task)
+      renderer.update(:started, task)
+      result = yield
+      renderer.update(:finished, task)
+      result
+    end
+
+    def create(stemcell_tgz)
+      if state.vm_cid
+        raise ConfigError, "VM #{state.vm_cid} already exists"
+      end
+      if state.stemcell_cid && state.stemcell_cid != state.stemcell_name
+        raise ConfigError, "stemcell #{state.stemcell_cid} already exists"
+      end
+
+      renderer.enter_stage("Deploy Micro BOSH", 11)
+
+      state.stemcell_cid = create_stemcell(stemcell_tgz)
+      state.stemcell_name = File.basename(stemcell_tgz, ".tgz")
+      save_state
+
+      begin
+        step "Creating VM from #{state.stemcell_cid}" do
+          state.vm_cid = create_vm(state.stemcell_cid)
+          discover_bosh_ip
+        end
+        save_state
+      rescue => e
+        delete_stemcell
+        raise e
+      end
+
+      step "Waiting for the agent" do
+        wait_until_agent_ready
+      end
+
+      step "Updating persistent disk" do
+        update_persistent_disk
+      end
+
+      apply(@apply_spec)
+
+      step "Waiting for the director" do
+        wait_until_director_ready
+      end
+    end
+
+    def destroy
+      renderer.enter_stage("Delete micro BOSH", 6)
+      agent_stop
+      if state.disk_cid
+        delete_disk(state.disk_cid, state.vm_cid)
+      end
+      delete_vm
+      delete_stemcell
+    end
+
+    def update(stemcell_tgz)
+      renderer.enter_stage("Prepare for update", 5)
+      agent_stop
+      detach_disk
+      delete_vm
+      delete_stemcell
+      create(stemcell_tgz)
+    end
+
+    def create_stemcell(stemcell_tgz)
+      if File.directory?(stemcell_tgz)
+        step "Using existing stemcell" do
+        end
+
+        step "Loading apply spec" do
+          @apply_spec = load_apply_spec("#{stemcell_tgz}/apply_spec.yml")
+        end
+
+        return stemcell_tgz
+      end
+
+      Dir.mktmpdir("sc-") do |stemcell|
+        step "Unpacking stemcell" do
+          run_command("tar -zxf #{stemcell_tgz} -C #{stemcell}")
+        end
+
+        @apply_spec = load_apply_spec("#{stemcell}/apply_spec.yml")
+        properties = Config.cloud_options["properties"]["stemcell"]
+
+        step "Uploading stemcell" do
+          cloud.create_stemcell("#{stemcell}/image", properties)
+        end
+      end
+    end
+
+    def create_vm(stemcell_cid)
+      resources = Config.resources['cloud_properties']
+      networks  = Config.networks
+      cloud.create_vm(state.uuid, stemcell_cid, resources, networks)
+    end
+
+    def mount_disk(disk_cid)
+      step "Mount disk" do
+        agent.run_task(:mount_disk, disk_cid.to_s)
+      end
+    end
+
+    def unmount_disk(disk_cid)
+      step "Unmount disk" do
+        if disk_info.include?(disk_cid)
+          agent.run_task(:unmount_disk, disk_cid.to_s)
+        end
+      end
+    end
+
+    def migrate_disk(src_disk_cid, dst_disk_cid)
+      step "Migrate disk" do
+        agent.run_task(:migrate_disk, src_disk_cid.to_s, dst_disk_cid.to_s)
+      end
+    end
+
+    def disk_info
+      return @disk_list if @disk_list
+      @disk_list = agent.list_disk
+    end
+
+    def create_disk
+      step "Create disk" do
+        state.disk_cid = cloud.create_disk(Config.resources['persistent_disk'], state.vm_cid)
+        save_state
+      end
+    end
+
+    def delete_disk(disk_cid, vm_cid)
+      unmount_disk(disk_cid)
+
+      begin
+        step "Detach disk" do
+          cloud.detach_disk(vm_cid, disk_cid) if vm_cid
+        end
+      rescue Bosh::Clouds::DiskNotAttached
+      end
+
+      begin
+        step "Delete disk" do
+          cloud.delete_disk(disk_cid)
+        end
+        state.disk_cid = nil
+        save_state
+      rescue Bosh::Clouds::DiskNotFound
+      end
+    end
+
+    def attach_disk(is_create=false)
+      return if state.disk_cid.nil?
+
+      cloud.attach_disk(state.vm_cid, state.disk_cid)
+      save_state
+
+      begin
+        mount_disk(state.disk_cid)
+      rescue
+        if is_create
+          logger.warn("!!! mount_disk(#{state.disk_cid}) failed !!! retrying...")
+          mount_disk(state.disk_cid)
+        else
+          raise
+        end
+      end
+    end
+
+    def detach_disk
+      if state.disk_cid.nil?
+        raise "Error while detaching disk: unknown disk attached to instance"
+      end
+
+      unmount_disk(state.disk_cid)
+      step "Detach disk" do
+        cloud.detach_disk(state.vm_cid, state.disk_cid)
+      end
+    end
+
+    def attach_missing_disk
+      if state.disk_cid
+        attach_disk(true)
+      end
+    end
+
+    def check_persistent_disk
+      return if state.disk_cid.nil?
+      agent_disk_cid = disk_info.first
+      if agent_disk_cid != state.disk_cid
+        raise "instance #{state.vm_cid} has invalid disk: Agent reports #{agent_disk_cid} while deployer's record shows #{state.disk_cid}"
+      end
+    end
+
+    def update_persistent_disk
+      attach_missing_disk
+      check_persistent_disk
+
+      #XXX handle disk size change
+      if state.disk_cid.nil?
+        create_disk
+        attach_disk(true)
+      end
+    end
+
+    def update_spec(spec)
+      properties = spec["properties"]
+
+      %w{blobstore postgres director redis nats aws_registry}.each do |service|
+        next unless properties[service]
+        properties[service]["address"] = bosh_ip
+
+        if override = Config.spec_properties[service]
+          properties[service].merge!(override)
+        end
+      end
+
+      case Config.cloud_options["plugin"]
+      when "vsphere"
+        properties["vcenter"] =
+          Config.spec_properties["vcenter"] ||
+          Config.cloud_options["properties"]["vcenters"].first.dup
+
+        properties["vcenter"]["address"] ||= properties["vcenter"]["host"]
+      when "aws"
+        properties["aws"] =
+          Config.spec_properties["aws"] ||
+          Config.cloud_options["properties"]["aws"].dup
+
+        properties["aws"]["registry"] = Config.cloud_options["properties"]["registry"]
+        properties["aws"]["stemcell"] = Config.cloud_options["properties"]["stemcell"]
+      else
+      end
+
+      spec
+    end
+
+    def apply(spec)
+      agent_stop
+
+      step "Applying micro BOSH spec" do
+        agent.run_task(:apply, update_spec(spec.dup))
+      end
+
+      agent_start
+    end
+
+    def discover_bosh_ip
+      if exists? and cloud.respond_to?(:ec2)
+        Config.bosh_ip = cloud.ec2.instances[state.vm_cid].private_ip_address
+        logger.info("discovered bosh ip=#{Config.bosh_ip}")
+      end
+      Config.bosh_ip
+    end
+
+    private
+
+    def bosh_ip
+      Config.bosh_ip
+    end
+
+    def agent_stop
+      step "Stopping agent services" do
+        begin
+          agent.run_task(:stop)
+        rescue
+        end
+      end
+    end
+
+    def agent_start
+      step "Starting agent services" do
+        agent.run_task(:start)
+      end
+    end
+
+    def wait_until_ready
+      timeout_time = Time.now.to_f + (60 * 5)
+      begin
+        yield
+        sleep 0.5
+      rescue Bosh::Agent::Error, Errno::ECONNREFUSED => e
+        if timeout_time - Time.now.to_f > 0
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    def wait_until_agent_ready #XXX >> agent_client
+      wait_until_ready { agent.ping }
+    end
+
+    def wait_until_director_ready
+      port = @apply_spec["properties"]["director"]["port"]
+      url = "http://#{bosh_ip}:#{port}/info"
+      wait_until_ready do
+        info = Yajl::Parser.parse(HTTPClient.new.get(url).body)
+        logger.info("Director is ready: #{info.inspect}")
+      end
+    end
+
+    def delete_stemcell
+      unless state.stemcell_cid
+        raise ConfigError, "Cannot find existing stemcell"
+      end
+
+      if state.stemcell_cid == state.stemcell_name
+        step "Preserving stemcell" do
+        end
+      else
+        step "Delete stemcell" do
+          cloud.delete_stemcell(state.stemcell_cid)
+        end
+      end
+
+      state.stemcell_cid = nil
+      state.stemcell_name = nil
+      save_state
+    end
+
+    def delete_vm
+      unless state.vm_cid
+        raise ConfigError, "Cannot find existing VM"
+      end
+      step "Delete VM" do
+        cloud.delete_vm(state.vm_cid)
+      end
+      state.vm_cid = nil
+      save_state
+    end
+
+    def load_deployments
+      if File.exists?(@state_yml)
+        logger.info("Loading existing deployment data from: #{@state_yml}")
+        YAML.load_file(@state_yml)
+      else
+        logger.info("No existing deployments found (will save to #{@state_yml})")
+        { "instances" => [], "disks" => [] }
+      end
+    end
+
+    def load_apply_spec(file)
+      logger.info("Loading apply spec from #{file}")
+      YAML.load_file(file)
+    end
+
+    def generate_unique_name
+      UUIDTools::UUID.random_create.to_s
+    end
+
+    def load_state(name)
+      @deployments = load_deployments
+
+      disk_model.insert_multiple(@deployments["disks"]) if disk_model
+      instance_model.insert_multiple(@deployments["instances"])
+
+      @state = instance_model.find(:name => name)
+      if @state.nil?
+        @state = instance_model.new
+        @state.uuid = "bm-#{generate_unique_name}"
+        @state.name = name
+        @state.save
+      else
+        discover_bosh_ip
+      end
+    end
+
+    def save_state
+      state.save
+      @deployments["instances"] = instance_model.map { |instance| instance.values }
+      @deployments["disks"] = disk_model.map { |disk| disk.values } if disk_model
+
+      File.open(@state_yml, "w") do |file|
+        file.write(YAML.dump(@deployments))
+      end
+    end
+
+    def run_command(command)
+      output = `#{command} 2>&1`
+      if $?.exitstatus != 0
+        $stderr.puts output
+        raise "'#{command}' failed with exit status=#{$?.exitstatus} [#{output}]"
+      end
+    end
+
+  end
+end