tnargav 1.3.5 → 1.3.6

data/plugins/providers/virtualbox/model/forwarded_port.rb

@@ -0,0 +1,70 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Model
+      # Represents a single forwarded port for VirtualBox. This has various
+      # helpers and defaults for a forwarded port.
+      class ForwardedPort
+        # The NAT adapter on which to attach the forwarded port.
+        #
+        # @return [Integer]
+        attr_reader :adapter
+
+        # If true, this port should be auto-corrected.
+        #
+        # @return [Boolean]
+        attr_reader :auto_correct
+
+        # The unique ID for the forwarded port.
+        #
+        # @return [String]
+        attr_reader :id
+
+        # The protocol to forward.
+        #
+        # @return [String]
+        attr_reader :protocol
+
+        # The IP that the forwarded port will connect to on the guest machine.
+        #
+        # @return [String]
+        attr_reader :guest_ip
+
+        # The port on the guest to be exposed on the host.
+        #
+        # @return [Integer]
+        attr_reader :guest_port
+
+        # The IP that the forwarded port will bind to on the host machine.
+        #
+        # @return [String]
+        attr_reader :host_ip
+
+        # The port on the host used to access the port on the guest.
+        #
+        # @return [Integer]
+        attr_reader :host_port
+
+        def initialize(id, host_port, guest_port, options)
+          @id         = id
+          @guest_port = guest_port
+          @host_port  = host_port
+
+          options ||= {}
+          @auto_correct = false
+          @auto_correct = options[:auto_correct] if options.has_key?(:auto_correct)
+          @adapter  = (options[:adapter] || 1).to_i
+          @guest_ip = options[:guest_ip] || nil
+          @host_ip = options[:host_ip] || nil
+          @protocol = options[:protocol] || "tcp"
+        end
+
+        # This corrects the host port and changes it to the given new port.
+        #
+        # @param [Integer] new_port The new port
+        def correct_host_port(new_port)
+          @host_port = new_port
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/plugin.rb

@@ -0,0 +1,42 @@
+require "vagrant"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    class Plugin < Vagrant.plugin("2")
+      name "VirtualBox provider"
+      description <<-EOF
+      The VirtualBox provider allows Vagrant to manage and control
+      VirtualBox-based virtual machines.
+      EOF
+
+      provider(:virtualbox) do
+        require File.expand_path("../provider", __FILE__)
+        Provider
+      end
+
+      config(:virtualbox, :provider) do
+        require File.expand_path("../config", __FILE__)
+        Config
+      end
+    end
+
+    autoload :Action, File.expand_path("../action", __FILE__)
+
+    # Drop some autoloads in here to optimize the performance of loading
+    # our drivers only when they are needed.
+    module Driver
+      autoload :Meta, File.expand_path("../driver/meta", __FILE__)
+      autoload :Version_4_0, File.expand_path("../driver/version_4_0", __FILE__)
+      autoload :Version_4_1, File.expand_path("../driver/version_4_1", __FILE__)
+      autoload :Version_4_2, File.expand_path("../driver/version_4_2", __FILE__)
+    end
+
+    module Model
+      autoload :ForwardedPort, File.expand_path("../model/forwarded_port", __FILE__)
+    end
+
+    module Util
+      autoload :CompileForwardedPorts, File.expand_path("../util/compile_forwarded_ports", __FILE__)
+    end
+  end
+end

data/plugins/providers/virtualbox/provider.rb

@@ -0,0 +1,92 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    class Provider < Vagrant.plugin("2", :provider)
+      attr_reader :driver
+
+      def initialize(machine)
+        @logger  = Log4r::Logger.new("vagrant::provider::virtualbox")
+        @machine = machine
+
+        # This method will load in our driver, so we call it now to
+        # initialize it.
+        machine_id_changed
+      end
+
+      # @see Vagrant::Plugin::V1::Provider#action
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      # If the machine ID changed, then we need to rebuild our underlying
+      # driver.
+      def machine_id_changed
+        id = @machine.id
+
+        begin
+          @logger.debug("Instantiating the driver for machine ID: #{@machine.id.inspect}")
+          @driver = Driver::Meta.new(id)
+        rescue Driver::Meta::VMNotFound
+          # The virtual machine doesn't exist, so we probably have a stale
+          # ID. Just clear the id out of the machine and reload it.
+          @logger.debug("VM not found! Clearing saved machine ID and reloading.")
+          id = nil
+          retry
+        end
+      end
+
+      # Returns the SSH info for accessing the VirtualBox VM.
+      def ssh_info
+        # If the VM is not created then we cannot possibly SSH into it, so
+        # we return nil.
+        return nil if state.id == :not_created
+
+        # Return what we know. The host is always "127.0.0.1" because
+        # VirtualBox VMs are always local. The port we try to discover
+        # by reading the forwarded ports.
+        return {
+          :host => "127.0.0.1",
+          :port => @driver.ssh_port(@machine.config.ssh.guest_port)
+        }
+      end
+
+      # Return the state of VirtualBox virtual machine by actually
+      # querying VBoxManage.
+      #
+      # @return [Symbol]
+      def state
+        # XXX: What happens if we destroy the VM but the UUID is still
+        # set here?
+
+        # Determine the ID of the state here.
+        state_id = nil
+        state_id = :not_created if !@driver.uuid
+        state_id = @driver.read_state if !state_id
+        state_id = :unknown if !state_id
+
+        # Translate into short/long descriptions
+        short = state_id.to_s.gsub("_", " ")
+        long  = I18n.t("vagrant.commands.status.#{state_id}")
+
+        # Return the state
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      # Returns a human-friendly string version of this provider which
+      # includes the machine's ID that this provider represents, if it
+      # has one.
+      #
+      # @return [String]
+      def to_s
+        id = @machine.id ? @machine.id : "new VM"
+        "VirtualBox (#{id})"
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/util/compile_forwarded_ports.rb

