vagrant-lxc 0.0.1 → 0.0.2

data/vendor/vagrant/lib/vagrant/util/stacked_proc_runner.rb

@@ -1,35 +0,0 @@
-module Vagrant
-  module Util
-    # Represents the "stacked proc runner" behavior which is used a
-    # couple places within Vagrant. This allows procs to "stack" on
-    # each other, then all execute in a single action. An example of
-    # its uses can be seen in the {Config} class.
-    module StackedProcRunner
-      # Returns the proc stack. This should always be called as the
-      # accessor of the stack. The instance variable itself should _never_
-      # be used.
-      #
-      # @return [Array<Proc>]
-      def proc_stack
-        @_proc_stack ||= []
-      end
-
-      # Adds (pushes) a proc to the stack. The actual proc added here is
-      # not executed, but merely stored.
-      #
-      # @param [Proc] block
-      def push_proc(&block)
-        proc_stack << block
-      end
-
-      # Executes all the procs on the stack, passing in the given arguments.
-      # The stack is not cleared afterwords. It is up to the user of this
-      # mixin to clear the stack by calling `proc_stack.clear`.
-      def run_procs!(*args)
-        proc_stack.each do |proc|
-          proc.call(*args)
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/util/string_block_editor.rb

@@ -1,75 +0,0 @@
-module Vagrant
-  module Util
-    # This class modifies strings by creating and managing Vagrant-owned
-    # "blocks" via wrapping them in specially formed comments.
-    #
-    # This is useful when modifying a file that someone else owns and adding
-    # automatic entries into it. Example: /etc/exports or some other
-    # configuration file.
-    #
-    # Vagrant marks ownership of a block in the string by wrapping it in
-    # VAGRANT-BEGIN and VAGRANT-END comments with a unique ID. Example:
-    #
-    #     foo
-    #     # VAGRANT-BEGIN: id
-    #     some contents
-    #     created by vagrant
-    #     # VAGRANT-END: id
-    #
-    # The goal of this class is to be able to insert and remove these
-    # blocks without modifying anything else in the string.
-    #
-    # The strings usually come from files but it is up to the caller to
-    # manage the file resource.
-    class StringBlockEditor
-      # The current string value. This is the value that is modified by
-      # the methods below.
-      #
-      # @return [String]
-      attr_reader :value
-
-      def initialize(string)
-        @value = string
-      end
-
-      # This returns the keys (or ids) that are in the string.
-      #
-      # @return [<Array<String>]
-      def keys
-        regexp = /^#\s*VAGRANT-BEGIN:\s*(.+?)$\r?\n?(.*)$\r?\n?^#\s*VAGRANT-END:\s(\1)$/m
-        @value.scan(regexp).map do |match|
-          match[0]
-        end
-      end
-
-      # This deletes the block with the given key if it exists.
-      def delete(key)
-        regexp = /^#\s*VAGRANT-BEGIN:\s*#{key}$.*^#\s*VAGRANT-END:\s*#{key}$\r?\n?/m
-        @value.gsub!(regexp, "")
-      end
-
-      # This gets the value of the block with the given key.
-      def get(key)
-        regexp = /^#\s*VAGRANT-BEGIN:\s*#{key}$\r?\n?(.*?)\r?\n?^#\s*VAGRANT-END:\s*#{key}$\r?\n?/m
-        match  = regexp.match(@value)
-        return nil if !match
-        match[1]
-      end
-
-      # This inserts a block with the given key and value.
-      #
-      # @param [String] key
-      # @param [String] value
-      def insert(key, value)
-        # Insert the new block into the value
-        new_block = <<BLOCK
-# VAGRANT-BEGIN: #{key}
-#{value.strip}
-# VAGRANT-END: #{key}
-BLOCK
-
-        @value << new_block
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/util/subprocess.rb

