vagrant-orchestrate 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85f4c2c23fc36ac0e8c472263b585d736444cde7
+  data.tar.gz: d85359d431acc54e007e5089e97b5391dc2af394
+SHA512:
+  metadata.gz: 14e2b97efed9fd854b9abdb285869780a8e9145f07747105da88e902c73845e4b50d779c9e1059d70d8d59cd4b071181abe419a5ea55f95dd6e954a6a7f96208
+  data.tar.gz: bcfe1a59b4013c6905132bced3e6dc9f3617b5edb3594e268ea32ac81e34c846a3191a88ae14c7380cd14f0d2b122402da117bdf345f31035e400433a9dff51a

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+/.vagrant/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,18 @@
+AllCops:
+  Exclude:
+    - '*.gemspec'
+
+Metrics/LineLength:
+  Max: 120
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 20
+
+StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/FileName:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in vagrant-orchestrate.gemspec
+gemspec
+
+group :development do
+  gem "vagrant", git: "https://github.com/mitchellh/vagrant.git"
+  gem "vagrant-spec", git: "https://github.com/mitchellh/vagrant-spec.git"
+end
+
+group :plugins do
+  gem "vagrant-orchestrate", path: "."
+  gem "vagrant-managed-servers"
+end

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014 Cimpress
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,57 @@
+# Vagrant Orchestrate
+
+This is a Vagrant 1.6+ plugin that allows orchestrated deployments
+to existing servers on top of the excellent vagrant-managed-servers plugin.
+It features a powerful templating `init` command and is designed from the
+ground up to be cross-platform, with first class support for Windows,
+Linux, and Mac.
+
+## Usage
+
+Install using the standard Vagrant plugin installation method:
+
+    $ vagrant plugin install vagrant-orchestrate
+
+### Initialization
+Initialize a Vagrantfile to orchestrate running a script on multiple managed servers
+
+    $ vagrant orchestrate init --shell
+
+You'll need to edit your Vagrantfile and replace some of variables, such as ssh username and
+password, and the path to the script to run. The first line of the file defines an array of
+managed servers that the `push` command will operate on.
+
+This works for Windows managed servers as well
+
+    $ vagrant orchestrate init --winrm [--winrm-username=USERNAME --winrm-password=PASSWORD]
+
+For a full list of init options, run `vagrant orchestrate init --help`
+
+### Pushing changes
+Go ahead and push changes to your managed servers.
+
+    $ vagrant orchestrate push
+
+You can run vagrant with increased verbosity if you run into problems
+
+    $ vagrant orchestrate push --debug
+
+## Branching strategy
+
+If you have several environments (e.g. dev, test, prod), it is recommended to create
+a separate branch for each environment and put the appropriate servers into the
+managed_servers array at the top of the Vagrantfile for each. To move a change
+across branches, simply create a feature branch from your earliest branch and then
+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]() to install rsync. Vagrant managed servers currently only works with cygwin based rsync implementations.
+
+## Contributing
+
+1. Fork it ( https://github.com/chrisbaldauf/vagrant-orchestrate/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new

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

@@ -0,0 +1,145 @@
+require "optparse"
+require "vagrant"
+
+# rubocop:disable Metrics/ClassLength
+module VagrantPlugins
+  module Orchestrate
+    module Command
+      class Init < Vagrant.plugin("2", :command)
+        include Vagrant::Util
+
+        DEFAULT_SHELL_PATH = "{{YOUR_SCRIPT_PATH}}"
+        DEFAULT_SHELL_INLINE = "{{YOUR_SCRIPT_COMMAND}}"
+        DEFAULT_WINRM_USERNAME = "{{YOUR_WINRM_USERNAME}}"
+        DEFAULT_WINRM_PASSWORD = "{{YOUR_WINRM_PASSWORD}}"
+        DEFAULT_SSH_USERNAME = "{{YOUR_SSH_USERNAME}}"
+        DEFAULT_SSH_PASSWORD = "{{YOUR_SSH_PASSWORD}}"
+        DEFAULT_SSH_PRIVATE_KEY_PATH = "{{YOUR_SSH_PRIVATE_KEY_PATH}}"
+        DEFAULT_PLUGINS = ["vagrant-managed-servers"]
+
+        # rubocop:disable Metrics/AbcSize, MethodLength
+        def execute
+          options = {}
+
+          options[:provisioners] = []
+          options[:servers] = []
+          options[:plugins] = DEFAULT_PLUGINS
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant orchestrate init [options]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("--provision-with x,y,z", Array, "Init only certain provisioners, by type.") do |list|
+              options[:provisioners] = list
+            end
+
+            o.on("--shell", "Shorthand for --provision-with shell") do
+              options[:provisioners] << "shell"
+            end
+
+            o.on("--shell-paths x,y,z", Array,
+                 "Comma separated list of shell scripts to run on provision. Only with --shell") do |list|
+              options[:shell_paths] = list
+            end
+
+            o.on("--shell-inline command", String, "Inline script to run. Only with --shell") do |c|
+              options[:shell_inline] = c
+            end
+
+            o.on("--puppet", "Shorthand for --provisioner-with=puppet") do
+              options[:provisioners] << "puppet"
+            end
+
+            o.on("--ssh-username USERNAME", String, "The username for communicating over ssh") do |u|
+              options[:ssh_username] = u
+            end
+
+            o.on("--ssh-password PASSWORD", String, "The username for communicating over ssh") do |p|
+              options[:ssh_password] = p
+            end
+
+            o.on("--ssh-private-key-path PATH", String, "Paths to the private key for communinicating over ssh") do |k|
+              options[:ssh_private_key_path] = k
+            end
+
+            o.on("--winrm", "Use the winrm communicator") do
+              options[:communicator] = "winrm"
+            end
+
+            o.on("--winrm-username USERNAME", String, "The username for communicating with winrm") do |u|
+              options[:winrm_username] = u
+            end
+
+            o.on("--winrm-password PASSWORD", String, "The password for communicating with winrm") do |p|
+              options[:winrm_password] = p
+            end
+
+            o.on("--plugins x,y,z", Array, "A comma separated list of vagrant plugins to be installed") do |p|
+              options[:plugins] += p
+            end
+
+            o.on("--servers x,y,z", Array, "A comma separated list of servers hostnames or IPs to deploy to") do |list|
+              options[:servers] = list
+            end
+
+            o.on("-f", "--force", "Force overwriting of files") do
+              options[:force] = true
+            end
+          end
+
+          argv = parse_options(opts)
+          return unless argv
+
+          options[:shell_paths] ||= options[:shell_inline] ? [] : [DEFAULT_SHELL_PATH]
+          options[:shell_inline] ||= DEFAULT_SHELL_INLINE
+          options[:winrm_username] ||= DEFAULT_WINRM_USERNAME
+          options[:winrm_password] ||= DEFAULT_WINRM_PASSWORD
+          options[:communicator] ||= "ssh"
+          options[:ssh_username] ||= DEFAULT_SSH_USERNAME
+          options[:ssh_password] ||= DEFAULT_SSH_PASSWORD unless options[:ssh_private_key_path]
+          options[:ssh_private_key_path] ||= DEFAULT_SSH_PRIVATE_KEY_PATH
+
+          contents = TemplateRenderer.render(Orchestrate.source_root.join("templates/vagrant/Vagrantfile"),
+                                             provisioners: options[:provisioners],
+                                             shell_paths: options[:shell_paths],
+                                             shell_inline: options[:shell_inline],
+                                             communicator: options[:communicator],
+                                             winrm_username: options[:winrm_username],
+                                             winrm_password: options[:winrm_password],
+                                             ssh_username: options[:ssh_username],
+                                             ssh_password: options[:ssh_password],
+                                             ssh_private_key_path: options[:ssh_private_key_path],
+                                             servers: options[:servers],
+                                             plugins: options[:plugins]
+                                             )
+          write_vagrantfile(contents, options)
+
+          @env.ui.info(I18n.t("vagrant.commands.init.success"), prefix: false)
+
+          # Success, exit status 0
+          0
+        end
+        # rubocop:enable Metrics/AbcSize, MethodLength
+
+        private
+
+        def write_vagrantfile(contents, options)
+          save_path = Pathname.new("Vagrantfile").expand_path(@env.cwd)
+          save_path.delete if save_path.exist? && options[:force]
+          fail Vagrant::Errors::VagrantfileExistsError if save_path.exist?
+
+          begin
+            save_path.open("w+") do |f|
+              f.write(contents)
+            end
+          rescue Errno::EACCES
+            raise Vagrant::Errors::VagrantfileWriteError
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength

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

@@ -0,0 +1,35 @@
+require "optparse"
+require "vagrant"
+
+module VagrantPlugins
+  module Orchestrate
+    module Command
+      class Push < Vagrant.plugin("2", :command)
+        include Vagrant::Util
+
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant orchestrate push"
+            o.separator ""
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+
+          with_target_vms(argv, provider: :managed) do |machine|
+            unless machine.name.to_s.start_with? "managed-"
+              @logger.debug("Skipping machine #{machine.name}")
+              next
+            end
+
+            machine.action(:up, options)
+            machine.action(:provision, options)
+            machine.action(:destroy, options)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require "optparse"
+require "vagrant"
+
+module VagrantPlugins
+  module Orchestrate
+    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'
+        end
+
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+
+          @subcommands.register(:init) do
+            require_relative "init"
+            Init
+          end
+
+          @subcommands.register(:push) do
+            require_relative "push"
+            Push
+          end
+        end
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the box commands.
+            return help
+          end
+
+          # If we reached this far then we must have a subcommand. If not,
+          # then we also just print the help and exit.
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        # Prints the help out for this command
+        # rubocop:disable Metrics/AbcSize
+        def help
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant orchestrate <subcommand> [<args>]"
+            o.separator ""
+            o.separator "Available subcommands:"
+
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, _value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              o.separator "     #{key}"
+            end
+
+            o.separator ""
+            o.separator "For help on any individual subcommand run `vagrant orchestrate <subcommand> -h`"
+          end
+
+          @env.ui.info(opts.help, prefix: false)
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/vagrant-orchestrate/plugin.rb

@@ -0,0 +1,62 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant Orchestrate plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.6.0"
+  fail "The Vagrant Orchestrate plugin is only compatible with Vagrant 1.6+"
+end
+
+module VagrantPlugins
+  module Orchestrate
+    class Plugin < Vagrant.plugin("2")
+      name "Orchestrate"
+      description <<-DESC
+      This plugin installs commands that make pushing changes to vagrant-managed-servers easy.
+      DESC
+
+      command(:orchestrate) do
+        require_relative "command/root"
+        Command::Root
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", Orchestrate.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil unless level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          Log4r::Logger.new("vagrant_orchestrate").tap do |logger|
+            logger.outputters = Log4r::Outputter.stderr
+            logger.level = level
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-orchestrate/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Orchestrate
+    VERSION = "0.0.1"
+  end
+end

data/lib/vagrant-orchestrate.rb

@@ -0,0 +1,12 @@
+require "vagrant-orchestrate/plugin"
+
+module VagrantPlugins
+  module Orchestrate
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+end
+
+def capture_stdout(&_block)
+  original_stdout = $stdout
+  $stdout = fake = StringIO.new
+  begin
+    yield
+  ensure
+    $stdout = original_stdout
+  end
+  fake.string
+end

data/spec/vagrant-orchestrate/command/init_spec.rb

@@ -0,0 +1,198 @@
+require "vagrant-orchestrate/command/init"
+require "vagrant-spec/unit"
+require "pp"
+
+describe VagrantPlugins::Orchestrate::Command::Init do
+  include_context "vagrant-unit"
+
+  let(:base_argv)     { ["-f"] }
+  let(:argv)          { [] }
+  let(:iso_env) do
+    env = isolated_environment
+    # We need to load an empty vagrantfile in order for things to be initialized
+    # properly
+    env.vagrantfile("")
+    env.create_vagrant_env ui_class: ui_class
+  end
+
+  let(:ui_class) { nil }
+
+  subject { described_class.new(base_argv + argv, iso_env) }
+
+  ["-h", "--help"].each do |arg|
+    describe "init help message #{arg}" do
+      let(:argv) { ["init", arg] }
+      let(:ui_class) { Vagrant::UI::Basic }
+      it "shows help" do
+        output = capture_stdout { subject.execute }
+        expect(output).to include("Usage: vagrant orchestrate init [options]")
+      end
+    end
+  end
+
+  describe "no parameters" do
+    it "creates basic vagrantfile" do
+      subject.execute
+      expect(Dir.entries(iso_env.cwd)).to include("Vagrantfile")
+    end
+  end
+
+  context "shell provisioner" do
+    describe "basic operation" do
+      let(:argv) { ["--shell"] }
+      it "creates a vagrantfile with default shell path" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.vm.provisioners.first.type).to eq(:shell)
+        expect(iso_env.vagrantfile.config.vm.provisioners.first.config.path).to eq(described_class::DEFAULT_SHELL_PATH)
+      end
+    end
+
+    describe "shell path" do
+      let(:argv) { ["--shell", "--shell-paths", "foo.sh"] }
+      it "creates a vagrantfile with custom shell path" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.vm.provisioners.first.type).to eq(:shell)
+        expect(iso_env.vagrantfile.config.vm.provisioners.first.config.path).to eq("foo.sh")
+      end
+    end
+
+    describe "shell inline" do
+      let(:argv) { ["--shell", "--shell-inline", "echo Hello, World!"] }
+      it "is passed through" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.vm.provisioners.first.config.inline).to eq("echo Hello, World!")
+      end
+    end
+
+    describe "multiple shell paths" do
+      let(:argv) { ["--shell", "--shell-paths", "foo.sh,bar.sh"] }
+      it "creates a vagrantfile with custom shell path" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.vm.provisioners.first.type).to eq(:shell)
+        expect(iso_env.vagrantfile.config.vm.provisioners.first.config.path).to eq("foo.sh")
+        expect(iso_env.vagrantfile.config.vm.provisioners[1].config.path).to eq("bar.sh")
+      end
+    end
+  end
+
+  context "puppet provisioner" do
+    describe "basic operation" do
+      let(:argv) { ["--provision-with", "puppet"] }
+      it "creates a vagrantfile with a puppet provisioner" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.vm.provisioners.first.type).to eq(:puppet)
+      end
+    end
+
+    describe "shorthand" do
+      let(:argv) { ["--puppet"] }
+      it "creates a vagrantfile with a puppet provisioner" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.vm.provisioners.first.type).to eq(:puppet)
+      end
+    end
+  end
+
+  context "winrm" do
+    describe "basic" do
+      let(:argv) { ["--winrm"] }
+      it "creates a vagrantfile with the winrm communicator" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.vm.communicator).to eq(:winrm)
+        expect(iso_env.vagrantfile.config.winrm.username).to eq(described_class::DEFAULT_WINRM_USERNAME)
+        expect(iso_env.vagrantfile.config.winrm.password).to eq(described_class::DEFAULT_WINRM_PASSWORD)
+      end
+    end
+
+    describe "username" do
+      let(:argv) { ["--winrm", "--winrm-username", "WINRM_USERNAME"] }
+      it "is parsed correctly" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.winrm.username).to eq("WINRM_USERNAME")
+      end
+    end
+
+    describe "password" do
+      let(:argv) { ["--winrm", "--winrm-password", "WINRM_PASSWORD"] }
+      it "is parsed correctly" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.winrm.password).to eq("WINRM_PASSWORD")
+      end
+    end
+  end
+
+  context "ssh" do
+    describe "default" do
+      it "has default username and password" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.ssh.username).to eq(described_class::DEFAULT_SSH_USERNAME)
+        expect(iso_env.vagrantfile.config.ssh.password).to eq(described_class::DEFAULT_SSH_PASSWORD)
+      end
+    end
+
+    describe "username" do
+      let(:argv) { ["--ssh-username", "SSH_USERNAME"] }
+      it "is passed through" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.ssh.username).to eq("SSH_USERNAME")
+      end
+    end
+
+    describe "password" do
+      let(:argv) { ["--ssh-password", "SSH_PASSWORD"] }
+      it "is passed through" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.ssh.password).to eq("SSH_PASSWORD")
+      end
+    end
+
+    describe "private key path" do
+      let(:argv) { ["--ssh-private-key-path", "SSH_PRIVATE_KEY_PATH"] }
+      it "is passed through" do
+        subject.execute
+        expect(iso_env.vagrantfile.config.ssh.private_key_path.first).to eq("SSH_PRIVATE_KEY_PATH")
+      end
+    end
+  end
+
+  context "plugins" do
+    describe "default" do
+      it "has default plugins in vagrantfile" do
+        subject.execute
+        # Since the plugin stuff isn't part of the actual Vagrantfile spec, we'll
+        # just peek at the text of the file
+        vagrantfile = File.readlines(File.join(iso_env.cwd, "Vagrantfile")).join
+        expect(vagrantfile).to include("required_plugins = %w( #{described_class::DEFAULT_PLUGINS.join(' ')} )")
+      end
+    end
+
+    describe "specified plugins" do
+      let(:argv) { ["--plugins", "plugin1,plugin2"] }
+      it "are required" do
+        subject.execute
+        expected = "required_plugins = %w( #{described_class::DEFAULT_PLUGINS.join(' ')} plugin1 plugin2 )"
+        vagrantfile = File.readlines(File.join(iso_env.cwd, "Vagrantfile")).join
+        expect(vagrantfile).to include(expected)
+      end
+    end
+  end
+
+  context "servers" do
+    describe "default" do
+      it "has no servers in vagrantfile" do
+        subject.execute
+        vagrantfile = File.readlines(File.join(iso_env.cwd, "Vagrantfile")).join
+        expect(vagrantfile).to include("managed_servers = %w( )")
+      end
+    end
+
+    describe "specified servers" do
+      let(:argv) { ["--servers", "server1,server2"] }
+      it "are required" do
+        subject.execute
+        vagrantfile = File.readlines(File.join(iso_env.cwd, "Vagrantfile")).join
+        expect(vagrantfile).to include("managed_servers = %w( server1 server2 )")
+      end
+    end
+  end
+end

