vagrant-orchestrate 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7922e2cc39373d1bf1e9d8934ce5c076040cbdc5
-  data.tar.gz: 4d80c7dae9a8ef60feb376a63ee418d516754fda
+  metadata.gz: fc2a1392e8001d976648512c3639ccf0bfa02422
+  data.tar.gz: d2fca53a34f4ebbb9353d5bcf084034cff22f47f
 SHA512:
-  metadata.gz: ad5fd6fcfd31b681f7f13bc5541ceeae2cd440d0d3e80e49c04704e69fa140d6fa24ed7d79d78fc293e5047f94056b6bb7f791d24e424a9073771081655dea85
-  data.tar.gz: 8c28fe99b0fac7f83da57ddb562d31552975daf74c0bd034631bff19b8d3cc43020e3d915704a4f72355a3303e83bf00d82fd3f84dc1c2773c1952d6e8c584a1
+  metadata.gz: e432897d4477f5907b39f65ed709899a194cc5a537c808ca83cf15ee6206a6c8f5118b059c2ab673ebce14fce864979fb75dee4d4b2bc947232fec7934fffcb0
+  data.tar.gz: e010c6132a1ee981a681228c111edae7b0318d52d17d059b9744a251257e13093a708ce309c375f5d31f9e0ccc8b81df51c3843ddc716f37bec315d22ff568a5

data/README.md

