bosh-bootstrap 0.10.2 → 0.11.0

data/lib/bosh-bootstrap/commander/README.md

@@ -1,47 +0,0 @@
-# Bosh::Bootstrap::Commander
-
-The sequence of commands that are run on an Inception VM can be either invoked locally on the Inception VM or from a remote machine. The `Commander` provides a DSL for describing the commands to be run and allows them to be sequentially run against a local or remote server.
-
-Remote servers are accessed via SSH commands.
-
-Example commands:
-``` ruby
-commands = Bosh::Bootstrap::Commander::Commands.new do |server|
-  server.create "vcap user", <<-BASH
-    #!/usr/bin/env bash
-    
-    groupadd vcap 
-    useradd vcap -m -g vcap
-    mkdir -p /home/vcap/.ssh
-    chown -R vcap:vcap /home/vcap/.ssh
-  BASH
-
-  server.install "rvm & ruby", <<-BASH
-    #!/usr/bin/env bash
-    
-    if [[ -x rvm ]]
-    then
-      rvm get stable
-    else
-      curl -L get.rvm.io | bash -s stable
-      source /etc/profile.d/rvm.sh
-    fi
-    command rvm install 1.9.3 # oh god this takes a long time
-    rvm 1.9.3
-    rvm alias create default 1.9.3
-  BASH
-end
-
-@local_machine.run(commands)
-@server.run(commands)
-```
-
-There is a set of predefined command methods which give nicer text output. You can also invoke any method upon `server` and it will be supported as the command name. The name of the method invoked is semantically meaningless; it is a convenience. 
-
-* `assign`
-* `create`
-* `download`
-* `install`
-* `provision`
-* `store`
-* `validate`

data/lib/bosh-bootstrap/commander/command.rb

@@ -1,25 +0,0 @@
-# A single command/script to be run on a local/remote server
-# For the display, it has an active ("installing") and 
-# past tense ("installed") verb and a noub/description ("packages")
-module Bosh::Bootstrap::Commander
-  class Command
-    attr_reader :command       # verb e.g. "install"
-    attr_reader :description   # noun phrase, e.g. "packages"
-
-    attr_reader :full_present_tense  # e.g. "installing packages"
-    attr_reader :full_past_tense    # e.g. "installed packages"
-  
-    def initialize(command, description, full_present_tense=nil, full_past_tense=nil)
-      @command            = command
-      @description        = description
-      @full_present_tense = full_present_tense || "#{command} #{description}"
-      @full_past_tense    = full_past_tense || "#{command} #{description}"
-    end
-
-    # Invoke this command (subclass) to call back upon
-    # +server+ to perform a server helper
-    def perform(server)
-      raise "please implement this method to call back upon `server`"
-    end
-  end
-end

data/lib/bosh-bootstrap/commander/commands.rb