@@ -0,0 +1,35 @@
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Util
+      module CompileForwardedPorts
+        include Vagrant::Util::ScopedHashOverride
+
+        # This method compiles the forwarded ports into {ForwardedPort}
+        # models.
+        def compile_forwarded_ports(config)
+          mappings = {}
+
+          config.vm.networks.each do |type, options|
+            if type == :forwarded_port
+              guest_port = options[:guest]
+              host_port  = options[:host]
+              protocol   = options[:protocol] || "tcp"
+              options    = scoped_hash_override(options, :virtualbox)
+              id         = options[:id]
+
+              # If the forwarded port was marked as disabled, ignore.
+              next if options[:disabled]
+
+              mappings[host_port.to_s + protocol.to_s] =
+                Model::ForwardedPort.new(id, host_port, guest_port, options)
+            end
+          end
+
+          mappings.values
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/ansible/config.rb

@@ -0,0 +1,89 @@
+module VagrantPlugins
+  module Ansible
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :playbook
+      attr_accessor :extra_vars
+      attr_accessor :inventory_path
+      attr_accessor :ask_sudo_pass
+      attr_accessor :limit
+      attr_accessor :sudo
+      attr_accessor :sudo_user
+      attr_accessor :verbose
+      attr_accessor :tags
+      attr_accessor :skip_tags
+      attr_accessor :start_at_task
+      attr_accessor :host_key_checking
+
+      # Joker attribute, used to pass unsupported arguments to ansible anyway
+      attr_accessor :raw_arguments
+
+      def initialize
+        @playbook          = UNSET_VALUE
+        @extra_vars        = UNSET_VALUE
+        @inventory_path    = UNSET_VALUE
+        @ask_sudo_pass     = UNSET_VALUE
+        @limit             = UNSET_VALUE
+        @sudo              = UNSET_VALUE
+        @sudo_user         = UNSET_VALUE
+        @verbose           = UNSET_VALUE
+        @tags              = UNSET_VALUE
+        @skip_tags         = UNSET_VALUE
+        @start_at_task     = UNSET_VALUE
+        @raw_arguments     = UNSET_VALUE
+        @host_key_checking = "true"
+      end
+
+      def finalize!
+        @playbook          = nil if @playbook == UNSET_VALUE
+        @extra_vars        = nil if @extra_vars == UNSET_VALUE
+        @inventory_path    = nil if @inventory_path == UNSET_VALUE
+        @ask_sudo_pass     = nil if @ask_sudo_pass == UNSET_VALUE
+        @limit             = nil if @limit == UNSET_VALUE
+        @sudo              = nil if @sudo == UNSET_VALUE
+        @sudo_user         = nil if @sudo_user == UNSET_VALUE
+        @verbose           = nil if @verbose == UNSET_VALUE
+        @tags              = nil if @tags == UNSET_VALUE
+        @skip_tags         = nil if @skip_tags == UNSET_VALUE
+        @start_at_task     = nil if @start_at_task == UNSET_VALUE
+        @raw_arguments     = nil if @raw_arguments == UNSET_VALUE
+        @host_key_checking = nil if @host_key_checking == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        # Validate that a playbook path was provided
+        if !playbook
+          errors << I18n.t("vagrant.provisioners.ansible.no_playbook")
+        end
+
+        # Validate the existence of said playbook on the host
+        if playbook
+          expanded_path = Pathname.new(playbook).expand_path(machine.env.root_path)
+          if !expanded_path.file?
+            errors << I18n.t("vagrant.provisioners.ansible.playbook_path_invalid",
+                              :path => expanded_path)
+          end
+        end
+
+        # Validate that extra_vars is a hash, if set
+        if extra_vars
+          if !extra_vars.kind_of?(Hash)
+            errors << I18n.t("vagrant.provisioners.ansible.extra_vars_not_hash")
+          end
+        end
+
+        # Validate the existence of the inventory_path, if specified
+        if inventory_path
+          expanded_path = Pathname.new(inventory_path).expand_path(machine.env.root_path)
+          if !expanded_path.exist?
+            errors << I18n.t("vagrant.provisioners.ansible.inventory_path_invalid",
+                              :path => expanded_path)
+          end
+        end
+
+        { "ansible provisioner" => errors }
+      end
+    end
+  end
+end

