vagrant-unbundled 2.2.19.0 → 2.3.2.0

data/plugins/commands/serve/mappers/internal/graph/mappers.rb

@@ -0,0 +1,332 @@
+module VagrantPlugins
+  module CommandServe
+    class Mappers
+      module Internal
+        class Graph
+          # Represent given mappers and inputs as
+          # graph.
+          class Mappers
+            include Util::HasLogger
+            # Weight given to root vertex
+            ROOT_WEIGHT = 0
+            # Weight given to source vertex or initial value
+            SOURCE_WEIGHT = 0
+            # Weight given to the destination vertex
+            FINAL_WEIGHT = 0
+            # Weight given to output types matching final
+            DST_WEIGHT = 0
+            # Weight given to named input value vertices
+            NAMED_VALUE_WEIGHT = 0
+            # Weight given to input value vertices
+            VALUE_WEIGHT = 10
+            # Weight given to input vertices
+            INPUT_WEIGHT = 20
+            # Weight given to output vertices
+            OUTPUT_WEIGHT = 20
+
+            # @return [Graph] graph instance representing mappers
+            attr_reader :graph
+            # @return [Object] source input value
+            attr_reader :source
+            # @return [Array<Object>] input values
+            attr_reader :inputs
+            # @return [String] named input to prefer
+            attr_reader :named
+            # @return [Mappers] mappers instance executing against
+            attr_reader :mappers
+            # @return [Class] expected return type
+            attr_reader :final
+            # @return [Boolean] graph is fresh (not using cached vertex list)
+            attr_reader :fresh
+            # @return [Array<Proc>] list of callables used for Method vertices
+            attr_reader :callables
+
+            @previous = {}
+
+            class << self
+              # Register a valid path for a given source
+              # and destination
+              #
+              # @param src [Class] source type
+              # @param dst [Class] destination type
+              # @param path [Array<Vertex>]
+              def register(src, dst, path)
+                begin
+                  @previous[generate_key(src, dst)] = path
+                rescue KeyError
+                  nil
+                end
+              end
+
+              # Remove an existing path registration
+              #
+              # @param src [Class] source type
+              # @param dst [Class] destination type
+              # @return [NilClass]
+              def unregister(src, dst)
+                @previous.delete(generate_key(src, dst))
+                nil
+              end
+
+              # Fetch a path for a given source and destination
+              # if it has been registered
+              #
+              # @param src [Class] source type
+              # @param dst [Class] destination type
+              # @return [Array<Vertex>, NilClass]
+              def previous(src, dst)
+                begin
+                  @previous[generate_key(src, dst)]
+                rescue KeyError
+                  nil
+                end
+              end
+
+              # Generate lookup key for given source
+              # and destination
+              #
+              # @param src [Class] source
+              # @param dst [Class] destination
+              # @return [String]
+              def generate_key(src, dst)
+                "#{src} -> #{dst}"
+              end
+            end
+
+            # Wrap a mappers instance into a graph with input values
+            # and determine and execute required path for desired output
+            #
+            # @param output_type [Class] Expected return type
+            # @param input_values [Array<Object>] Values provided for execution
+            # @param mappers [Mappers] Mappers instance to use
+            # @param named [String] Named input to prefer
+            # @param source [Object] Source value for conversion (optional)
+            def initialize(output_type:, input_values:, mappers:, named: nil, source: nil)
+              if !output_type.nil? && !output_type.is_a?(Class) && !output_type.is_a?(Module)
+                raise TypeError,
+                  "Expected output type to be `Class', got `#{output_type.class}' (#{output_type})"
+              end
+              @final = output_type
+              @source = source
+              @inputs = Array(input_values)
+              if !mappers.is_a?(CommandServe::Mappers)
+                raise TypeError,
+                  "Expected mapper to be `Mappers', got `#{mappers.class}'"
+              end
+              @mappers = mappers
+              @callables = mappers.mappers
+              @named = named.to_s
+              @fresh = true
+
+              # If we have a valid source type (and are not generating a value) check
+              # if a path has already been registered for this source/destination
+              # pair. If it has, we can fetch the callables out of the registered
+              # path and build our graph only using that subset of callables
+              if source != GENERATE_CLASS && self.class.previous(source, final)
+                @callables = self.class.previous(source, final).find_all { |v|
+                  v.is_a?(Vertex::Method)
+                }.map(&:callable)
+                # Since we built the graph using a registered path lookup, mark
+                # this as non-fresh
+                @fresh = false
+              end
+
+              setup!
+
+              logger.debug { "new graph mappers instance created #{self}" }
+              logger.debug { "graph: #{graph.inspect}" }
+            end
+
+            # Generate path and execute required mappers
+            #
+            # @return [Object] result
+            def execute
+              # Generate list of vertices to reach destination
+              # from root, if possible
+              search = Search.new(graph: graph)
+              logger.debug { "searching for conversion path #{source ? source : inputs.first.class} -> #{final}" }
+              p = search.path(@root, @dst)
+
+              logger.debug {
+                sp = p.map{ |v|
+                  v = v.to_s.slice(0, 100) + "...>" if v.to_s.length > 100
+                  v
+                }.join(" ->\n  ")
+                "found execution path:\n  #{sp}"
+              }
+
+              # Call root first and validate it was
+              # actually root. The value is a stub,
+              # so it's not saved.
+              result = p.shift.call
+              if result != :root
+                raise "Initial vertex is not root. Expected `:root', got `#{result}'"
+              end
+
+              # If we were not generating a value and the graph was fresh,
+              # register this path lookup for future use.
+              if source != GENERATE_CLASS && fresh
+                self.class.register(source, final, p)
+              end
+
+              # Execute each vertex in the path
+              p.each do |v|
+                # The argument list required by the current
+                # vertex will be defined by its incoming edges
+                args = search.graph.in_vertices(v).map(&:value)
+                v.call(*args)
+              end
+
+              # The resultant value will be stored within the
+              # destination vertex
+              @dst.value
+            rescue => err
+              # If a failure was encountered and the graph was fresh
+              # allow the error to continue bubbling up
+              raise if fresh
+
+              # If the graph is not fresh, unregister the cached path
+              # and retry the mapping with the full graph
+              logger.trace("search execution using cached path failed, retrying with full graph (#{err})")
+              self.class.unregister(source, final)
+              self.class.new(
+                output_type: final,
+                input_values: inputs,
+                mappers: mappers,
+                named: named,
+                source: source
+              ).execute
+            end
+
+            def to_s
+              "<Graph:Mappers output_type=#{final} input_values=#{inputs.map(&:class)}>"
+            end
+
+            def inspect
+              "<#{self.class.name}:#{object_id} output_type=#{final} input_values=#{inputs} graph=#{graph}>"
+            end
+
+            protected
+
+            # Setup the graph using the provided Mappers instance
+            def setup!
+              @graph = Graph.new
+              # Create a root vertex to provide a single starting point
+              @root = graph.add_vertex(Graph::Vertex::Root.new(value: :root))
+              @root.weight = ROOT_WEIGHT
+              # Add the provided input values
+              input_vertices = []
+              initial_value = true
+
+              input_vertices += inputs.map do |input_value|
+                if input_value == GENERATE
+                  initial_value = false
+                  next
+                end
+                if input_value.is_a?(Type::NamedArgument)
+                  iv = graph.add_vertex(
+                    Graph::Vertex::NamedValue.new(
+                      name: input_value.name.to_s,
+                      value: input_value.value
+                    )
+                  )
+                  iv.weight = input_value.name.to_s == named ? NAMED_VALUE_WEIGHT : VALUE_WEIGHT
+                else
+                  iv = graph.add_vertex(Graph::Vertex::Value.new(value: input_value))
+                  iv.weight = initial_value ? SOURCE_WEIGHT : VALUE_WEIGHT
+                end
+                # If this is the initial value and we are not generating a result,
+                # then mark it as the origin value
+                if initial_value
+                  @origin = iv
+                  logger.info("origin vertex has been set: #{@origin}")
+                end
+
+                initial_value = false
+                graph.add_edge(@root, iv)
+                iv
+              end.compact
+              # Also add the known values from the mappers instance
+              input_vertices += mappers.known_arguments.map do |input_value|
+                iv = graph.add_vertex(Graph::Vertex::Value.new(value: input_value))
+                iv.weight = VALUE_WEIGHT
+                graph.add_edge(@root, iv)
+                iv
+              end
+              fn_inputs = Array.new
+              fn_outputs = Array.new
+              # Create vertices for all our registered mappers,
+              # as well as their inputs and outputs
+              callables.each do |mapper|
+                fn = graph.add_vertex(Graph::Vertex::Method.new(callable: mapper))
+                fn_inputs += mapper.inputs.map do |i|
+                  iv = graph.add_vertex(Graph::Vertex::Input.new(type: i.type, origin_restricted: i.origin_restricted))
+                  iv.weight = INPUT_WEIGHT + fn.extra_weight
+                  graph.add_edge(iv, fn)
+                  iv
+                end
+                ov = graph.add_vertex(Graph::Vertex::Output.new(type: mapper.output))
+                ov.weight = (mapper.output == final ? DST_WEIGHT : OUTPUT_WEIGHT) + fn.extra_weight
+                graph.add_edge(fn, ov)
+                fn_outputs << ov
+              end
+              # Create an output vertex for our expected
+              # result type
+              @dst = graph.add_vertex(Graph::Vertex::Final.new(type: final))
+              @dst.weight = FINAL_WEIGHT
+
+              # Add an edge from all our value vertices to
+              # matching input vertices
+              input_vertices.each do |iv|
+                fn_inputs.each do |f_iv|
+                  if f_iv.origin_value_only? && iv != @origin
+                    next
+                  end
+                  if iv.type == f_iv.type || iv.type.ancestors.include?(f_iv.type)
+                    graph.add_edge(iv, f_iv)
+                  end
+                end
+
+                # If a value vertex matches the desired
+                # output value, connect it directly
+                if @dst.type == iv.type # || iv.type.ancestors.include?(@dst.type)
+                  graph.add_edge(iv, @dst)
+                end
+              end
+              # Add an edge from all our output vertices to
+              # matching input vertices
+              fn_outputs.each do |f_ov|
+                fn_inputs.each do |f_iv|
+                  next if f_iv.origin_value_only?
+                  if f_ov.type == f_iv.type || f_ov.type.ancestors.include?(f_iv.type)
+                    graph.add_edge(f_ov, f_iv)
+                  end
+                end
+
+                # If an output value matches the desired
+                # output value, connect it directly
+                if @dst.type == f_ov.type || f_ov.type.ancestors.include?(@dst)
+                  if @dst.type != f_ov.type
+                    f_ov.weight += 1000
+                  end
+                  graph.add_edge(f_ov, @dst)
+                end
+              end
+
+              # The output attached to our destination should be
+              # terminated at the destiation. If it has any out
+              # edges, remove those vertices (which has the bonus
+              # of helping to prevent cycles)
+              graph.each_in_vertex(@dst) do |vrt|
+                graph.each_out_vertex(vrt) do |ov|
+                  next if ov == @dst
+                  graph.remove_edge(vrt, ov)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/serve/mappers/internal/graph/search.rb