@@ -1,80 +0,0 @@
-module Bosh::Bootstrap::Commander
-  class Commands
-    attr_reader :commands
-
-    def initialize(&block)
-      @commands = []
-      yield self
-    end
-
-    def upload_file(target_path, file_contents)
-      @commands << UploadCommand.new(target_path, file_contents)
-    end
-
-    #
-    # Generic remote script commands with custom phrases
-    #
-
-    def assign(description, script, options={})
-      @commands << RemoteScriptCommand.new(
-        "assign", description, script,
-        "assigning #{description}", "assigned #{description}", options)
-    end
-
-    # Runs a script on target server, and stores the (stripped) STDOUT into
-    # settings.
-    # 
-    # Usage:
-    # server.capture_value "salted password", script("convert_salted_password", "PASSWORD" => settings.bosh.password),
-    #   :settings => "bosh.salted_password"
-    #
-    # Would store the returned STDOUT into settings[:bosh][:salted_password]
-    def capture_value(description, script, options)
-      @commands << RemoteScriptCommand.new(
-        "capture value", description, script,
-        "captures value of #{description}", "captured value of #{description}", options)
-    end
-
-    def create(description, script, options={})
-      @commands << RemoteScriptCommand.new(
-        "create", description, script,
-        "creating #{description}", "created #{description}", options)
-    end
-
-    def download(description, script, options={})
-      @commands << RemoteScriptCommand.new(
-        "download", description, script,
-        "downloading #{description}", "downloaded #{description}", options)
-    end
-
-    def install(description, script, options={})
-      @commands << RemoteScriptCommand.new(
-        "install", description, script,
-        "installing #{description}", "installed #{description}", options)
-    end
-
-    def provision(description, script, options={})
-      @commands << RemoteScriptCommand.new(
-        "provision", description, script,
-        "provisioning #{description}", "provisioned #{description}", options)
-    end
-
-    def store(description, script, options={})
-      @commands << RemoteScriptCommand.new(
-        "store", description, script,
-        "storing #{description}", "stored #{description}", options)
-    end
-
-    def validate(description, script, options={})
-      @commands << RemoteScriptCommand.new(
-        "validate", description, script,
-        "validating #{description}", "validated #{description}", options)
-    end
-
-    # catch-all for commands with generic active/past tense phrases
-    def method_missing(command, *args, &blk)
-      description, script = args[0..1]
-      @commands << RemoteScriptCommand.new(command.to_s, description, script)
-    end
-  end
-end

data/lib/bosh-bootstrap/commander/local_server.rb

@@ -1,68 +0,0 @@
-require "popen4"
-
-class Bosh::Bootstrap::Commander::LocalServer
-  attr_reader :logfile
-
-  def initialize(logfile=STDERR)
-    @logfile = logfile
-  end
-
-  # Execute the +Command+ objects, in sequential order
-  # upon the local server
-  # +commands+ is a +Commands+ container
-  #
-  # Returns false once any subcommand fails to execute successfully
-  def run(commands)
-    commands.commands.each do |command|
-      puts command.full_present_tense
-      if command.perform(self)
-        Thor::Base.shell.new.say "Successfully #{command.full_past_tense}", :green
-      else
-        Thor::Base.shell.new.say_status "error", "#{command.full_present_tense}", :red
-        return false
-      end
-    end
-  end
-
-  #
-  # Commands performed on local server
-  # These map to Command subclasses, which then callback to these
-  # local server specific implementations
-  #
-
-  # Run a script
-  def run_script(command, script, options={})
-    command.as_file do |execution_command|
-      `chmod +x #{execution_command}`
-      status = POpen4::popen4(execution_command) do |stdout, stderr, stdin, pid|
-        out = stdout.read
-        logfile.puts out unless out.strip == ""
-        err = stderr.read
-        if err.strip != ""
-          logfile.puts err
-          STDERR.puts err if logfile != STDERR
-        end
-        logfile.flush
-      end
-      status.success?
-    end
-  rescue StandardError => e
-    logfile.puts e.message
-    false
-  end
-
-  # Upload a file (put a file into local filesystem)
-  def upload_file(command, path, contents, upload_as_user=nil)
-    basedir = File.dirname(path)
-    unless File.directory?(basedir)
-      logfile.puts "creating micro-bosh manifest folder: #{basedir}"
-      FileUtils.mkdir_p(basedir)
-    end
-    logfile.puts "creating micro-bosh manifest: #{path}"
-    File.open(path, "w") { |file| file << contents }
-    true
-  rescue StandardError => e
-    logfile.puts e.message
-    false
-  end
-end

data/lib/bosh-bootstrap/commander/remote_script_command.rb

