vagrant-lxc 0.0.1

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

@@ -0,0 +1,58 @@
+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 port on the guest to be exposed on the host.
+        #
+        # @return [Integer]
+        attr_reader :guest_port
+
+        # 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 = true
+          @auto_correct = options[:auto_correct] if options.has_key?(:auto_correct)
+          @adapter  = options[:adapter] || 1
+          @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/vendor/vagrant/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/vendor/vagrant/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 == :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/vendor/vagrant/plugins/providers/virtualbox/util/compile_forwarded_ports.rb

@@ -0,0 +1,31 @@
+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]
+              options    = scoped_hash_override(options, :virtualbox)
+              id         = options[:id]
+
+              mappings[host_port] =
+                Model::ForwardedPort.new(id, host_port, guest_port, options)
+            end
+          end
+
+          mappings.values
+        end
+      end
+    end
+  end
+end

data/vendor/vagrant/plugins/provisioners/chef/config/base.rb

@@ -0,0 +1,65 @@
+module VagrantPlugins
+  module Chef
+    module Config
+      class Base < Vagrant.plugin("2", :config)
+        # Shared config
+        attr_accessor :node_name
+        attr_accessor :provisioning_path
+        attr_accessor :log_level
+        attr_accessor :json
+        attr_accessor :http_proxy
+        attr_accessor :http_proxy_user
+        attr_accessor :http_proxy_pass
+        attr_accessor :https_proxy
+        attr_accessor :https_proxy_user
+        attr_accessor :https_proxy_pass
+        attr_accessor :no_proxy
+        attr_accessor :binary_path
+        attr_accessor :binary_env
+        attr_accessor :attempts
+        attr_accessor :arguments
+        attr_writer :run_list
+
+        # Provide defaults in such a way that they won't override the instance
+        # variable. This is so merging continues to work properly.
+        def attempts; @attempts || 1; end
+        def json; @json ||= {}; end
+        def log_level; @log_level || :info; end
+
+        # This returns the json that is merged with the defaults and the
+        # user set data.
+        def merged_json
+          original = { :instance_role => "vagrant" }
+          original[:run_list] = @run_list if @run_list
+          original.merge(json || {})
+        end
+
+        # Returns the run list, but also sets it up to be empty if it
+        # hasn't been defined already.
+        def run_list
+          @run_list ||= []
+        end
+
+        # Adds a recipe to the run list
+        def add_recipe(name)
+          name = "recipe[#{name}]" unless name =~ /^recipe\[(.+?)\]$/
+            run_list << name
+        end
+
+        # Adds a role to the run list
+        def add_role(name)
+          name = "role[#{name}]" unless name =~ /^role\[(.+?)\]$/
+            run_list << name
+        end
+
+        def instance_variables_hash
+          # Overridden so that the 'json' key could be removed, since its just
+          # merged into the config anyways
+          result = super
+          result.delete("json")
+          result
+        end
+      end
+    end
+  end
+end

data/vendor/vagrant/plugins/provisioners/chef/config/chef_client.rb

@@ -0,0 +1,39 @@
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module Chef
+    module Config
+      class ChefClient < Base
+        attr_accessor :chef_server_url
+        attr_accessor :validation_key_path
+        attr_accessor :validation_client_name
+        attr_accessor :client_key_path
+        attr_accessor :file_cache_path
+        attr_accessor :file_backup_path
+        attr_accessor :environment
+        attr_accessor :encrypted_data_bag_secret_key_path
+        attr_accessor :encrypted_data_bag_secret
+
+        # Provide defaults in such a way that they won't override the instance
+        # variable. This is so merging continues to work properly.
+        def validation_client_name; @validation_client_name || "chef-validator"; end
+        def client_key_path; @client_key_path || "/etc/chef/client.pem"; end
+        def file_cache_path; @file_cache_path || "/srv/chef/file_store"; end
+        def file_backup_path; @file_backup_path || "/srv/chef/cache"; end
+        def encrypted_data_bag_secret; @encrypted_data_bag_secret || "/tmp/encrypted_data_bag_secret"; end
+
+        def validate(machine)
+          errors = []
+          errors << I18n.t("vagrant.config.chef.server_url_empty") if \
+            !chef_server_url || chef_server_url.strip == ""
+          errors << I18n.t("vagrant.config.chef.validation_key_path") if \
+            !validation_key_path
+          errors << I18n.t("vagrant.config.chef.run_list_empty") if \
+            @run_list && @run_list.empty?
+
+          { "chef client provisioner" => errors }
+        end
+      end
+    end
+  end
+end