data/spec/vagrant-orchestrate/command/root_spec.rb

@@ -0,0 +1,27 @@
+require "vagrant-orchestrate/command/root"
+require "vagrant-orchestrate/command/init"
+require "vagrant-spec/unit"
+
+describe VagrantPlugins::Orchestrate::Command::Root do
+  include_context "vagrant-unit"
+
+  let(:argv)     { [] }
+  let(:iso_env) do
+    env = isolated_environment
+    env.vagrantfile("")
+    env.create_vagrant_env ui_class: Vagrant::UI::Basic
+  end
+
+  subject { described_class.new(argv, iso_env) }
+
+  ["", "-h", "--help"].each do |arg|
+    describe "root help message #{arg}" do
+      let(:argv) { [arg] }
+      it "shows help" do
+        output = capture_stdout { subject.execute }
+        expect(output).to \
+          include("Usage: vagrant orchestrate <subcommand> [<args>]")
+      end
+    end
+  end
+end

data/templates/vagrant/Vagrantfile.erb

@@ -0,0 +1,45 @@
+managed_servers = %w( <% servers.each do |s| -%><%= s %> <% end -%>)
+
+<% if plugins.any? -%>
+required_plugins = %w( <% plugins.each do |p| -%><%= p %> <% end -%>)
+required_plugins.each do |plugin|
+  system "vagrant plugin install #{plugin}" unless Vagrant.has_plugin? plugin
+end
+<% end %>
+Vagrant.configure("2") do |config|
+  <% if provisioners.include? "shell" -%>
+  <% shell_paths.each do |path| -%>
+  config.vm.provision "shell", path: "<%= path %>"
+  <% end -%>
+  <% if shell_inline -%>
+  config.vm.provision "shell", inline: "<%= shell_inline %>"
+  <% end -%>
+  <% end -%>
+  <% if provisioners.include? "puppet" -%>
+  config.vm.provision "puppet" do |puppet|
+  end
+  <% end -%>
+  <% if communicator == "ssh" -%>
+  config.ssh.username = "<%= ssh_username %>"
+  <% if ssh_password -%>
+  config.ssh.password = "<%= ssh_password %>"
+  <% end -%>
+  <% if !ssh_password -%>
+  config.ssh.private_key_path = "<%= ssh_private_key_path %>"
+  <% end -%>
+  <% end -%>
+  <% if communicator == "winrm" -%>
+  config.vm.communicator = "<%= communicator %>"
+  config.winrm.username = "<%= winrm_username %>"
+  config.winrm.password = "<%= winrm_password %>"
+  <% end -%>
+
+  managed_servers.each do |instance|
+    config.vm.define "managed-#{instance}" do |box|
+      box.vm.box = "tknerr/managed-server-dummy"
+      box.vm.provider :managed do |provider|
+        provider.server = instance
+      end
+    end
+  end
+end