@@ -1,51 +0,0 @@
-# A single command/script to be run on a local/remote server
-# For the display, it has an active ("installing") and 
-# past tense ("installed") verb and a noub/description ("packages")
-module Bosh::Bootstrap::Commander
-  class RemoteScriptCommand < Command
-    attr_reader :command       # verb e.g. "install"
-    attr_reader :description   # noun phrase, e.g. "packages"
-    attr_reader :script
-
-    attr_reader :full_present_tense  # e.g. "installing packages"
-    attr_reader :full_past_tense    # e.g. "installed packages"
-
-    # Optional:
-    attr_reader :ssh_username # e.g. ubuntu or vcap
-    attr_reader :run_as_root
-    attr_reader :settings             # settings manifest (result of script might get stored back)
-    attr_reader :save_output_to_settings_key # e.g. bosh.salted_password
-
-    def initialize(command, description, script, full_present_tense=nil, full_past_tense=nil, options={})
-      super(command, description, full_present_tense, full_past_tense)
-      @script = script
-      @ssh_username = options[:ssh_username]
-      @run_as_root = options[:run_as_root]
-      @settings = options[:settings]
-      @save_output_to_settings_key = options[:save_output_to_settings_key]
-    end
-
-    # Invoke this command to call back upon +server.run_script+ 
-    def perform(server)
-      server.run_script(self, script,
-        ssh_username: ssh_username, run_as_root: run_as_root,
-        settings: settings, save_output_to_settings_key: save_output_to_settings_key)
-    end
-
-    # Provide a filename that represents this Command
-    def to_filename
-      @to_filename ||= "#{command} #{description}".gsub(/\W+/, '_')
-    end
-
-    # Stores the script on the local filesystem in a temporary directory
-    # Returns path
-    def as_file(&block)
-      tmpdir = ENV['TMPDIR'] || "/tmp"
-      script_path = File.join(tmpdir, to_filename)
-      File.open(script_path, "w") do |f|
-        f << @script
-      end
-      yield script_path
-    end
-  end
-end

data/lib/bosh-bootstrap/commander/remote_server.rb