@@ -1,270 +0,0 @@
-require 'childprocess'
-require 'log4r'
-
-require 'vagrant/util/platform'
-
-module Vagrant
-  module Util
-    # Execute a command in a subprocess, gathering the results and
-    # exit status.
-    #
-    # This class also allows you to read the data as it is outputted
-    # from the subprocess in real time, by simply passing a block to
-    # the execute method.
-    class Subprocess
-      # The chunk size for reading from subprocess IO.
-      READ_CHUNK_SIZE = 4096
-
-      # Convenience method for executing a method.
-      def self.execute(*command, &block)
-        new(*command).execute(&block)
-      end
-
-      def initialize(*command)
-        @options = command.last.is_a?(Hash) ? command.pop : {}
-        @command = command
-        @logger  = Log4r::Logger.new("vagrant::util::subprocess")
-      end
-
-      def execute
-        # Get the timeout, if we have one
-        timeout = @options[:timeout]
-
-        # Get the working directory
-        workdir = @options[:workdir] || Dir.pwd
-
-        # Get what we're interested in being notified about
-        notify  = @options[:notify] || []
-        notify  = [notify] if !notify.is_a?(Array)
-        if notify.empty? && block_given?
-          # If a block is given, subscribers must be given, otherwise the
-          # block is never called. This is usually NOT what you want, so this
-          # is an error.
-          message = "A list of notify subscriptions must be given if a block is given"
-          raise ArgumentError, message
-        end
-
-        # Let's get some more useful booleans that we access a lot so
-        # we're not constantly calling an `include` check
-        notify_table = {}
-        notify_table[:stderr] = notify.include?(:stderr)
-        notify_table[:stdout] = notify.include?(:stdout)
-        notify_stdin  = notify.include?(:stdin)
-
-        # Build the ChildProcess
-        @logger.info("Starting process: #{@command.inspect}")
-        process = ChildProcess.build(*@command)
-
-        # Create the pipes so we can read the output in real time as
-        # we execute the command.
-        stdout, stdout_writer = IO.pipe
-        stderr, stderr_writer = IO.pipe
-        process.io.stdout = stdout_writer
-        process.io.stderr = stderr_writer
-        process.duplex = true
-
-        # Set the environment on the process if we must
-        if @options[:env]
-          @options[:env].each do |k, v|
-            process.environment[k] = v
-          end
-        end
-
-        # Start the process
-        begin
-          Dir.chdir(workdir) do
-            process.start
-          end
-        rescue ChildProcess::LaunchError => ex
-          # Raise our own version of the error so that users of the class
-          # don't need to be aware of ChildProcess
-          raise LaunchError.new(ex.message)
-        end
-
-        # Make sure the stdin does not buffer
-        process.io.stdin.sync = true
-
-        if RUBY_PLATFORM != "java"
-          # On Java, we have to close after. See down the method...
-          # Otherwise, we close the writers right here, since we're
-          # not on the writing side.
-          stdout_writer.close
-          stderr_writer.close
-        end
-
-        # Create a dictionary to store all the output we see.
-        io_data = { :stdout => "", :stderr => "" }
-
-        # Record the start time for timeout purposes
-        start_time = Time.now.to_i
-
-        @logger.debug("Selecting on IO")
-        while true
-          writers = notify_stdin ? [process.io.stdin] : []
-          results = IO.select([stdout, stderr], writers, nil, timeout || 0.1)
-          results ||= []
-          readers = results[0]
-          writers = results[1]
-
-          # Check if we have exceeded our timeout
-          raise TimeoutExceeded, process.pid if timeout && (Time.now.to_i - start_time) > timeout
-
-          # Check the readers to see if they're ready
-          if readers && !readers.empty?
-            readers.each do |r|
-              # Read from the IO object
-              data = read_io(r)
-
-              # We don't need to do anything if the data is empty
-              next if data.empty?
-
-              io_name = r == stdout ? :stdout : :stderr
-              @logger.debug("#{io_name}: #{data.chomp}")
-
-              io_data[io_name] += data
-              yield io_name, data if block_given? && notify_table[io_name]
-            end
-          end
-
-          # Break out if the process exited. We have to do this before
-          # attempting to write to stdin otherwise we'll get a broken pipe
-          # error.
-          break if process.exited?
-
-          # Check the writers to see if they're ready, and notify any listeners
-          if writers && !writers.empty?
-            yield :stdin, process.io.stdin if block_given?
-          end
-        end
-
-        # Wait for the process to end.
-        begin
-          remaining = (timeout || 32000) - (Time.now.to_i - start_time)
-          remaining = 0 if remaining < 0
-          @logger.debug("Waiting for process to exit. Remaining to timeout: #{remaining}")
-
-          process.poll_for_exit(remaining)
-        rescue ChildProcess::TimeoutError
-          raise TimeoutExceeded, process.pid
-        end
-
-        @logger.debug("Exit status: #{process.exit_code}")
-
-        # Read the final output data, since it is possible we missed a small
-        # amount of text between the time we last read data and when the
-        # process exited.
-        [stdout, stderr].each do |io|
-          # Read the extra data, ignoring if there isn't any
-          extra_data = read_io(io)
-          next if extra_data == ""
-
-          # Log it out and accumulate
-          io_name = io == stdout ? :stdout : :stderr
-          io_data[io_name] += extra_data
-          @logger.debug("#{io_name}: #{extra_data.chomp}")
-
-          # Yield to any listeners any remaining data
-          yield io_name, extra_data if block_given?
-        end
-
-        if RUBY_PLATFORM == "java"
-          # On JRuby, we need to close the writers after the process,
-          # for some reason. See GH-711.
-          stdout_writer.close
-          stderr_writer.close
-        end
-
-        # Return an exit status container
-        return Result.new(process.exit_code, io_data[:stdout], io_data[:stderr])
-      end
-
-      protected
-
-      # Reads data from an IO object while it can, returning the data it reads.
-      # When it encounters a case when it can't read anymore, it returns the
-      # data.
-      #
-      # @return [String]
-      def read_io(io)
-        data = ""
-
-        while true
-          begin
-            if Platform.windows?
-              # Windows doesn't support non-blocking reads on
-              # file descriptors or pipes so we have to get
-              # a bit more creative.
-
-              # Check if data is actually ready on this IO device.
-              # We have to do this since `readpartial` will actually block
-              # until data is available, which can cause blocking forever
-              # in some cases.
-              results = IO.select([io], nil, nil, 0.1)
-              break if !results || results[0].empty?
-
-              # Read!
-              data << io.readpartial(READ_CHUNK_SIZE)
-            else
-              # Do a simple non-blocking read on the IO object
-              data << io.read_nonblock(READ_CHUNK_SIZE)
-            end
-          rescue Exception => e
-            # The catch-all rescue here is to support multiple Ruby versions,
-            # since we use some Ruby 1.9 specific exceptions.
-
-            breakable = false
-            if e.is_a?(EOFError)
-              # An `EOFError` means this IO object is done!
-              breakable = true
-            elsif defined?(IO::WaitReadable) && e.is_a?(IO::WaitReadable)
-              # IO::WaitReadable is only available on Ruby 1.9+
-
-              # An IO::WaitReadable means there may be more IO but this
-              # IO object is not ready to be read from yet. No problem,
-              # we read as much as we can, so we break.
-              breakable = true
-            elsif e.is_a?(Errno::EAGAIN)
-              # Otherwise, we just look for the EAGAIN error which should be
-              # all that IO::WaitReadable does in Ruby 1.9.
-              breakable = true
-            end
-
-            # Break out if we're supposed to. Otherwise re-raise the error
-            # because it is a real problem.
-            break if breakable
-            raise
-          end
-        end
-
-        data
-      end
-
-      # An error which raises when a process fails to start
-      class LaunchError < StandardError; end
-
-      # An error which occurs when the process doesn't end within
-      # the given timeout.
-      class TimeoutExceeded < StandardError
-        attr_reader :pid
-
-        def initialize(pid)
-          super()
-          @pid = pid
-        end
-      end
-
-      # Container class to store the results of executing a subprocess.
-      class Result
-        attr_reader :exit_code
-        attr_reader :stdout
-        attr_reader :stderr
-
-        def initialize(exit_code, stdout, stderr)
-          @exit_code = exit_code
-          @stdout    = stdout
-          @stderr    = stderr
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/util/template_renderer.rb

