vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/chef/plugin.rb

@@ -1,107 +0,0 @@
-require "pathname"
-
-require "vagrant"
-
-require_relative "command_builder"
-
-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`, `chef-client`, `chef-zero` or `chef-apply`.
-      DESC
-
-      config(:chef_apply, :provisioner) do
-        require_relative "config/chef_apply"
-        Config::ChefApply
-      end
-
-      config(:chef_client, :provisioner) do
-        require_relative "config/chef_client"
-        Config::ChefClient
-      end
-
-      config(:chef_solo, :provisioner) do
-        require_relative "config/chef_solo"
-        Config::ChefSolo
-      end
-
-      config(:chef_zero, :provisioner) do
-        require_relative "config/chef_zero"
-        Config::ChefZero
-      end
-
-      provisioner(:chef_apply) do
-        require_relative "provisioner/chef_apply"
-        Provisioner::ChefApply
-      end
-
-      provisioner(:chef_client) do
-        require_relative "provisioner/chef_client"
-        Provisioner::ChefClient
-      end
-
-      provisioner(:chef_solo)   do
-        require_relative "provisioner/chef_solo"
-        Provisioner::ChefSolo
-      end
-
-      provisioner(:chef_zero)   do
-        require_relative "provisioner/chef_zero"
-        Provisioner::ChefZero
-      end
-
-      guest_capability(:debian, :chef_install) do
-        require_relative "cap/debian/chef_install"
-        Cap::Debian::ChefInstall
-      end
-
-      guest_capability(:freebsd, :chef_install) do
-        require_relative "cap/freebsd/chef_install"
-        Cap::FreeBSD::ChefInstall
-      end
-
-      guest_capability(:freebsd, :chef_installed) do
-        require_relative "cap/freebsd/chef_installed"
-        Cap::FreeBSD::ChefInstalled
-      end
-
-      guest_capability(:linux, :chef_installed) do
-        require_relative "cap/linux/chef_installed"
-        Cap::Linux::ChefInstalled
-      end
-
-      guest_capability(:omnios, :chef_install) do
-        require_relative "cap/omnios/chef_install"
-        Cap::OmniOS::ChefInstall
-      end
-
-      guest_capability(:omnios, :chef_installed) do
-        require_relative "cap/omnios/chef_installed"
-        Cap::OmniOS::ChefInstalled
-      end
-
-      guest_capability(:redhat, :chef_install) do
-        require_relative "cap/redhat/chef_install"
-        Cap::Redhat::ChefInstall
-      end
-
-      guest_capability(:suse, :chef_install) do
-        require_relative "cap/suse/chef_install"
-        Cap::Suse::ChefInstall
-      end
-
-      guest_capability(:windows, :chef_install) do
-        require_relative "cap/windows/chef_install"
-        Cap::Windows::ChefInstall
-      end
-
-      guest_capability(:windows, :chef_installed) do
-        require_relative "cap/windows/chef_installed"
-        Cap::Windows::ChefInstalled
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/chef/provisioner/base.rb

@@ -1,255 +0,0 @@
-require "tempfile"
-
-require_relative "../../../../lib/vagrant/util/presence"
-require_relative "../../../../lib/vagrant/util/template_renderer"
-
-require_relative "../installer"
-
-module VagrantPlugins
-  module Chef
-    module Provisioner
-      # This class is a base class where the common functionality shared between
-      # chef-solo and chef-client provisioning are stored. This is **not an actual
-      # provisioner**. Instead, {ChefSolo} or {ChefServer} should be used.
-      class Base < Vagrant.plugin("2", :provisioner)
-        include Vagrant::Util
-        include Vagrant::Util::Presence
-
-        class ChefError < Vagrant::Errors::VagrantError
-          error_namespace("vagrant.provisioners.chef")
-        end
-
-        def initialize(machine, config)
-          super
-
-          @logger = Log4r::Logger.new("vagrant::provisioners::chef")
-
-          if @config.respond_to?(:node_name) && !present?(@config.node_name)
-            # First attempt to get the node name from the hostname, and if that
-            # is not present, generate/retrieve a random hostname.
-            hostname = @machine.config.vm.hostname
-            if present?(hostname)
-              @machine.ui.info I18n.t("vagrant.provisioners.chef.using_hostname_node_name",
-                hostname: hostname,
-              )
-              @config.node_name = hostname
-            else
-              cache = @machine.data_dir.join("chef_node_name")
-              if !cache.exist?
-                @machine.ui.info I18n.t("vagrant.provisioners.chef.generating_node_name")
-                cache.open("w+") do |f|
-                  f.write("vagrant-#{SecureRandom.hex(4)}")
-                end
-              end
-
-              if cache.file?
-                @logger.info("Loading cached node_name...")
-                @config.node_name = cache.read.strip
-              end
-            end
-          end
-        end
-
-        def install_chef
-          return if !config.install
-
-          @logger.info("Checking for Chef installation...")
-          installer = Installer.new(@machine,
-            product: config.product,
-            channel: config.channel,
-            version: config.version,
-            omnibus_url: config.omnibus_url,
-            force: config.install == :force,
-            download_path:  config.installer_download_path
-          )
-          installer.ensure_installed
-        end
-
-        def verify_binary(binary)
-          # Checks for the existence of chef binary and error if it
-          # doesn't exist.
-          if windows?
-            command = "if ((&'#{binary}' -v) -Match 'Chef: *'){ exit 0 } else { exit 1 }"
-          else
-            command = "sh -c 'command -v #{binary}'"
-          end
-
-          @machine.communicate.sudo(
-            command,
-            error_class: ChefError,
-            error_key: :chef_not_detected,
-            binary: binary,
-          )
-        end
-
-        # Returns the path to the Chef binary, taking into account the
-        # `binary_path` configuration option.
-        def chef_binary_path(binary)
-          return binary if !@config.binary_path
-          return File.join(@config.binary_path, binary)
-        end
-
-        def chown_provisioning_folder
-          paths = [
-            guest_provisioning_path,
-            guest_file_backup_path,
-            guest_file_cache_path,
-          ]
-
-          @machine.communicate.tap do |comm|
-            paths.each do |path|
-              if windows?
-                comm.sudo("mkdir ""#{path}"" -f")
-              else
-                comm.sudo("mkdir -p #{path}")
-                comm.sudo("chown -h #{@machine.ssh_info[:username]} #{path}")
-              end
-            end
-          end
-        end
-
-        def setup_config(template, filename, template_vars)
-          # If we have custom configuration, upload it
-          remote_custom_config_path = nil
-          if @config.custom_config_path
-            expanded = File.expand_path(
-              @config.custom_config_path, @machine.env.root_path)
-            remote_custom_config_path = File.join(
-              guest_provisioning_path, "custom-config.rb")
-
-            @machine.communicate.upload(expanded, remote_custom_config_path)
-          end
-
-          config_file = TemplateRenderer.render(template, {
-            custom_configuration: remote_custom_config_path,
-            encrypted_data_bag_secret: guest_encrypted_data_bag_secret_key_path,
-            environment:      @config.environment,
-            file_cache_path:  guest_file_cache_path,
-            file_backup_path: guest_file_backup_path,
-            log_level:        @config.log_level.to_sym,
-            node_name:        @config.node_name,
-            verbose_logging:  @config.verbose_logging,
-            enable_reporting: @config.enable_reporting,
-            http_proxy:       @config.http_proxy,
-            http_proxy_user:  @config.http_proxy_user,
-            http_proxy_pass:  @config.http_proxy_pass,
-            https_proxy:      @config.https_proxy,
-            https_proxy_user: @config.https_proxy_user,
-            https_proxy_pass: @config.https_proxy_pass,
-            no_proxy:         @config.no_proxy,
-            formatter:        @config.formatter
-          }.merge(template_vars))
-
-          # Create a temporary file to store the data so we can upload it.
-          remote_file = File.join(guest_provisioning_path, filename)
-          @machine.communicate.sudo(remove_command(remote_file), error_check: false)
-          Tempfile.open("vagrant-chef-provisioner-config") do |f|
-            f.binmode
-            f.write(config_file)
-            f.fsync
-            f.close
-            @machine.communicate.upload(f.path, remote_file)
-          end
-        end
-
-        def setup_json
-          @machine.ui.info I18n.t("vagrant.provisioners.chef.json")
-
-          # Get the JSON that we're going to expose to Chef
-          json = @config.json
-          json[:run_list] = @config.run_list if @config.run_list &&
-            !@config.run_list.empty?
-          json = JSON.pretty_generate(json)
-
-          # Create a temporary file to store the data so we can upload it.
-          remote_file = File.join(guest_provisioning_path, "dna.json")
-          @machine.communicate.sudo(remove_command(remote_file), error_check: false)
-          Tempfile.open("vagrant-chef-provisioner-config") do |f|
-            f.binmode
-            f.write(json)
-            f.fsync
-            f.close
-            @machine.communicate.upload(f.path, remote_file)
-          end
-        end
-
-        def upload_encrypted_data_bag_secret
-          remote_file = guest_encrypted_data_bag_secret_key_path
-          return if !remote_file
-
-          @machine.ui.info I18n.t(
-            "vagrant.provisioners.chef.upload_encrypted_data_bag_secret_key")
-
-          @machine.communicate.sudo(remove_command(remote_file), error_check: false)
-          @machine.communicate.upload(encrypted_data_bag_secret_key_path, remote_file)
-        end
-
-        def delete_encrypted_data_bag_secret
-          remote_file = guest_encrypted_data_bag_secret_key_path
-          return if remote_file.nil?
-
-          @machine.communicate.sudo(remove_command(remote_file), error_check: false)
-        end
-
-        def encrypted_data_bag_secret_key_path
-          File.expand_path(@config.encrypted_data_bag_secret_key_path,
-            @machine.env.root_path)
-        end
-
-        def guest_encrypted_data_bag_secret_key_path
-          if @config.encrypted_data_bag_secret_key_path
-            File.join(guest_provisioning_path, "encrypted_data_bag_secret_key")
-          end
-        end
-
-        def guest_provisioning_path
-          if !@config.provisioning_path.nil?
-            return @config.provisioning_path
-          end
-
-          if windows?
-            "C:/vagrant-chef"
-          else
-            "/tmp/vagrant-chef"
-          end
-        end
-
-        def guest_file_backup_path
-          if !@config.file_backup_path.nil?
-            return @config.file_backup_path
-          end
-
-          if windows?
-            "C:/chef/backup"
-          else
-            "/var/chef/backup"
-          end
-        end
-
-        def guest_file_cache_path
-          if !@config.file_cache_path.nil?
-            return @config.file_cache_path
-          end
-
-          if windows?
-            "C:/chef/cache"
-          else
-            "/var/chef/cache"
-          end
-        end
-
-        def remove_command(path)
-          if windows?
-            "if (test-path ""#{path}"") {rm ""#{path}"" -force -recurse}"
-          else
-            "rm -f #{path}"
-          end
-        end
-
-        def windows?
-          @machine.config.vm.communicator == :winrm
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/chef/provisioner/chef_apply.rb

@@ -1,71 +0,0 @@
-require "digest/md5"
-require "tempfile"
-
-require_relative "base"
-
-module VagrantPlugins
-  module Chef
-    module Provisioner
-      class ChefApply < Base
-        def provision
-          install_chef
-          verify_binary(chef_binary_path("chef-apply"))
-
-          command = "chef-apply"
-          command << " \"#{target_recipe_path}\""
-          command << " --log_level #{config.log_level}"
-
-          user = @machine.ssh_info[:username]
-
-          # Reset upload path permissions for the current ssh user
-          if windows?
-            @machine.communicate.sudo("mkdir ""#{config.upload_path}"" -f")
-          else
-            @machine.communicate.sudo("mkdir -p #{config.upload_path}")
-            @machine.communicate.sudo("chown -R #{user} #{config.upload_path}")
-          end
-
-          # Upload the recipe
-          upload_recipe
-
-          @machine.ui.info(I18n.t("vagrant.provisioners.chef.running_apply",
-            script: config.path)
-          )
-
-          # Execute it with sudo
-          @machine.communicate.sudo(command) do |type, data|
-            if [:stderr, :stdout].include?(type)
-              # Output the data with the proper color based on the stream.
-              color = (type == :stdout) ? :green : :red
-
-              # Chomp the data to avoid the newlines that the Chef outputs
-              @machine.env.ui.info(data.chomp, color: color, prefix: false)
-            end
-          end
-        end
-
-        # The destination (on the guest) where the recipe will live
-        # @return [String]
-        def target_recipe_path
-          key = Digest::MD5.hexdigest(config.recipe)
-          File.join(config.upload_path, "recipe-#{key}.rb")
-        end
-
-        # Write the raw recipe contents to a tempfile and upload that to the
-        # machine.
-        def upload_recipe
-          # Write the raw recipe contents to a tempfile and upload
-          Tempfile.open(["vagrant-chef-apply", ".rb"]) do |f|
-            f.binmode
-            f.write(config.recipe)
-            f.fsync
-            f.close
-
-            # Upload the tempfile to the guest
-            @machine.communicate.upload(f.path, target_recipe_path)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/chef/provisioner/chef_client.rb

@@ -1,176 +0,0 @@
-require 'pathname'
-
-require 'vagrant'
-require 'vagrant/util/presence'
-require 'vagrant/util/subprocess'
-
-require_relative "base"
-
-module VagrantPlugins
-  module Chef
-    module Provisioner
-      # This class implements provisioning via chef-client, allowing provisioning
-      # with a chef server.
-      class ChefClient < Base
-        include Vagrant::Util::Presence
-
-        def configure(root_config)
-          raise ChefError, :server_validation_key_required if @config.validation_key_path.nil?
-          raise ChefError, :server_validation_key_doesnt_exist if !File.file?(validation_key_path)
-          raise ChefError, :server_url_required if @config.chef_server_url.nil?
-        end
-
-        def provision
-          install_chef
-          verify_binary(chef_binary_path("chef-client"))
-          chown_provisioning_folder
-          create_client_key_folder
-          upload_validation_key
-          upload_encrypted_data_bag_secret
-          setup_json
-          setup_server_config
-          run_chef_client
-          delete_encrypted_data_bag_secret
-        end
-
-        def cleanup
-          if @config.delete_node
-            delete_from_chef_server("node")
-          end
-
-          if @config.delete_client
-            delete_from_chef_server("client")
-          end
-        end
-
-        def create_client_key_folder
-          @machine.ui.info I18n.t("vagrant.provisioners.chef.client_key_folder")
-          path = Pathname.new(guest_client_key_path)
-
-          if windows?
-            @machine.communicate.sudo("mkdir ""#{path.dirname}"" -f")
-          else
-            @machine.communicate.sudo("mkdir -p #{path.dirname}")
-          end
-        end
-
-        def upload_validation_key
-          @machine.ui.info I18n.t("vagrant.provisioners.chef.upload_validation_key")
-          @machine.communicate.upload(validation_key_path, guest_validation_key_path)
-        end
-
-        def setup_server_config
-          setup_config("provisioners/chef_client/client", "client.rb", {
-            chef_server_url: @config.chef_server_url,
-            validation_client_name: @config.validation_client_name,
-            validation_key: guest_validation_key_path,
-            client_key: guest_client_key_path,
-          })
-        end
-
-        def run_chef_client
-          if @config.run_list && @config.run_list.empty?
-            @machine.ui.warn(I18n.t("vagrant.chef_run_list_empty"))
-          end
-
-          command = CommandBuilder.command(:client, @config,
-            windows: windows?,
-            colored: @machine.env.ui.color?,
-          )
-          
-          still_active = 259 #provisioner has asked chef to reboot 
-          
-          @config.attempts.times do |attempt|
-            exit_status = 0
-            while exit_status == 0 || exit_status == still_active 
-              if @machine.guest.capability?(:wait_for_reboot)
-                @machine.guest.capability(:wait_for_reboot)
-              elsif attempt > 0
-                sleep 10
-                @machine.communicate.wait_for_ready(@machine.config.vm.boot_timeout)
-              end
-              if attempt == 0
-                @machine.ui.info I18n.t("vagrant.provisioners.chef.running_client")
-              else
-                @machine.ui.info I18n.t("vagrant.provisioners.chef.running_client_again")
-              end
-
-              opts = { error_check: false, elevated: true }
-              exit_status = @machine.communicate.sudo(command, opts) do |type, data|
-                # Output the data with the proper color based on the stream.
-                color = type == :stdout ? :green : :red
-
-                data = data.chomp
-                next if data.empty?
-
-                @machine.ui.info(data, color: color)
-              end
-
-              # There is no need to run Chef again if it converges
-              return if exit_status == 0
-            end
-          end
-
-          # If we reached this point then Chef never converged! Error.
-          raise ChefError, :no_convergence
-        end
-
-        def validation_key_path
-          File.expand_path(@config.validation_key_path, @machine.env.root_path)
-        end
-
-        def guest_client_key_path
-          if !@config.client_key_path.nil?
-            return @config.client_key_path
-          end
-
-          if windows?
-            "C:/chef/client.pem"
-          else
-            "/etc/chef/client.pem"
-          end
-        end
-
-        def guest_client_rb_path
-          File.join(guest_provisioning_path, "client.rb")
-        end
-
-        def guest_validation_key_path
-          File.join(guest_provisioning_path, "validation.pem")
-        end
-
-        def delete_from_chef_server(deletable)
-          node_name = @config.node_name
-
-          if !present?(node_name)
-            @machine.ui.warn(I18n.t("vagrant.provisioners.chef.missing_node_name",
-              deletable: deletable,
-            ))
-            return
-          end
-
-          @machine.ui.info(I18n.t("vagrant.provisioners.chef.deleting_from_server",
-            deletable: deletable, name: node_name))
-
-          command =  "knife #{deletable} delete #{node_name}"
-          command << " --config '#{guest_client_rb_path}'"
-          command << " --yes"
-
-          output = []
-          result = @machine.communicate.sudo(command, error_check: false) do |_, data|
-            output << data
-          end
-
-          if result != 0
-            @machine.ui.error("There were errors removing the #{deletable} from the Chef Server:")
-            @machine.ui.error("")
-            @machine.ui.error(output.join("\n"))
-            @machine.ui.error("")
-            @machine.ui.error("Vagrant will continue destroying the virtual machine, but you may need")
-            @machine.ui.error("to manually delete the #{deletable} from the Chef Server!")
-          end
-        end
-      end
-    end
-  end
-end