@@ -192,6 +192,34 @@ Current machine states:
 
 local                     not created (virtualbox)
 ```
+
+#### Credentials
+
+Vagrant orchestrate offers the capability to prompt for credentials from the command
+line at the time of a push. You can initialize your Vagrantfile to declare this
+by passing the `--credentials-prompt` flag to the `vagrant orchestrate init` command,
+or add the following to your Vagrantfile.
+
+```ruby
+Vagrant.configure("2") do |config|
+
+  ...
+
+  config.orchestrate.credentials do |creds|
+    creds.prompt = true
+  end
+```
+
+The credentials config object can accept one additional parameter, `file_path`. Setting
+`creds.file_path = path/to/username_password.yaml` tells vagrant-orchestrate to
+look for a file at the given path, and read from its :username and :password fields
+('username' and 'password' are also accepted). Additionally, you can pass the username
+and password in using the `VAGRANT_ORCHESTRATE_USERNAME` and `VAGRANT_ORCHESTRATE_PASSWORD`
+environment variables. Environment variables take precedence over the file, and the file
+takes precedence over the prompting. It is possible to set `prompt` to `false`, or leave
+it unset, in which case only environment variables and the credentials file (if provided)
+will be checked.
+
 #### Puppet
 
 Experimental puppet templating support is available as well with the `--puppet` flag and associated options
@@ -226,15 +254,20 @@ modules/
 For a full list of init options, run `vagrant orchestrate init --help`
 
 ### Pushing changes
-Go ahead and push changes to your managed servers, one at a time. Support for parallel deployments is planned.
+Go ahead and push changes to your managed servers, in serial by default.
 
     $ vagrant orchestrate push
 
-The push command is currently limited by convention to vagrant machines that start with the "managed-" prefix. So if you have other, local machines defined in the Vagrantfile, `vagrant orchestrate push` will not operate on those, but be cautioned that `vagrant up`, `provision` and `destroy` will by default.
+The push command is currently limited by convention to vagrant machines that use the `:managed` provider. So if you have other, local machines defined in the Vagrantfile, `vagrant orchestrate push` will not operate on those.
+
+#### Deployment Strategy
+
+Vagrant Orchestrate supports several deployment [strategies](docs/strategies.md), including parallel and
+blue-green.
 
-You can run vagrant with increased verbosity if you run into problems
+You can push changes to all of your servers in parallel with
 
-    $ vagrant orchestrate push --debug
+    $ vagrant orchestrate push --strategy parallel
 
 ## Filtering managed commands
 It can be easy to make mistakes such as rebooting production if you have managed long-lived servers as well as local VMs defined in your Vagrantfile. We add some protection with the `orchestrate.filter_managed_commands` configuration setting, which will cause up, provision, reload, and destroy commands to be ignored for servers with the managed provider.
@@ -254,6 +287,7 @@ merge that feature into downstream environments to avoid conflicts.
 ## Tips for Windows hosts
 
 * Need rsync? Install [OpenSSH](http://www.mls-software.com/opensshd.html) and then run this [script](https://github.com/joefitzgerald/packer-windows/blob/master/scripts/rsync.bat) to install rsync. Vagrant managed servers currently only works with cygwin based rsync implementations.
+* If you're using winrm-s as your communicator, you'll need to configure it first on the target machine! Check out [the plugin readme](https://github.com/Cimpress-MCP/vagrant-winrm-s/blob/master/README.md#setting-up-your-server) for instructions on how to set this up.
 
 ## Contributing
 

data/Rakefile

@@ -6,3 +6,4 @@ RuboCop::RakeTask.new
 RSpec::Core::RakeTask.new(:spec)
 
 task build: ["rubocop:auto_correct", :spec]
+task default: :build

data/docs/strategy.md

@@ -0,0 +1,91 @@
+# Deployment Strategies
+
+Vagrant Orchestrate supports several deployment strategies, including parallel and
+blue-green. Here we'll cover how to use the various strategies as well as describing
+situations when each might be useful.
+
+## Specifying a strategy
+
+### Command line
+
+Strategies can be passed on the command line with the `--strategy` parameter
+
+    $ vagrant orchestrate push --strategy parallel
+
+### Vagrantfile configuration
+
+Alternatively, you can specify the deployment strategy in your Vagrantfile
+
+    config.orchestrate.strategy = :parallel
+
+Command line parameters take precedence over Vagrantfile set configuration values.
+
+## Strategies
+
+### Serial (default)
+This will deploy to the target servers one at a time. This can be useful if you
+have a small number servers, or if you need to keep the majority of your servers
+online in order to support your application's load.
+
+    $ vagrant orchestrate push --strategy serial
+
+    config.orchestrate.strategy = :serial
+
+
+### Parallel
+This strategy will deploy to all of the target servers at the same time. This is
+useful if you want to minimize the amount of time that an overall deployment takes.
+Depending on how you've written your provisioners, this could cause downtime for
+the application that is being deployed.
+
+    $ vagrant orchestrate push --strategy parallel
+
+    config.orchestrate.strategy = :parallel
+
+### Canary
+The canary strategy will deploy to a single server, provide an opportunity to
+test the deployed server, and then deploy the remainder of the servers in parallel.
+This is a great opportunity to test one node of your cluster before blasting your
+changes out to them all. This can be particularly useful when combined with post
+provision [trigger](https://github.com/emyl/vagrant-triggers) to run a smoke test.
+
+    $ vagrant orchestrate push --strategy canary
+
+    config.orchestrate.strategy = :canary
+
+### Blue Green
+The [Blue Green](http://martinfowler.com/bliki/BlueGreenDeployment.html) deployment
+strategy deploys to half of the cluster in parallel, then the other half, with
+a pause in between. This doesn't manage any of your load balancing or networking
+configuraiton for you, but if your application has a healthcheck that your load
+balancer respects, it should be easy to turn it off at the start of your provisioning
+and back on at the end. If your application can serve the load on half of its nodes
+then this will be the best blend of getting the deployment done quickly and maintaining
+a working application.
+
+    $ vagrant orchestrate push --strategy blue_green
+
+    config.orchestrate.strategy = :blue_green
+
+### Canary Blue Green
+This strategy simply combines the two immediately above - deploying to a single
+server, pausing, then to half the cluster in parallel, pausing, and then the remainder,
+also in parallel. Good if you have a large number of servers and want to do a
+smoke test of a single server before committing to pushing to half of your farm.
+
+    $ vagrant orchestrate push --strategy canary_blue_green
+
+		config.orchestrate.strategy = :canary_blue_green
+
+## Suppressing Prompts
+In order to automate the deployment process, it can be very useful to suppress
+prompts. You can achieve that in two ways:
+
+From the command line, add the `--force` or `-f` parameter
+
+    $ vagrant orchestrate push --strategy canary -f
+
+
+Within your vagrantfile, set the `force_push` setting to true
+
+    config.orchestrate.force_push = true

data/lib/vagrant-orchestrate/action/setcredentials.rb

@@ -0,0 +1,88 @@
+module VagrantPlugins
+  module Orchestrate
+    module Action
+      class SetCredentials
+        def initialize(app, _env)
+          @app = app
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def call(env)
+          @machine = env[:machine]
+
+          if @machine.config.orchestrate.credentials
+            @ui = env[:ui]
+            config_creds = @machine.config.orchestrate.credentials
+            (username, password) = retrieve_creds(config_creds)
+
+            # Apply the credentials to the machine info, or back out if we were unable to procure them.
+            if username && password
+              apply_creds(username, password)
+            else
+              @ui.warn <<-WARNING
+Vagrant-orchestrate could not gather credentials for machine #{@machine.name}. \
+Continuing with default credentials."
+              WARNING
+            end
+          end
+
+          @app.call env
+        end
+
+        def retrieve_creds(config_creds)
+          # Use environment variable overrides, or else what was provided in the config file
+          config_creds.username = ENV["VAGRANT_ORCHESTRATE_USERNAME"] || config_creds.username
+          config_creds.password = ENV["VAGRANT_ORCHESTRATE_PASSWORD"] || config_creds.password
+
+          # Use credentials file to any username or password that is still undiscovered
+          check_creds_file(config_creds) unless config_creds.username && config_creds.password
+
+          # Only prompt if allowed by config
+          if config_creds.prompt
+            config_creds.username ||= prompt_username
+            config_creds.password ||= prompt_password
+          end
+
+          [config_creds.username, config_creds.password]
+        end
+
+        def apply_creds(username, password)
+          configs = [@machine.config.winrm, @machine.config.ssh]
+          configs.each do |config|
+            next unless config
+            config.username = username
+            config.password = password
+          end
+        end
+
+        def prompt_username
+          default = ENV["USERNAME"]
+          default ||= ENV["USER"]
+          username = @ui.ask("username? [#{default}]")
+          username = default if username.empty?
+          username
+        end
+
+        def prompt_password
+          @ui.ask("password?", echo: false)
+        end
+
+        def check_creds_file(config_creds)
+          file_path = config_creds.file_path
+          return unless file_path
+          unless File.exist?(file_path)
+            @ui.info "Credential file not found at #{file_path}. Prompting user for credentials."
+            return
+          end
+          begin
+            creds_yaml = YAML.load(File.read(file_path))
+            config_creds.password ||= creds_yaml[:password] || creds_yaml["password"]
+            config_creds.username ||= creds_yaml[:username] || creds_yaml["username"]
+          rescue
+            @ui.warn "Credentials file at #{file_path} was not valid YAML. Prompting user for credentials."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-orchestrate/command/init.rb

@@ -41,7 +41,7 @@ module VagrantPlugins
             end
 
             o.on("--shell-paths x,y,z", Array,
-                 "Comma separated list of shell scripts to run on provision. Only with --shell") do |list|
+                 "Comma-separated list of shell scripts to run on provision. Only with --shell") do |list|
               options[:shell_paths] = list
             end
 
@@ -66,7 +66,7 @@ module VagrantPlugins
               options[:ssh_username] = u
             end
 
-            o.on("--ssh-password PASSWORD", String, "The username for communicating over ssh") do |p|
+            o.on("--ssh-password PASSWORD", String, "The password for communicating over ssh") do |p|
               options[:ssh_password] = p
             end
 
@@ -102,6 +102,15 @@ module VagrantPlugins
             o.on("-f", "--force", "Force overwriting of files") do
               options[:force] = true
             end
+
+            o.on("--credentials-prompt", "Prompt for credentials when performing orchestrate operations") do
+              options[:creds_prompt] = true
+            end
+
+            cfpmsg = "The path to a yaml file containing :username and :password fields to use with vagrant orchestrate"
+            o.on("--credentials-file-path FILEPATH", String, cfpmsg) do |file_path|
+              options[:creds_file_path] = file_path
+            end
           end
 
           argv = parse_options(opts)
@@ -131,7 +140,8 @@ module VagrantPlugins
                                              ssh_private_key_path: options[:ssh_private_key_path],
                                              servers: options[:servers],
                                              environments: options[:environments],
-                                             plugins: options[:plugins]
+                                             plugins: options[:plugins],
+                                             creds_prompt: options[:creds_prompt]
                                              )
           write_file("Vagrantfile", contents, options)
           FileUtils.cp(Orchestrate.source_root.join("templates", "vagrant", "dummy.box"),
@@ -177,8 +187,8 @@ module VagrantPlugins
           contents = TemplateRenderer.render(Orchestrate.source_root.join("templates/environment/servers.json"),
                                              environments: environments)
           write_file("servers.json", contents, options)
-          @env.ui.info("You've created an environment aware configuration.")
-          @env.ui.info("To complete the process you need to do the following: ")
+          @env.ui.info("You've created an environment-aware configuration.")
+          @env.ui.info("To complete the process, you need to do the following: ")
           @env.ui.info(" 1. Add the target servers to servers.json")
           @env.ui.info(" 2. Commit your changes")
           @env.ui.info(" 3. Create a git branch for each environment")

data/lib/vagrant-orchestrate/command/push.rb

@@ -1,14 +1,26 @@
 require "optparse"
 require "vagrant"
 
+class Array
+  def in_groups(num_groups)
+    return [] if num_groups == 0
+    slice_size = (size / Float(num_groups)).ceil
+    each_slice(slice_size).to_a
+  end
+end
+
 module VagrantPlugins
   module Orchestrate
     module Command
       class Push < Vagrant.plugin("2", :command)
         include Vagrant::Util
 
+        @logger = Log4r::Logger.new("vagrant_orchestrate::command::push")
+
+        # rubocop:disable Metrics/AbcSize, MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def execute
           options = {}
+          options[:force] = @env.vagrantfile.config.orchestrate.force_push
 
           opts = OptionParser.new do |o|
             o.banner = "Usage: vagrant orchestrate push"
@@ -17,29 +29,105 @@ module VagrantPlugins
             o.on("--reboot", "Reboot a managed server after the provisioning step") do
               options[:reboot] = true
             end
+
+            o.on("--strategy strategy", "The orchestration strategy to use. Default is serial") do |v|
+              options[:strategy] = v
+            end
+
+            o.on("-f", "--force", "Suppress prompting in between groups") do
+              options[:force] = true
+            end
           end
 
           # Parse the options
           argv = parse_options(opts)
+          return unless argv
 
+          machines = []
           with_target_vms(argv) do |machine|
-            unless machine.provider_name.to_sym == :managed
-              @env.ui.info("Skipping machine #{machine.name}")
-              next
+            if machine.provider_name.to_sym == :managed
+              machines << machine
+            else
+              @logger.debug("Skipping #{machine.name} because it doesn't use the :managed provider")
+            end
+          end
+
+          if machines.empty?
+            @env.ui.info("No servers with :managed provider found. Skipping.")
+            return
+          end
+
+          # This environment variable is used as a signal to the filtermanaged
+          # action so that we don't filter managed commands that are really just
+          # the implementation of a push action.
+
+          options[:parallel] = true
+          strategy = options[:strategy] || @env.vagrantfile.config.orchestrate.strategy
+          @env.ui.info("Pushing to managed servers using #{strategy} strategy.")
+          case strategy.to_sym
+          when :serial
+            options[:parallel] = false
+            result = deploy(options, machines)
+          when :parallel
+            result = deploy(options, machines)
+          when :canary
+            # A single canary server and then the rest
+            result = deploy(options, machines.take(1), machines.drop(1))
+          when :blue_green
+            # Split into two (almost) equal groups
+            groups = machines.in_groups(2)
+            result = deploy(options, groups.first, groups.last)
+          when :canary_blue_green
+            # A single canary and then two equal groups
+            canary = machines.take(1)
+            groups = machines.drop(1).in_groups(2)
+            result = deploy(options, canary, groups.first, groups.last)
+          else
+            @env.ui.error("Invalid deployment strategy specified")
+            result = false
+          end
+
+          return 1 unless result
+          0
+        end
+        # rubocop:enable Metrics/AbcSize, MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def deploy(options, *groups)
+          groups.each_with_index do |machines, index|
+            @logger.debug("Orchestrating push to group number #{index + 1} of #{groups.size}.")
+            @logger.debug(" -- Hosts: #{machines.collect { |m| m.name.to_s }.join(',')}")
+            ENV["VAGRANT_ORCHESTRATE_COMMAND"] = "PUSH"
+            begin
+              batchify(machines, :up, options)
+              batchify(machines, :provision, options)
+              batchify(machines, :reload, options) if options[:reboot]
+              batchify(machines, :destroy, options)
+              @logger.debug("Finished orchestrating push to group number #{index + 1} of #{groups.size}.")
+            ensure
+              ENV.delete "VAGRANT_ORCHESTRATE_COMMAND"
             end
-            push(machine, options)
+
+            # Don't prompt on the last group, that would be annoying
+            unless index == groups.size - 1 || options[:force]
+              return false unless prompt_for_continue
+            end
+          end
+        end
+
+        def prompt_for_continue
+          result = @env.ui.ask("Deployment paused for manual review. Would you like to continue? (y/n)")
+          if result.upcase != "Y"
+            @env.ui.info("Deployment push action by user")
+            return false
           end
+          true
         end
 
-        def push(machine, options)
-          ENV["VAGRANT_ORCHESTRATE_COMMAND"] = "PUSH"
-          begin
-            machine.action(:up, options)
-            machine.action(:provision, options)
-            machine.action(:reload, options) if options[:reboot]
-            machine.action(:destroy, options)
-          ensure
-            ENV.delete "VAGRANT_ORCHESTRATE_COMMAND"
+        def batchify(machines, action, options)
+          @env.batch(options[:parallel]) do |batch|
+            machines.each do |machine|
+              batch.action(machine, action, options)
+            end
           end
         end
       end

data/lib/vagrant-orchestrate/command/root.rb

@@ -6,8 +6,7 @@ module VagrantPlugins
     module Command
       class Root < Vagrant.plugin(2, :command)
         def self.synopsis
-          'Orchestrates provsioning of managed servers. Useful for deploying changes \
-          repeatedly across multiple managed environments'
+          "Orchestrate provsioning of managed servers across environments"
         end
 
         def initialize(argv, env)

data/lib/vagrant-orchestrate/config.rb

@@ -1,16 +1,92 @@
 require "vagrant"
+require "yaml"
 
 module VagrantPlugins
   module Orchestrate
     class Config < Vagrant.plugin(2, :config)
       attr_accessor :filter_managed_commands
+      attr_accessor :strategy
+      attr_accessor :force_push
+      attr_accessor :credentials
 
       def initialize
         @filter_managed_commands = UNSET_VALUE
+        @strategy = UNSET_VALUE
+        @force_push = UNSET_VALUE
+        @credentials = Credentials.new
+      end
+
+      def credentials
+        yield @credentials if block_given?
+        @credentials
+      end
+
+      # It was a little hard to dig up, but this method gets called on the more general
+      # config object, with the more specific config as the argument.
+      # https://github.com/mitchellh/vagrant/blob/master/lib/vagrant/config/v2/loader.rb
+      def merge(new_config)
+        super.tap do |result|
+          if new_config.credentials.unset?
+            result.credentials = @credentials
+          elsif @credentials.unset?
+            result.credentials = new_config.credentials
+          else
+            result.credentials = @credentials.merge(new_config.credentials)
+          end
+        end
       end
 
       def finalize!
         @filter_managed_commands = false if @filter_managed_commands == UNSET_VALUE
+        @strategy = :serial if @strategy == UNSET_VALUE
+        @force_push = false if @force_push == UNSET_VALUE
+        @credentials = nil if @credentials.unset?
+        @credentials.finalize! if @credentials
+      end
+
+      class Credentials
+        # Same as Vagrant does to distinguish uninitialized variables and intentional assignments
+        # to Ruby's nil, we just have to define ourselves because we're in different scope
+        UNSET_VALUE = ::Vagrant::Plugin::V2::Config::UNSET_VALUE
+
+        attr_accessor :prompt
+        attr_accessor :file_path
+        attr_accessor :username
+        attr_accessor :password
+
+        def initialize
+          @prompt = UNSET_VALUE
+          @file_path = UNSET_VALUE
+          @username = UNSET_VALUE
+          @password = UNSET_VALUE
+          @unset = nil
+        end
+
+        def unset?
+          @unset || [@prompt, @file_path, @username, @password] == [UNSET_VALUE, UNSET_VALUE, UNSET_VALUE, UNSET_VALUE]
+        end
+
+        # Merge needs to be implemented here because this class doesn't get to
+        # to extend Vagrant.plugin(2, :config), and it would be pretty surprising
+        # if credentials configuration defined at different levels couldn't be merged
+        def merge(new_config)
+          result = dup
+          unless new_config.unset?
+            result.prompt = new_config.prompt unless new_config.prompt == UNSET_VALUE
+            result.file_path = new_config.file_path unless new_config.file_path == UNSET_VALUE
+            result.username = new_config.username unless new_config.username == UNSET_VALUE
+            result.password = new_config.password unless new_config.password == UNSET_VALUE
+          end
+          result
+        end
+
+        def finalize!
+          @unset = unset?
+          @prompt = nil if @prompt == UNSET_VALUE
+          @file_path = nil if @file_path == UNSET_VALUE
+          @username = nil if @username == UNSET_VALUE
+          @password = nil if @password == UNSET_VALUE
+        end
       end
     end
   end

data/lib/vagrant-orchestrate/plugin.rb

@@ -1,4 +1,5 @@
 require "vagrant-orchestrate/action/filtermanaged"
+require "vagrant-orchestrate/action/setcredentials"
 
 begin
   require "vagrant"
@@ -35,18 +36,22 @@ module VagrantPlugins
 
       action_hook(:orchestrate, :machine_action_up) do |hook|
         hook.prepend Action::FilterManaged
+        hook.prepend Action::SetCredentials
       end
 
       action_hook(:orchestrate, :machine_action_provision) do |hook|
         hook.prepend Action::FilterManaged
+        hook.prepend Action::SetCredentials
       end
 
       action_hook(:orchestrate, :machine_action_destroy) do |hook|
         hook.prepend Action::FilterManaged
+        hook.prepend Action::SetCredentials
       end
 
       action_hook(:orchestrate, :machine_action_reload) do |hook|
         hook.prepend Action::FilterManaged
+        hook.prepend Action::SetCredentials
       end
 
       # This initializes the internationalization strings.

data/lib/vagrant-orchestrate/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Orchestrate
-    VERSION = "0.3.2"
+    VERSION = "0.4.0"
   end
 end

data/templates/vagrant/Vagrantfile.erb

@@ -14,6 +14,12 @@ Vagrant.configure("2") do |config|
   # This disables up, provision, reload, and destroy for managed servers. Use
   # `vagrant orchestrate push` to communicate with managed servers.
   config.orchestrate.filter_managed_commands = true
+  <% if creds_prompt -%>
+  config.orchestrate.credentials.prompt = true
+  <% end -%>
+  <% if creds_file_path -%>
+  config.orchestrate.credentials.file_path = "<%= creds_file_path%>"
+  <% end -%>
 
   <% if provisioners.include? "shell" -%>
   <% shell_paths.each do |path| -%>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-orchestrate
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Christopher Baldauf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-23 00:00:00.000000000 Z
+date: 2015-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,9 +80,11 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- docs/strategy.md
 - dummy.box
 - lib/vagrant-orchestrate.rb
 - lib/vagrant-orchestrate/action/filtermanaged.rb
+- lib/vagrant-orchestrate/action/setcredentials.rb
 - lib/vagrant-orchestrate/command/init.rb
 - lib/vagrant-orchestrate/command/push.rb
 - lib/vagrant-orchestrate/command/root.rb