data/vagrant-orchestrate.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-orchestrate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'vagrant-orchestrate'
+  spec.version       = VagrantPlugins::Orchestrate::VERSION
+  spec.authors       = ['Christopher Baldauf']
+  spec.email         = ['cbaldauf@cimpress.com']
+  spec.summary       = 'Vagrant plugin to orchestrate the deployment of managed servers.'
+  spec.homepage      = ''
+  spec.license       = 'Apache 2.0'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  # See Gemfile for additional development dependencies that were not available
+  # on rubygems (or another gem source), but needed to be downloaded from git.
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-orchestrate
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Christopher Baldauf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- cbaldauf@cimpress.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rubocop.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/vagrant-orchestrate.rb
+- lib/vagrant-orchestrate/command/init.rb
+- lib/vagrant-orchestrate/command/push.rb
+- lib/vagrant-orchestrate/command/root.rb
+- lib/vagrant-orchestrate/plugin.rb
+- lib/vagrant-orchestrate/version.rb
+- locales/en.yml
+- spec/spec_helper.rb
+- spec/vagrant-orchestrate/command/init_spec.rb
+- spec/vagrant-orchestrate/command/root_spec.rb
+- templates/vagrant/Vagrantfile.erb
+- vagrant-orchestrate.gemspec
+homepage: ''
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Vagrant plugin to orchestrate the deployment of managed servers.
+test_files:
+- spec/spec_helper.rb
+- spec/vagrant-orchestrate/command/init_spec.rb
+- spec/vagrant-orchestrate/command/root_spec.rb