data/plugins/provisioners/ansible/plugin.rb

@@ -0,0 +1,23 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Ansible
+    class Plugin < Vagrant.plugin("2")
+      name "ansible"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      Ansible playbooks.
+      DESC
+
+      config(:ansible, :provisioner) do
+        require File.expand_path("../config", __FILE__)
+        Config
+      end
+
+      provisioner(:ansible) do
+        require File.expand_path("../provisioner", __FILE__)
+        Provisioner
+      end
+    end
+  end
+end

data/plugins/provisioners/ansible/provisioner.rb

@@ -0,0 +1,100 @@
+module VagrantPlugins
+  module Ansible
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+      def provision
+        ssh = @machine.ssh_info
+
+        # Connect with Vagrant user (unless --user or --private-key are overidden by 'raw_arguments')
+        options = %W[--private-key=#{ssh[:private_key_path]} --user=#{ssh[:username]}]
+
+        # Joker! Not (yet) supported arguments can be passed this way.
+        options << "#{config.raw_arguments}" if config.raw_arguments
+
+        # Append Provisioner options (higher precedence):
+        if config.extra_vars
+          extra_vars = config.extra_vars.map do |k,v|
+            v = v.gsub('"', '\\"')
+            if v.include?(' ')
+              v = v.gsub("'", "\\'")
+              v = "'#{v}'"
+            end
+
+            "#{k}=#{v}"
+          end
+          options << "--extra-vars=\"#{extra_vars.join(" ")}\""
+        end
+
+        options << "--inventory-file=#{self.setup_inventory_file}"
+        options << "--sudo" if config.sudo
+        options << "--sudo-user=#{config.sudo_user}" if config.sudo_user
+        options << "#{self.get_verbosity_argument}"
+        options << "--ask-sudo-pass" if config.ask_sudo_pass
+        options << "--tags=#{as_list_argument(config.tags)}" if config.tags
+        options << "--skip-tags=#{as_list_argument(config.skip_tags)}" if config.skip_tags
+        options << "--limit=#{as_list_argument(config.limit)}" if config.limit
+        options << "--start-at-task=#{config.start_at_task}" if config.start_at_task
+
+        # Assemble the full ansible-playbook command
+        command = (%w(ansible-playbook) << options << config.playbook).flatten
+
+        # Write stdout and stderr data, since it's the regular Ansible output
+        command << {
+          :env => {
+            "ANSIBLE_FORCE_COLOR" => "true",
+            "ANSIBLE_HOST_KEY_CHECKING" => "#{config.host_key_checking}"
+          },
+          :notify => [:stdout, :stderr],
+          :workdir => @machine.env.root_path.to_s
+        }
+
+        begin
+          result = Vagrant::Util::Subprocess.execute(*command) do |type, data|
+            if type == :stdout || type == :stderr
+              @machine.env.ui.info(data, :new_line => false, :prefix => false)
+            end
+          end
+
+          raise Vagrant::Errors::AnsibleFailed if result.exit_code != 0
+        rescue Vagrant::Util::Subprocess::LaunchError
+          raise Vagrant::Errors::AnsiblePlaybookAppNotFound
+        end
+      end
+
+      protected
+
+      # Auto-generate "safe" inventory file based on Vagrantfile,
+      # unless inventory_path is explicitly provided
+      def setup_inventory_file
+        return config.inventory_path if config.inventory_path
+
+        ssh = @machine.ssh_info
+
+        generated_inventory_file =
+          @machine.env.root_path.join("vagrant_ansible_inventory_#{machine.name}")
+
+        generated_inventory_file.open('w') do |file|
+          file.write("# Generated by Vagrant\n\n")
+          file.write("#{machine.name} ansible_ssh_host=#{ssh[:host]} ansible_ssh_port=#{ssh[:port]}\n")
+        end
+
+        return generated_inventory_file.to_s
+      end
+
+      def get_verbosity_argument
+        if config.verbose.to_s =~ /^v+$/
+          # Hopefully ansible-playbook accepts "silly" arguments like '-vvvvv', as '-vvv'
+          return "-#{config.verbose}"
+        elsif config.verbose.to_s == 'extra'
+          return '-vvv'
+        else
+          # fall back to default verbosity
+          return '--verbose'
+        end
+      end
+
+      def as_list_argument(v)
+        v.kind_of?(Array) ? v.join(',') : v
+      end
+    end
+  end
+end