@@ -1,137 +0,0 @@
-require "net/scp"
-require "tempfile"
-
-class Bosh::Bootstrap::Commander::RemoteServer
-
-  attr_reader :host
-  attr_reader :private_key_path
-  attr_reader :default_ssh_username
-  attr_reader :logfile
-
-  def initialize(host, private_key_path, logfile=STDERR)
-    @host, @private_key_path, @logfile = host, private_key_path, logfile
-    @default_ssh_username = "vcap" # unless overridden by a Command (before vcap exists)
-  end
-
-  # Execute the +Command+ objects, in sequential order
-  # upon the local server
-  # +commands+ is a +Commands+ container
-  #
-  # Returns false once any subcommand fails to execute successfully
-  def run(commands)
-    commands.commands.each do |command|
-      puts command.full_present_tense
-      if command.perform(self)
-        Thor::Base.shell.new.say "Successfully #{command.full_past_tense}", :green
-      else
-        Thor::Base.shell.new.say_status "error", "#{command.full_present_tense}", :red
-        return false
-      end
-    end
-  end
-
-  #
-  # Commands performed on remote server
-  # These map to Command subclasses, which then callback to these
-  # remote server specific implementations
-  #
-
-  # Run a script
-  #
-  # Uploads it to the remote server, makes it executable, then executes
-  # Stores the last line of stripped STDOUT/STDERR into a settings field, 
-  #   if :settings & :save_output_to_settings_key => "x.y.z" provided
-  def run_script(command, script, options={})
-    ssh_username = options[:ssh_username] || default_ssh_username
-    run_as_root  = options[:run_as_root]
-    settings     = options[:settings]
-    settings_key = options[:save_output_to_settings_key]
-
-    remote_path = remote_tmp_script_path(command)
-    upload_file(command, remote_path, script, ssh_username)
-    output, status = run_remote_script(remote_path, ssh_username, run_as_root)
-    output =~ /^(.*)\Z/
-    last_line = $1
-    # store output into a settings field, if requested
-    # TODO replace this with SettingsSetting#setting(settings_key, last_line.strip)
-
-    puts "Last line of script: #{last_line}"
-    puts "Storing to settings_key #{settings_key}" if settings_key
-    if settings_key
-      settings_key_portions = settings_key.split(".")
-      parent_key_portions, final_key = settings_key_portions[0..-2], settings_key_portions[-1]
-      target_settings_field = settings
-      parent_key_portions.each do |key_portion|
-        target_settings_field[key_portion] ||= {}
-        target_settings_field = target_settings_field[key_portion]
-      end
-      target_settings_field[final_key] = last_line.strip
-    end
-
-    status
-  rescue StandardError => e
-    logfile.puts e.message
-    false
-  end
-
-  # Upload a file (put a file into the remote server's filesystem)
-  def upload_file(command, remote_path, contents, ssh_username=nil)
-    upload_as_user = ssh_username || default_ssh_username
-    run_remote_command("mkdir -p #{File.dirname(remote_path)}", upload_as_user)
-    Tempfile.open("remote_script") do |file|
-      file << contents
-      file.flush
-      logfile.puts "uploading #{remote_path} to Inception VM"
-      Net::SCP.upload!(host, upload_as_user, file.path, remote_path, ssh: { keys: private_keys })
-    end
-    true
-  rescue StandardError => e
-    logfile.puts "ERROR running upload_file(#{command.class}, '#{remote_path}', ...)"
-    logfile.puts e.message
-    logfile.puts e.backtrace
-    false
-  end
-
-  private
-  def remote_tmp_script_path(command)
-    "/tmp/remote_script_#{command.to_filename}"
-  end
-
-  # Makes +remote_path+ executable, then runs it
-  # Returns:
-  # * a String of all STDOUT/STDERR; which is also appended to +logfile+
-  # * status (true = success)
-  #
-  # TODO catch exceptions http://learnonthejob.blogspot.com/2010/08/exception-handling-for-netssh.html
-  def run_remote_script(remote_path, ssh_username, run_as_root)
-    sudo = run_as_root ? "sudo " : ""
-    commands = [
-      "chmod +x #{remote_path}",
-      "bash -lc '#{sudo}/usr/bin/env PATH=$PATH #{remote_path}'"
-    ]
-    script_output = ""
-    results = Fog::SSH.new(host, ssh_username, keys: private_keys).run(commands) do |stdout, stderr|
-      [stdout, stderr].flatten.each do |data|
-        logfile << data
-        script_output << data
-      end
-    end
-    result = results.last
-    result_success = result.status == 0
-    [script_output, result_success]
-  end
-
-  def run_remote_command(command, username)
-    Net::SSH.start(host, username, keys: private_keys) do |ssh|
-      ssh.exec!("bash -lc '#{command}'") do |channel, stream, data|
-        logfile << data
-      end
-    end
-  end
-
-  # path to local private key being used
-  def private_keys
-    [private_key_path]
-  end
-
-end

data/lib/bosh-bootstrap/commander/upload_command.rb

@@ -1,17 +0,0 @@
-# A single command/script to be run on a local/remote server
-# For the display, it has an active ("installing") and 
-# past tense ("installed") verb and a noub/description ("packages")
-module Bosh::Bootstrap::Commander
-  class UploadCommand < Command
-    def initialize(target_path, file_contents)
-      super("upload", "file", "uploading file", "uploaded file")
-      @target_path = target_path
-      @file_contents = file_contents
-    end
-
-    # Invoke this command to call back upon +server.upload_file+ 
-    def perform(server)
-      server.upload_file(self, @target_path, @file_contents)
-    end
-  end
-end

data/lib/bosh-bootstrap/commander.rb

@@ -1,9 +0,0 @@
-module Bosh::Bootstrap::Commander
-end
-
-require "bosh-bootstrap/commander/command"
-require "bosh-bootstrap/commander/remote_script_command"
-require "bosh-bootstrap/commander/upload_command"
-require "bosh-bootstrap/commander/commands"
-require "bosh-bootstrap/commander/local_server"
-require "bosh-bootstrap/commander/remote_server"

data/lib/bosh-bootstrap/helpers/fog_setup.rb