data/vendor/vagrant/plugins/provisioners/chef/config/chef_solo.rb

@@ -0,0 +1,87 @@
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module Chef
+    module Config
+      class ChefSolo < Base
+        attr_accessor :cookbooks_path
+        attr_accessor :roles_path
+        attr_accessor :data_bags_path
+        attr_accessor :recipe_url
+        attr_accessor :nfs
+        attr_accessor :encrypted_data_bag_secret_key_path
+        attr_accessor :encrypted_data_bag_secret
+
+        def initialize
+          super
+
+          @cookbooks_path            = UNSET_VALUE
+          @data_bags_path            = UNSET_VALUE
+          @recipe_url                = UNSET_VALUE
+          @roles_path                = UNSET_VALUE
+          @encrypted_data_bag_secret = UNSET_VALUE
+          @encrypted_data_bag_secret_key_path = UNSET_VALUE
+          @nfs                       = UNSET_VALUE
+        end
+
+        def finalize!
+          if @cookbooks_path == UNSET_VALUE
+            @cookbooks_path = [[:host, "cookbooks"], [:vm, "cookbooks"]]
+          end
+
+          @data_bags_path = [] if @data_bags_path == UNSET_VALUE
+          @roles_path     = [] if @roles_path == UNSET_VALUE
+
+          # Make sure the path is an array.
+          @cookbooks_path = prepare_folders_config(@cookbooks_path)
+          @data_bags_path = prepare_folders_config(@data_bags_path)
+          @roles_path     = prepare_folders_config(@roles_path)
+
+          @encrypted_data_bag_secret = "/tmp/encrypted_data_bag_secret" if \
+            @encrypted_data_bag_secret == UNSET_VALUE
+          @encrypted_data_bag_secret_key_path = nil if \
+            @encrypted_data_bag_secret_key_path == UNSET_VALUE
+          @nfs = false if @nfs == UNSET_VALUE
+          @recipe_url = nil if @recipe_url == UNSET_VALUE
+        end
+
+        def validate(machine)
+          errors = []
+          errors << I18n.t("vagrant.config.chef.cookbooks_path_empty") if \
+            !cookbooks_path || [cookbooks_path].flatten.empty?
+          errors << I18n.t("vagrant.config.chef.run_list_empty") if \
+            !run_list || run_list.empty?
+
+          @cookbooks_path.each do |type, path|
+            next if type != :host
+            expanded_path = File.expand_path(path, machine.env.root_path)
+
+            if !File.exist?(expanded_path)
+              errors << I18n.t("vagrant.config.chef.cookbooks_path_missing",
+                              :path => expanded_path)
+            end
+          end
+
+          { "chef solo provisioner" => errors }
+        end
+
+        protected
+
+        # This takes any of the configurations that take a path or
+        # array of paths and turns it into the proper format.
+        #
+        # @return [Array]
+        def prepare_folders_config(config)
+          # Make sure the path is an array
+          config = [config] if !config.is_a?(Array) || config.first.is_a?(Symbol)
+
+          # Make sure all the paths are in the proper format
+          config.map do |path|
+            path = [:host, path] if !path.is_a?(Array)
+            path
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/vagrant/plugins/provisioners/chef/plugin.rb

@@ -0,0 +1,33 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Chef
+    class Plugin < Vagrant.plugin("2")
+      name "chef"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      Chef via `chef-solo` or `chef-client`.
+      DESC
+
+      config(:chef_solo, :provisioner) do
+        require File.expand_path("../config/chef_solo", __FILE__)
+        Config::ChefSolo
+      end
+
+      config(:chef_client, :provisioner) do
+        require File.expand_path("../config/chef_client", __FILE__)
+        Config::ChefClient
+      end
+
+      provisioner(:chef_solo)   do
+        require File.expand_path("../provisioner/chef_solo", __FILE__)
+        Provisioner::ChefSolo
+      end
+
+      provisioner(:chef_client) do
+        require File.expand_path("../provisioner/chef_client", __FILE__)
+        Provisioner::ChefClient
+      end
+    end
+  end
+end