@@ -0,0 +1,329 @@
+module VagrantPlugins
+  module CommandServe
+    class Mappers
+      module Internal
+        class Graph
+          # Provides searching of a graph to determine if a
+          # destination vertex is accessible from a given
+          # root vertex.
+          class Search
+            class NoPathError < StandardError; end
+            class InvalidVertex < StandardError
+              attr_reader :vertex
+              def initialize(v)
+                super("Invalid vertex within path")
+                @vertex = v
+              end
+            end
+
+            include Util::HasLogger
+
+            attr_reader :graph
+
+            # Create a new Search instance
+            #
+            # @param graph [Graph] Graph used for searching
+            def initialize(graph:)
+              @m = Mutex.new
+              @graph = graph
+              @root = nil
+            end
+
+            # Generate a path from a given source vertex
+            #
+            # @param src [Vertex] Source vertex
+            # @return [Array<Vertex>] path from source to destination
+            # @raises [NoPathError] when no path can be determined
+            def path(src, dst)
+              @m.synchronize do
+                logger.debug { "finding path #{src} -> #{dst}" }
+
+                # Mark the root of our graph which will be used later
+                @root = src
+
+                # When searching for a path in the graph, we will be looking
+                # for the shortest path. Since we know the desired final
+                # destination, we want to use that as our starting point
+                # and attempt to find a path from that destination vertex
+                # to the source vertex. So we start by reversing the graph
+                graph.reverse!
+
+                # Perform an initial DFS to prune the graph down. This will remove any
+                # vertices which are not connected to the root of the graph (which will
+                # be the destination since we reversed the graph). The reason we do this
+                # is to reduce the overall size of the graph before generating our path,
+                # and to ensure that the both ends of the graph are still available after
+                # the pruning.
+                vertices = []
+                descender = lambda { |v|
+                  graph.depth_first_visit(v) { |vrt|
+                    vertices << vrt
+                  }
+                  vertices.uniq!
+                  vertices.each do |vrt|
+                    if vrt.incoming_edges_required
+                      graph.out_vertices(vrt).each do |ov|
+                        if !vertices.include?(ov)
+                          descender.call(ov)
+                        end
+                      end
+                    end
+                  end
+                }
+
+                # Since the destination is now the "root" of our reversed graph,
+                # we want to start our search from there to generate the list
+                # of verticies it can connect to.
+                descender.call(dst)
+
+                # Remove excess vertices from the graph
+                (graph.vertices - vertices).each { |v|
+                  graph.remove_vertex(v)
+                }
+
+                logger.trace { "graph after DFS reduction:\n#{graph.reverse.inspect}" }
+                logger.trace { "generating list of required vertices for path #{src} -> #{dst}" }
+
+                # If the graph no longer contains the source vertex (this is the root of the
+                # non-reversed graph) then it is impossible to generate a valid path.
+                if !graph.vertices.include?(src)
+                  raise NoPathError,
+                    "Graph no longer includes source vertex #{src} (#{src} -> #{dst})"
+                end
+
+                # This should not happen since we start our DFS from the destination vertex
+                # but we keep this sanity check regardless.
+                if !graph.vertices.include?(dst)
+                  raise NoPathError,
+                    "Graph no longer includes destination vertex #{dst} (#{src} -> #{dst})"
+                end
+                # Generate list of required vertices from the graph
+                required_vertices = generate_path(dst, src)
+
+                # If no vertices were returned, then the path generation failed
+                if required_vertices.nil?
+                  raise NoPathError,
+                    "Path generation failed to reach destination (#{src} -> #{dst&.type&.inspect})"
+                end
+
+                logger.trace { "required vertices list generation complete for path #{src} -> #{dst}" }
+
+                # Now that we have a path, remove all extraneous vertices
+                # from the graph. We're going to use the graph to provide
+                # us a proper ordering of the vertices below
+                (graph.vertices - required_vertices).each do |vrt|
+                  graph.remove_vertex(vrt)
+                end
+
+                # Reverse the graph so the direction of the graph is in its
+                # original state.
+                graph.reverse!
+
+                # Check if the graph is acyclic. If it is not, break any cycles found in the graph.
+                graph.break_cycles!(src) if !graph.acyclic?
+
+                logger.debug { "graph after acyclic breakage:\n#{graph.reverse.inspect}" }
+
+                # Apply topological sort to the graph so we have
+                # a proper order for execution. This is required
+                # to ensure that all inputs for a given vertex are
+                # available before executing it.
+                result = Array.new.tap do |path|
+                  t = graph.topsort_iterator
+                  until t.at_end?
+                    path << t.forward
+                  end
+                end
+
+                # If the first vertex of the path is not the expected source,
+                # or the last vertex is not the expected destination, then
+                # a valid path was not found. Even though we generated our
+                # list of required vertices, this can still occur if the
+                # resultant graph included any cycles, and breaking the cycle(s)
+                # resulted in orphaned vertices.
+                if result.first != src
+                  raise NoPathError,
+                    "Initial vertex is not source #{src} != #{result.first}"
+                end
+
+                if result.last != dst
+                  raise NoPathError,
+                    "Final vertex is not destination #{dst} != #{result.last}"
+                end
+
+                result
+              end
+            rescue NoPathError
+              if ENV["VAGRANT_LOG_MAPPER"].to_s != ""
+                begin
+                  require 'rgl/dot'
+                  graph.reverse.write_to_graphic_file('jpg', 'graph-no-path')
+                rescue
+                  #
+                end
+              end
+              raise
+            end
+
+            protected
+
+            # Generate a list of required vertices for making a
+            # path from the given source vertex to the given
+            # destination vertex.
+            #
+            # @param src [Vertex] source vertex
+            # @param dst [Vertex] destination vertex
+            # @return [Array<Vertex>, NilClass]
+            def generate_path(src, dst)
+              begin
+                # Find the shortest path based edge weights. Since
+                # we are generating a path against the reversed graph,
+                # the source is our desired destination vertex and the
+                # destination is the source vertex.
+                path = graph.shortest_path(src, dst)
+                logger.trace {
+                  o = Array(path).reverse.map { |v|
+                    "  #{v} ->"
+                  }.join("\n")
+                  "path generation #{dst} -> #{src}\n#{o}"
+                }
+                if path.nil?
+                  raise NoPathError,
+                    "Path generation failed to reach destination (#{dst} -> #{src})"
+                end
+                # Once we have the path, we need to expand the
+                # path to ensure that all vertices in the path
+                # are fully reachable, and if any vertices are
+                # missing that they are added
+                expand_path(path, dst, graph)
+              rescue InvalidVertex => err
+                # An invalid vertex will be flagged when path expansion exposes
+                # a vertex which requires all incoming edges and all the edges
+                # cannot reach the destination vertex. When this happens, we
+                # remove that vertex from the graph and then retry the path
+                # generation.
+                logger.trace { "invalid vertex in path, removing (#{err.vertex})" }
+                graph.remove_vertex(err.vertex)
+                retry
+              end
+            end
+
+            # Expand a given path of vertices by iterating through
+            # the provided path and validating all required vertices
+            # are in the path for any vertices which require all incoming
+            # edges. The result will be the list of original vertices
+            # plus all additional vertices found to be missing.
+            #
+            # @param path [Array<Vertex>] current path
+            # @param dst [Vertex]
+            def expand_path(path, dst, graph)
+              new_path = path.dup
+              path.each do |v|
+                # Only inspect vertices that require all
+                # incoming edges
+                next if !v.incoming_edges_required
+                logger.trace { "validating incoming edges for vertex #{v}" }
+                # Since we are using a reversed graph, the incoming edges are now
+                # outgoing edges, so we graph the out vertices
+                outs = graph.out_vertices(v)
+                # Make a clone of the graph so we can modify it without affecting
+                # the original
+                g = graph.clone
+                # Remove the original vertex we are currently inspecting from
+                # the cloned graph. This is done to prevent generating a cycle
+                # where the vetex is required in the path to reach the destination
+                g.remove_vertex(v)
+                # Now we find the path from each vertex to the destination
+                outs.each do |src|
+                  # Since inputs can support named arguments, temporarily update
+                  # weights of value vertices.
+                  ipath = reweight_for(src, g) do |ig|
+                    ig.shortest_path(src, dst)
+                  end
+                  # Remove any other incoming edges to this input
+                  # (graph.out_vertices(src) - [ipath.first]).each do |dv|
+                  #   graph.remove_edge(src, dv)
+                  # end
+
+                  # If no path was found an exception is raised that the vertex
+                  # in the path (this is the original vertex from the first loop)
+                  # is not valid within the path.
+                  if ipath.nil? || ipath.empty?
+                    logger.trace { "failed to find validating path from #{dst} -> #{src}" }
+                    raise InvalidVertex.new(v)
+                  else
+                    logger.trace { "found validating path from #{dst} -> #{src}" }
+                  end
+                  # Remove any vertices that already exist in our final collection
+                  # so we don't duplicate the inspection on them
+                  ipath = ipath - new_path
+                  if !ipath.empty?
+                    # Since we have new vertices we need to expand them to
+                    # ensure that they all have valid paths to the destination.
+                    # The graph provided here is our modified clone to prevent
+                    # a cycle where the original vertex is required
+                    ipath = expand_path(ipath, dst,  g)
+                    # And now we add any new vertices which were discovered to
+                    # be required
+                    new_path |= ipath
+                  end
+                end
+                logger.trace { "incoming edge validation complete for vertex #{v}" }
+              end
+              new_path
+            end
+
+            # Modify the weights of value type vertices when the given
+            # vertex is a Vertex::Input and has a name defined. All
+            # value vertices will have their weight reset to the default
+            # value weight, and if a Vertex::NamedValue exists with a
+            # matching name, it will have the NAMED_VALUE_WEIGHT
+            # applied. After the given block is executed, the value
+            # vertices will have their original weights re-applied.
+            #
+            # Since value vertices are identified by type, only
+            # one value of any type may exist in the graph. However,
+            # if the value is named, then multiple values of the same
+            # type may exist in the graph. For instance, with named
+            # values two strings could be provided, one named "local_path"
+            # and another named "remote_path". If a mapper function is
+            # only interested in the value of the "remote_path", it
+            # can include that name within its input definition. Then
+            # this method can be used to prefer the name string argument
+            # "remote_path" over the "local_path" named argument, or
+            # just a regular string value.
+            #
+            # @param vertex [Vertex] source vertex
+            # @param graph [Graph] graph to modify
+            # @yieldparam [Graph] modified graph (passed instance, not a copy)
+            # @yield block to execute
+            # @return [Object] result of block
+            def reweight_for(vertex, graph)
+              original_weights = {}
+              begin
+                if vertex.is_a?(Vertex::Input) && vertex.name
+                  graph.each_vertex do |v|
+                    next if !v.is_a?(Vertex::Value)
+                    original_weights[v] = v.weight
+                    if v.name.to_s == vertex.name.to_s
+                      v.weight = Mappers::NAMED_VALUE_WEIGHT
+                    else
+                      v.weight = Mappers::VALUE_WEIGHT
+                    end
+                  end
+                end
+                yield graph
+              ensure
+                # Set the weights of the value vertices back to
+                # their original values
+                original_weights.each do |v, w|
+                  v.weight = w
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/serve/mappers/internal/graph/vertex/final.rb

@@ -0,0 +1,35 @@
+module VagrantPlugins
+  module CommandServe
+    class Mappers
+      module Internal
+        class Graph
+          class Vertex
+            # Vertex that represents an output of
+            # a method
+            class Final < Vertex
+              attr_reader :type
+
+              def initialize(type:)
+                @type = type
+              end
+
+              # When an output Vertex is called,
+              # we simply set the value for use
+              def call(arg)
+                @value = arg
+              end
+
+              def to_s
+                "<Vertex:Final type=#{type} hash=#{hash_code}>"
+              end
+
+              def inspect
+                "<#{self.class.name} type=#{type} value=#{value} hash=#{hash_code}>"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end