@@ -1,50 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-require "fog"
-module Bosh; module Bootstrap; module Helpers; end; end; end
-
-# A collection of methods related to getting fog_compute
-# credentials for creating the inception VM
-# and to provide to the MicroBOSH for its uses.
-#
-# Attempts to look in +settings.fog_path+ to see if there is a .fog file.
-module Bosh::Bootstrap::Helpers::FogSetup
-  
-  # fog connection object to Compute tasks (VMs, IP addresses)
-  def fog_compute
-    @fog_compute ||= begin
-      # Fog::Compute.new requires Hash with keys that are symbols
-      # but Settings converts all keys to strings
-      # So create a version of settings.fog_credentials with symbol keys
-      credentials_with_symbols = settings.fog_credentials.inject({}) do |creds, key_pair|
-        key, value = key_pair
-        creds[key.to_sym] = value
-        creds
-      end
-      Fog::Compute.new(credentials_with_symbols)
-    end
-  end
-
-  def reset_fog_compute
-    @fog_compute = nil
-    @provider = nil # in cli.rb - I don't like this; need one wrapper for all CPI/compute calls
-    # or don't create fog_compute until we know all IaaS details
-  end
-
-  def fog_config
-    @fog_config ||= begin
-      if File.exists?(fog_config_path)
-        say "Found infrastructure API credentials at #{fog_config_path} (override with --fog)"
-        YAML.load_file(fog_config_path)
-      else
-        say "No existing #{fog_config_path} fog configuration file", :yellow
-        {}
-      end
-    end
-  end
-
-  def fog_config_path
-    settings.fog_path
-  end
-
-end

data/lib/bosh-bootstrap/helpers/settings.rb

@@ -1,99 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-require "settingslogic"
-module Bosh; module Bootstrap; module Helpers; end; end; end
-
-# Helper methods for loading/saving settings
-module Bosh::Bootstrap::Helpers::Settings
-
-  # Previously selected settings are stored in a YAML manifest
-  # Protects the manifest file with user-only priveleges
-  def settings
-    @settings ||= begin
-      FileUtils.mkdir_p(File.dirname(settings_path))
-      unless File.exists?(settings_path)
-        File.open(settings_path, "w") do |file|
-          file << {}.to_yaml
-        end
-      end
-      FileUtils.chmod 0600, settings_path
-      Settingslogic.new(settings_path)
-    end
-  end
-
-  def save_settings!
-    File.open(settings_path, "w") do |file|
-      raw_settings_yaml = settings.to_yaml.gsub(" !ruby/hash:Settingslogic", "")
-      file << raw_settings_yaml
-    end
-    @settings = nil # force to reload & recreate helper methods
-  end
-
-  # the base directory for holding the manifest settings file
-  # and private keys
-  #
-  # Defaults to ~/.bosh_bootstrap; and can be overridden with either:
-  # * $SETTINGS - to a folder (supported method)
-  # * $MANIFEST - to a folder (unsupported)
-  # * $MANIFEST - to a specific file; but uses its parent dir (unsupported, backwards compatibility)
-  def settings_dir
-    @settings_dir ||= begin
-      settings_dir = ENV["SETTINGS"] if ENV["SETTINGS"]
-      settings_dir ||= ENV["MANIFEST"] if ENV["MANIFEST"]
-      settings_dir = File.dirname(settings_dir) if settings_dir && File.file?(settings_dir)
-      settings_dir ||= "~/.bosh_bootstrap"
-      File.expand_path(settings_dir)
-    end
-  end
-
-  def settings_path
-    File.join(settings_dir, "manifest.yml")
-  end
-
-  def settings_ssh_dir
-    File.join(settings_dir, "ssh")
-  end
-
-  def backup_current_settings_file
-    backup_path = "#{settings_path}.bak"
-    FileUtils.cp_r(settings_path, backup_path)
-  end
-
-  def migrate_old_settings
-    if migrate_old_ssh_keys?
-      say "Upgrading settings manifest file:"
-      backup_current_settings_file
-    end
-    migrate_old_ssh_keys
-  end
-
-  # Do we need to migrate old ssh keys to new settings format?
-  def migrate_old_ssh_keys?
-    settings["local"] && settings["local"]["private_key_path"]
-  end
-
-  # Migrate this old data
-  #   local:
-  #     public_key_path: /Users/drnic/.ssh/id_rsa.pub
-  #     private_key_path: /Users/drnic/.ssh/id_rsa
-  # into new format:
-  #   inception:
-  #     local_private_key_path: ~/.bosh_bootstrap/ssh/inception (copy of settings.local.private_key_path)
-  #     key_pair:
-  #       name: <name of provider key_pair used when provisioning inception VM>
-  #       private_key: <contents of settings.local.private_key_path file>
-  #       public_key: <contents of settings.local.public_key_path file>
-  def migrate_old_ssh_keys
-    if migrate_old_ssh_keys?
-      say "-> migrating to cache private key for inception VM..."
-      inception_vm_private_key_path # to setup the path in settings
-      settings["inception"]["key_pair"] ||= {}
-      settings["inception"]["key_pair"]["name"] = "fog_default"
-      settings["inception"]["key_pair"]["private_key"] = File.read(settings["local"]["private_key_path"]).strip
-      settings["inception"]["key_pair"]["public_key"] = File.read(settings["local"]["public_key_path"]).strip
-      settings.delete("local")
-      save_settings!
-    end
-  end
-
-end