@@ -1,83 +0,0 @@
-require 'ostruct'
-require 'erubis'
-
-module Vagrant
-  module Util
-    # This class is used to render the ERB templates in the
-    # `GEM_ROOT/templates` directory.
-    class TemplateRenderer < OpenStruct
-      class << self
-        # Render a given template and return the result. This method optionally
-        # takes a block which will be passed the renderer prior to rendering, which
-        # allows the caller to set any view variables within the renderer itself.
-        #
-        # @return [String] Rendered template
-        def render(*args)
-          render_with(:render, *args)
-        end
-
-        # Render a given string and return the result. This method optionally
-        # takes a block which will be passed the renderer prior to rendering, which
-        # allows the caller to set any view variables within the renderer itself.
-        #
-        # @param [String] template The template data string.
-        # @return [String] Rendered template
-        def render_string(*args)
-          render_with(:render_string, *args)
-        end
-
-        # Method used internally to DRY out the other renderers. This method
-        # creates and sets up the renderer before calling a specified method on it.
-        def render_with(method, template, data={})
-          renderer = new(template, data)
-          yield renderer if block_given?
-          renderer.send(method.to_sym)
-        end
-      end
-
-      def initialize(template, data = {})
-        super()
-
-        data[:template] = template
-        data.each do |key, value|
-          send("#{key}=", value)
-        end
-      end
-
-      # Renders the template using the class intance as the binding. Because the
-      # renderer inherits from `OpenStruct`, additional view variables can be
-      # added like normal accessors.
-      #
-      # @return [String]
-      def render
-        # TODO: Seems like a pretty dirty way to do this. Perhaps refactor this
-        old_template = template
-        result = nil
-        File.open(full_template_path, 'r') do |f|
-          self.template = f.read
-          result = render_string
-        end
-
-        result
-      ensure
-        self.template = old_template
-      end
-
-      # Renders a template, handling the template as a string, but otherwise
-      # acting the same way as {#render}.
-      #
-      # @return [String]
-      def render_string
-        Erubis::Eruby.new(template, :trim => true).result(binding)
-      end
-
-      # Returns the full path to the template, taking into accoun the gem directory
-      # and adding the `.erb` extension to the end.
-      #
-      # @return [String]
-      def full_template_path
-        Vagrant.source_root.join('templates', "#{template}.erb").to_s.squeeze("/")
-      end
-    end
-  end
-end