data/lib/bosh-bootstrap/helpers/settings_setter.rb

@@ -1,41 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-require "settingslogic"
-module Bosh; module Bootstrap; module Helpers; end; end; end
-
-# Set a nested setting with "key1.key2.key3" notation
-#
-# Assumes +settings+ contains the settings
-module Bosh::Bootstrap::Helpers::SettingsSetter
-
-  # Let's you navigate to a nested setting, do something with it,
-  # and then saves any changes to settings.
-  # Usage:
-  #   with_setting "inception" { |s| s["host"] = "1.2.3.4" }
-  #   with_setting "a.b.c" { |s| s["value"] = "1.2.3.4" }
-  def with_setting(nested_key, &block)
-    target_settings_field = settings
-    settings_key_portions = nested_key.split(".")
-    parent_key_portions, final_key = settings_key_portions[0..-2], settings_key_portions[-1]
-    parent_key_portions.each do |key_portion|
-      target_settings_field[key_portion] ||= {}
-      target_settings_field = target_settings_field[key_portion]
-    end
-
-    target_settings_field[final_key] ||= {}
-    yield target_settings_field[final_key]
-    save_settings!
-  end
-
-  def setting(nested_key, value)
-    target_settings_field = settings
-    settings_key_portions = nested_key.split(".")
-    parent_key_portions, final_key = settings_key_portions[0..-2], settings_key_portions[-1]
-    parent_key_portions.each do |key_portion|
-      target_settings_field[key_portion] ||= {}
-      target_settings_field = target_settings_field[key_portion]
-    end
-    target_settings_field[final_key] = value
-  end
-
-end

data/lib/bosh-bootstrap/helpers.rb

@@ -1,3 +0,0 @@
-require "bosh-bootstrap/helpers/settings"
-require "bosh-bootstrap/helpers/settings_setter"
-require "bosh-bootstrap/helpers/fog_setup"

data/lib/bosh-bootstrap/stages/stage_micro_bosh_delete/bosh_micro_delete

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-
-# Deletes a micro BOSH using "bosh micro delete"
-#
-# Required:
-# * $BOSH_NAME - name of bosh deployment
-#   (thus /var/vcap/store/microboshes/deployments/$BOSH_NAME/micro_bosh.yml exists)
-
-set -e # exit immediately if a simple command exits with a non-zero status
-set -u # report the usage of uninitialized variables
-
-# TODO in preparation for http://reviews.cloudfoundry.org/#/c/11976/
-export COLUMNS=80 # force a small width for progress bar
-
-cd /var/vcap/store/microboshes/deployments/
-bosh -n micro deployment $BOSH_NAME
-
-echo "Deleting deployment of micro BOSH $BOSH_NAME"
-bosh -n micro delete