vagrant-tools 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d2898850a57d6033da0766d357602395ba69b1d
-  data.tar.gz: 65271bbbca73801f2223bfebdd95965181be4ad6
+  metadata.gz: 223938120159ab83c8dcbd85f7b159cf985cd966
+  data.tar.gz: 116911824dbf2fe3b9b9290da10f9e73ff8b02d4
 SHA512:
-  metadata.gz: da9a691708420a95151da7c89cc5c588c3aadac1f596215766cf19217df319a12cac5302049efee3b2448af0036df4f47f46c901b244cac99845efcdd9a78f57
-  data.tar.gz: c1325e21edf6785ca70e9ebe54c14018afb805b910f9eff437e653f9cd5a44acb5be7ab38a1dba4c0de2953deaec21743b89e63e0d4563e3d99be1eb732cb163
+  metadata.gz: f12b48fad246a5c6bfe7ddefb1d989ecaa49d4a228f0b6bfe44f8af2745d49f8e9723fb9eab143eb09acc5f2d735b01046a035fbf4ae1c70636e86e327e47f70
+  data.tar.gz: 4efa91af35cb46613d1e4aad748b47f44728b73983f89a0c1895c992d0db6d117ef3aa04af481aef14196f181bf56e5cdd65eca7d73effec5aa8907b80b9f75c

data/README.md

@@ -1,10 +1,30 @@
 # Vagrant::Tools
 
-Vagrant configuration management tool (via cli).
+Vagrant cli configuration management tool. The missing tool for vagrant that allows you to control all your vagrant instances. Use cli command: `vgls` to list all vagrant configs (all Vagrantfiles), and `vgctl [target] [vgcmd]` to control configurations from outside the Vagrantfile dir.
 
-By using cli commands: `vgls` you can list all .vagrant configs on your system.
-Use `vgctl -t config -c (vagrant command)` to run vagrant commands from any path (working dir) on your system.
+**Example**
 
+```bash
+$ vgls
+some-project (/Users/dblommesteijn/Programming/some-project)
+- testing (vmid: cee72fc1-f647-4a2a-be48-04b4c1adeb2d)
+- deployment (vmid: d46784f8-5a76-49eb-a511-1ab6c50d777d)
+$ vgctl some-project status
+Current machine states:
+
+testing                   poweroff (virtualbox)
+deployment                poweroff (virtualbox)
+
+This environment represents multiple VMs. The VMs are all listed
+above with their current state. For more information about a specific
+VM, run `vagrant status NAME`.
+$ vgctl some-project up testing
+... starting the vm
+$ vgctl some-project ssh testing
+... interactive ssh shell
+$ vgctl some-project destroy testing
+... destroying vm [y/N]
+```
 
 ## Roadmap
 
@@ -14,18 +34,28 @@ Use `vgctl -t config -c (vagrant command)` to run vagrant commands from any path
   * List all vagrant configurations
   * Add basic controls for up/ halt/ destroy etc.
 
-* Version (0.1.0) Current
+* Version (0.1.0)
 
   * Enable `vagrant ssh` interactive shell
 
 * Version (0.1.1)
 
-  * Filter only active/ inactive
-  * Add option to switch to .config path `vgctl -t target-box -c cd`
+  * Filter show only active
+  * Changed formatting of target and command
+  * Add option to switch to .config path `vgctl target-box shell`
+  * Filter show only zombies
+
+* Current/ Master
+
+  * stub
 
 
 ## Installation
 
+Install the latest version from the git repository, or install it via RubyGems
+
+#### From Source
+
 **Clone the git repository to your local machine.**
 
 ```bash
@@ -40,6 +70,17 @@ rake install
 # vgls and vgctl will be available system wide
 ```
 
+#### RubyGems
+
+**Get the package from RubyGems**
+
+```bash
+gem install vagrant-tools
+```
+
+
+## Usage
+
 **Run commands**
 
 ```bash
@@ -49,8 +90,6 @@ vgls
 vgctl
 ```
 
-## Usage
-
 Verbose, this will output operations to STDOUT
 
 ```bash
@@ -65,8 +104,8 @@ Change target configuration (find operation), base from where .vagrant configs a
 *NOTE: this will force cache refresh*
 
 ```bash
-vgls -p `$HOME`/path/to/your/repos
-vgctl -p `$HOME`/path/to/your/repos
+vgls -p $HOME/path/to/your/repos
+vgctl -p $HOME/path/to/your/repos
 ```
 
 Target or list vagrant config relative to a given config
@@ -74,8 +113,8 @@ Target or list vagrant config relative to a given config
 *NOTE: duplicate config names will get a _n offset*
 
 ```bash
-vgls -t my-test-box
-vgctl -t my-test-box
+vgls my-test-box
+vgctl my-test-box
 ```
 
 Refresh cache, by default cache is stored at `$HOME/.vagrant-tools/settings.json`
@@ -89,12 +128,31 @@ vgctl -x
 Run a vagrant command (-c prepends `vagrant ` to all commands)
 
 ```bash
-vgctl -t my-test-box -c list-commands
+vgctl my-test-box list-commands
 # runs `vagrant list-commands` in the path of `my-test-box`
 # ... etc
 ```
 
-Print help file
+Show only active instances
+
+```bash
+vgls -a
+```
+
+Show detached instances (running without .config)
+
+```bash
+vgls -z
+```
+
+Launch a shell targeted at the 'cwd' relative to the target
+
+```bash
+vgctl my-text-box shell
+# launches a shell: pwd => $HOME/path/to/your/repos/my-text-box
+```
+
+Print help message
 
 ```bash
 vgls -h
@@ -109,16 +167,16 @@ Listing all vagrant configs, and starting VM
 # list all configs
 vgls
 # execute `vagrant up` on path of `my-test-box`
-vgctl -t my-test-box -c up
-vgctl -t my-test-box -c ssh
+vgctl my-test-box up
+vgctl my-test-box ssh
 ```
 
 Destroy a running VM
 
 ```bash
-# list all configs
-vgls
+# list running configs
+vgls -a
 # execute `vagrant destroy` on path of `my-test-box`
-vgctl -t my-test-box -c destory
+vgctl my-test-box destory
 ```
 

data/bin/vgctl

@@ -1,84 +1,121 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + "/../lib/vagrant/tools")
-require 'optparse'
+require 'getoptlong'
 
 
-def main(argv)
-  # set configuration
+def main()
+  # configure vgtools
   vgtools_cfg = Vagrant::Tools.config do |c|
     # defaults
     c.prefix = ENV["HOME"]
     c.verbose = false
-    # getopts
-    opt_parser = OptionParser.new do |opts|
-      opts.banner = "Vagrant control, Usage: vgctl [options]"
+    c.output = {machine: false, long: false, only_active: false}
+    c.target = nil
+    c.cmd = nil
+    c.refresh_cache = false
+    # parse regular commands with getopt
+    begin
+      opts = GetoptLong.new(
+        ['--prefix', '-p', GetoptLong::REQUIRED_ARGUMENT],
+        ['--verbose', '-v', GetoptLong::NO_ARGUMENT],
+        ['--refresh-cache', '-x', GetoptLong::NO_ARGUMENT],
+        ['--only-active', '-a', GetoptLong::NO_ARGUMENT],
+        ['--help', '-h', GetoptLong::NO_ARGUMENT],
+      )
+      opts.each do |opt, arg|
+        case opt
+          when '--prefix'
+            c.prefix = arg
+            c.refresh_cache = true
+          when '--verbose'
+            c.verbose = true
+          when '--refresh-cache'
+            c.refresh_cache = true
+          when '--help'
+            puts <<-EOF
+vgctl, version: #{Vagrant::Tools::VERSION}
 
-      opts.on("-p", "--prefix DIR", String, "Define prefix (default $HOME)") do |v|
-        c.prefix = v
-        c.refresh_cache = true
-      end
-      opts.on("-v", "--verbose", "Verbose output") do |v|
-        c.verbose = true
-      end
-      opts.on("-t", "--target TARGET", String, "Target specific Vagrantfile directory") do |v|
-        c.target = v
-      end
-      opts.on("-c", "--cmd COMMAND", String, "Run vagrant command relative to -t TARGET (-c \"up\")") do |v|
-        c.cmd = v
-      end
-      opts.on("-x", "--refresh-cache", "Refresh cached results") do |v|
-        c.refresh_cache = v
-      end
-      opts.on_tail("-h", "--help", "Show this message") do
-        puts opts
-        exit 1
+usage: vgctl [-pvxhc] [TARGET [COMMAND | shell]]
+  
+  p : set lookup prefix (default $HOME)
+  v : verbose output
+  x : refresh cached results (.vagrant lookup)
+  TARGET : target a specific config (vagrantfile dir)
+  COMMAND : run vagrant command at target's `cwd`
+  shell : start a shell at target's `cwd`
+
+  h : show this help message
+            EOF
+          exit
+        else
+          puts "extra: " + opt + "|" + arg
+        end
       end
+    rescue GetoptLong::InvalidOption => e
+      exit
     end
-    begin
-      opt_parser.parse!
-    rescue OptionParser::MissingArgument => e
-      puts e.message
-      exit 1
-    rescue OptionParser::InvalidOption => e
-      puts e.message
-      exit 1
+
+    # parse commands and targets (outside getopt)
+    ARGV.each_with_index do |arg, i|
+      case i
+      when 0
+        c.target = arg
+      when 1
+        c.cmd = ARGV[1..-1].join(" ")
+        break
+      end
     end
   end
+  # configuration
+  cfg = Vagrant::Tools.get_config
+  # output buffer
+  output = Vagrant::Tools::Output.new(cfg)
+  output.append("running `#{File.basename(__FILE__)}` in verbose mode (disable by removing [-v])", :verbose)
+  output.append(cfg.to_s, :verbose)
+
   cfg = Vagrant::Tools.get_config 
   verify = vgtools_cfg.verify? do |errors|
-    # if cfg.target.nil? || cfg.target == "
-    errors[:target] = "target does not exist" if cfg.target.nil?
-    errors[:cmd] = "invalid" if cfg.cmd.nil? || cfg.cmd == ""
-    # errors[:]
+    errors[:target] = "missing target option (print help -h)" if cfg.target.nil? || cfg.target == ""
+    errors[:cmd] = "missing command option (print help -h)" if cfg.cmd.nil? || cfg.cmd == ""
   end
   unless verify
-    puts vgtools_cfg.error_messages
-    exit 1
+    output.append(vgtools_cfg.error_messages)
+    output.render()
+    exit
   end
 
-  # print verbose message
-  if cfg.verbose
-    puts "Running `#{File.basename(__FILE__)}` in verbose mode (disable by removing -v [options])"
+  # build root object from found configs (internal)
+  root = Vagrant::Tools::Root.new(cfg, output)
+  nodes = []
+
+  # visit configs
+  root.visit() do |node|
+    if node.is_a?(Vagrant::Tools::Orm::Config)
+      nodes << node if node.match_target?(cfg.target)
+    end
   end
-  
-  # find config root by target name (project root name)
-  root = Vagrant::Tools::Root.new
-  config = root.find_by_project_root(cfg.target)
-  if config.nil?
-    puts "target config not found"
-    exit
-  else
-    puts "executing: #{cfg.cmd}" if cfg.verbose
+
+  begin
+    # verify config target, and run on one specific config
+    if nodes.empty?
+      output.append("target config not found: `#{cfg.target}`")
+    elsif nodes.size > 1
+      output.append("multiple configs found (this should never happen)")
+    else
+      output.append("executing: #{cfg.cmd}", :verbose)
+      nodes.first.exec_vagrant_command(cfg.cmd)
+    end
+  rescue Exception => e
+    output.append(e.message)
   end
-  # execute command relative to config
-  config.exec_vagrant_command(cfg.cmd)
+  output.render()
 end
 
-
+# entry point
 if File.basename(__FILE__) == File.basename($0)
   begin
-    main(ARGV)
+    main()
   rescue Interrupt
     exit 0
   end

data/bin/vgls

@@ -1,71 +1,198 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + "/../lib/vagrant/tools")
-require 'optparse'
+require 'getoptlong'
 
 
-def main(argv)
-  # set configuration
+def main()
+  # configure vgtools
   vgtools_cfg = Vagrant::Tools.config do |c|
     # defaults
     c.prefix = ENV["HOME"]
     c.verbose = false
-    # getopts
-    opt_parser = OptionParser.new do |opts|
-      opts.banner = "Vagrant list, Usage: vgls [options]"
-      opts.on("-p", "--prefix DIR", String, "Define prefix (default $HOME)") do |v|
-        c.prefix = v
-        c.refresh_cache = true
-      end
-      opts.on("-v", "--verbose", "Verbose output") do |v|
-        c.verbose = true
-      end
-      opts.on("-t", "--target TARGET", String, "Target specific config (Vagrantfile dir)") do |v|
-        c.target = v
-      end
-      opts.on("-x", "--refresh-cache", "Refresh cached results") do |v|
-        c.refresh_cache = v
-      end
-      opts.on_tail("-h", "--help", "Show this message") do
-        puts opts
-        exit 1
-      end
+    c.output = {machine: false, long: false, only_active: false, vagrantfile: false, zombies: false}
+    c.target = nil
+    c.cmd = nil
+    c.refresh_cache = false
 
-    end
+    # parse regular commands with getopt
     begin
-      opt_parser.parse!
-    rescue OptionParser::InvalidOption => e
-      puts e.message
-      exit 1
-    rescue OptionParser::MissingArgument => e
-      puts e.message
-      exit 1
+      opts = GetoptLong.new(
+        ['--prefix', '-p', GetoptLong::REQUIRED_ARGUMENT],
+        ['--verbose', '-v', GetoptLong::NO_ARGUMENT],
+        ['--refresh-cache', '-x', GetoptLong::NO_ARGUMENT],
+        ['--only-active', '-a', GetoptLong::NO_ARGUMENT],
+        ['--zombies', '-z', GetoptLong::NO_ARGUMENT],
+        ['--vagrantfile', '-V', GetoptLong::NO_ARGUMENT],
+        ['--help', '-h', GetoptLong::NO_ARGUMENT],
+      )
+      opts.each do |opt, arg|
+        case opt
+          when '--prefix'
+            c.prefix = arg
+            c.refresh_cache = true
+          when '--verbose'
+            c.verbose = true
+          when '--refresh-cache'
+            c.refresh_cache = true
+          when '--only-active'
+            c.output[:only_active] = true
+          when '--vagrantfile'
+            c.output[:vagrantfile] = true
+          when '--zombies'
+            c.output[:zombies] = true
+          when '--help'
+            puts <<-EOF
+vgls, version: #{Vagrant::Tools::VERSION}
+
+usage: vgls [-pvxh] [TARGET]
+  
+  p : set lookup prefix (default $HOME)
+  v : verbose output
+  x : refresh cached results (.vagrant lookup)
+  V : output Vagrantfile
+  a : filter on running instances
+  z : filter on zombie instances (no .config and running)
+  TARGET : target a specific config (Vagrantfile dir)
+
+  h : show this help message
+            EOF
+          exit
+        end
+      end
+    rescue GetoptLong::InvalidOption => e
+      exit
+    end
+
+    # parse commands and targets (outside getopt)
+    ARGV.each_with_index do |arg, i|
+      case i
+      when 0
+        c.target = arg
+      when 1
+        c.cmd = ARGV[1..-1].join(" ")
+        break
+      end
     end
   end
 
+  # configuration
+  cfg = Vagrant::Tools.get_config
+  # output buffer
+  output = Vagrant::Tools::Output.new(cfg)
+  output.append("running `#{File.basename(__FILE__)}` in verbose mode (disable by removing [-v])", :verbose)
+  output.append(cfg.to_s, :verbose)
+
+  # verify errors
   verify = vgtools_cfg.verify? do |errors|
-    # if
-    # errors[:]
+    # TODO: not sure if this should be here!?
+    if cfg.output[:only_active] && cfg.output[:zombies]
+      errors[:zombies] = "cannot lookup both only-active and zombies"
+    end
   end
+  # act on errors
   unless verify
     puts vgtools_cfg.error_messages
     exit 1
   end
+  # build root object from found configs (internal)
+  root = Vagrant::Tools::Root.new(cfg, output)
+  nodes = []
+
+  if !cfg.output[:zombies]
+    # filter no-nodes
+    if !cfg.output[:only_active] && cfg.target.nil?
+      root.visit() do |node|
+        nodes << node
+      end
+    # filter `only-active`
+    elsif cfg.output[:only_active] && cfg.target.nil?
+      root.visit() do |node|
+        if node.is_a?(Vagrant::Tools::Orm::Config)
+          nodes << node if node.has_active_machines?
+        elsif node.is_a?(Vagrant::Tools::Orm::Machine)
+          nodes << node if node.has_active_providers?
+        elsif node.is_a?(Vagrant::Tools::Orm::Provider)
+          nodes << node if node.active?
+        end
+      end
+    # filter `target`
+    elsif !cfg.output[:only_active] && !cfg.target.nil?
+      root.visit() do |node|
+        if node.is_a?(Vagrant::Tools::Orm::Config)
+          nodes << node if node.match_target?(cfg.target)
+        elsif node.is_a?(Vagrant::Tools::Orm::Machine)
+          nodes << node if node.parent.match_target?(cfg.target)
+        elsif node.is_a?(Vagrant::Tools::Orm::Provider)
+          nodes << node if node.parent.match_target?(cfg.target)
+        end
+      end
+    # filter `target` and `only-active`
+    elsif cfg.output[:only_active] && !cfg.target.nil?
+      root.visit() do |node|
+        if node.is_a?(Vagrant::Tools::Orm::Config)
+          nodes << node if node.has_active_machines? && node.match_target?(cfg.target)
+        elsif node.is_a?(Vagrant::Tools::Orm::Machine)
+          nodes << node if node.has_active_providers? && node.parent.match_target?(cfg.target)
+        elsif node.is_a?(Vagrant::Tools::Orm::Provider)
+          nodes << node if node.active? && node.parent.match_target?(cfg.target)
+        end
+      end
+    end
+  # filter `zombies` detached VMs
+  else
+    running_vms = Vagrant::Tools::Helper.get_running_vms
+    root.visit() do |node|
+      if node.is_a?(Vagrant::Tools::Orm::Provider)
+        if !node.process.nil?
+          running_vms.delete(node.process.pid)
+        end
+      end
+    end
+    if running_vms.size > 0
+      running_vms.each do |pid, vm|
+        output.append("#{vm.pid}, #{vm.cmdline}")
+      end
+    end
+  end
 
-  cfg = Vagrant::Tools.get_config 
-  if cfg.verbose
-    puts "Running `#{File.basename(__FILE__)}` in verbose mode (disable by removing -v [options])"
+  # determine how the nodes are output
+  nodes.each do |node|
+    # show vagrantfile
+    if cfg.output[:vagrantfile]
+      if node.is_a?(Vagrant::Tools::Orm::Config)
+        output.append(node)
+        output.append("-- Vagrantfile (#{node.vagrantfile}): ---------------------")
+        output.append(node.vagrantfile_contents)
+      end
+    else 
+      # print all nodes
+      if node.is_a?(Vagrant::Tools::Orm::Config)
+        output.append(node)
+      elsif node.is_a?(Vagrant::Tools::Orm::Machine)
+        output.append("- #{node.name} ", :nonewline)
+      elsif node.is_a?(Vagrant::Tools::Orm::Provider)
+        output.append("(#{node.status_s})")
+      end
+    end
   end
 
-  # output lists
-  root = Vagrant::Tools::Root.new
-  puts root.to_outputs
+  # append cache status
+  if root.cache.cache_old?
+    a = root.cache.cache_time_a
+    output.append("cache is %dd, %dh, %dm, and %ds old (consider refreshing -x)" % a)
+  elsif cfg.verbose
+    a = root.cache.cache_time_a
+    output.append("cache is %dd, %dh, %dm, and %ds old" % a, :verbose)
+  end
+  # print output
+  output.render()
 end
 
-
+# entry point
 if File.basename(__FILE__) == File.basename($0)
   begin
-    main(ARGV)
+    main()
   rescue Interrupt
     exit 0
   end

data/lib/vagrant/tools/cache.rb

@@ -10,26 +10,32 @@ module Vagrant
         @path = path
         @cfg = Vagrant::Tools.get_config
         unless File.exists?(@path)
-          puts "Creating `#{path}`" if @cfg.verbose
+          puts "creating `#{path}`" if @cfg.verbose
           FileUtils.mkpath(@path)
         end
         @filename = "#{@path}/settings.json"
+        @delta = 0.0
       end
 
       def get_config
         return {} unless File.exists?(@filename)
-        #TODO: read from file
         begin
+          puts "reading cache file: `#{@filename}`" if @cfg.verbose
           json = JSON.parse(File.read(@filename), {symbolize_names: true})
-          json[:configs]
-        rescue
+          c_time = Time.at(json[:configs_date])
+          puts "cache time: `#{c_time}`" if @cfg.verbose
+          @delta = Cache.time_delta(c_time) #if json.include?(:configs_date)
+          return json[:configs]
+        rescue Exception => e
+          puts e.message
+          puts e
           return {}
         end
       end
 
       def set_config(dirs)
-        puts "Writing to `#{@filename}`" if @cfg.verbose
-        config_paths = { configs: dirs.flat_map{|k,v| v.map(&:config_path)} }
+        puts "writing to `#{@filename}`" if @cfg.verbose
+        config_paths = { configs_date: Time.now.to_i, configs: dirs.flat_map{|k,v| v.map(&:config_path)} }
         flat_json = JSON.pretty_generate(config_paths)
         puts flat_json if @cfg.verbose
         File.open(@filename,"w") do |f|
@@ -37,6 +43,25 @@ module Vagrant
         end
       end
 
+      def cache_old?
+        @delta > 864000.0
+      end
+
+      def cache_time_a
+        mm, ss = @delta.divmod(60) 
+        hh, mm = mm.divmod(60) 
+        dd, hh = hh.divmod(24)
+        [dd, hh, mm, ss]
+      end
+
+      protected
+
+      class << self
+        def time_delta(time)
+          now = Time.now
+          Time.now - time
+        end
+      end
     end
 
   end

data/lib/vagrant/tools/config.rb

@@ -7,11 +7,6 @@ module Vagrant
 
       def initialize
         @errors = {}
-        self.prefix = ENV["HOME"]
-        self.verbose = false
-        self.output = {machine: false, long: false}
-        self.target = nil
-        self.cmd = nil
       end
 
       def verify?(&block)
@@ -29,8 +24,19 @@ module Vagrant
       end
 
       def error_messages
-        @errors.map{|k,v| "Error `#{k}`: #{v}"}
+        @errors.map{|k,v| "error `#{k}`: #{v}"}
       end
+      
+      def to_hash
+        hash = {}
+        instance_variables.each {|var| hash[var.to_s.delete("@")] = instance_variable_get(var) }
+        hash
+      end
+
+      def to_s
+        self.to_hash.map{|k,v| "#{k}: #{v}"}.join("\n")
+      end
+
 
     end
 

data/lib/vagrant/tools/helper.rb

@@ -1,25 +1,31 @@
 module Vagrant
   module Tools
-
     class Helper
-
       class << self
+        def iterate_processes(&block)
+          Sys::ProcTable.ps(&block)
+        end
 
-        # collecting user input, continue if input == y else exit
-        # def collect_input_yn_exit!(action)
-        #   STDOUT.write "#{action} are you sure [y/N]? "
-        #   STDOUT.flush
-        #   a = gets
-        #   case a.downcase
-        #   when "y\n"
-        #     return true
-        #   else
-        #     exit
-        #   end
-        # end
+        def get_running_vms
+          vms = []
+          Helper.iterate_processes do |p|
+            if p.cmdline.include?("VBoxHeadless")
+              vms << p
+            #elsif... add other providers
+            end
+          end
+          # remove all non-vagrant boxes
+          # vms.reject{|vm| vm.cmdline.match(/--startvm ([0-9a-f\-]+)/).size <= 0}#.map{|t| {t.pid => t}}
 
+          ret = {}
+          vms.each do |vm|
+            tmp = vm.cmdline.match(/--startvm ([0-9a-f\-]+)/)
+            next if tmp.size <= 0
+            ret[vm.pid] = vm
+          end
+          ret
+        end
       end
-
     end
   end
 end

data/lib/vagrant/tools/orm/config.rb

@@ -6,15 +6,21 @@ module Vagrant
 
       class Config
 
-        attr_accessor :name, :project_root, :offset, :config_path
+        ENV_SHELL = ENV["SHELL"]
 
-        def initialize(config_path)
-          @cfg = Vagrant::Tools.get_config
+        attr_accessor :name, :project_root, :offset, :config_path, :vagrantfile, :parent
+
+        def initialize(cfg, output, parent, config_path)
+          @cfg = cfg
+          @output = output
+          self.parent = parent
           self.config_path = config_path
           self.project_root = File.absolute_path("#{config_path}/../")
-          @machines = Dir["#{self.config_path}/machines/*"].flat_map{|t| Machine.new(t)}
+          self.vagrantfile = File.absolute_path("#{self.project_root}/Vagrantfile")
+          @machines = Dir["#{self.config_path}/machines/*"].flat_map{|t| Machine.new(@cfg, @output, self, t)}
           self.name = File.basename(File.absolute_path("#{config_path}/../"))
           self.offset = 0
+          @output.append("found config: `#{self.config_path}`", :verbose)
         end
 
         def project_root_name
@@ -26,9 +32,18 @@ module Vagrant
           "#{self.project_root_name}#{o}"
         end
 
-        def exec_vagrant_command(cmd)
-          cmd = "(cd #{self.project_root} && vagrant #{cmd})"
-          puts cmd if @cfg.verbose
+        def exec_vagrant_command(command)
+          # TODO: add some cmd check?
+          cmd = ""
+          case command
+          when 'shell'
+            raise "no shell found (in $SHELL)" if ENV_SHELL.nil? || ENV_SHELL == ""
+            cmd = "(cd #{self.project_root} && #{ENV_SHELL})"
+          else
+            cmd = "(cd #{self.project_root} && vagrant #{command})"
+          end
+          @output.append(cmd, :verbose)
+          # system call to command
           system(cmd)
         end
 
@@ -36,11 +51,43 @@ module Vagrant
           @machines.map(&:name)
         end
 
+        def vagrantfile_contents
+          return nil unless File.exists?(self.vagrantfile)
+          File.read(self.vagrantfile)
+        end
+
+        def has_active_machines?
+          @machines.map(&:has_active_providers?).include?(true)
+        end
+
+        def match_target?(target)
+          self.project_root_name_with_offset == target
+        end
+
+        def pretty_name
+          "#{self.project_root_name_with_offset} (#{@project_root})"
+        end
+
         def to_outputs
           machines = @machines.map(&:to_outputs).join("")
-          "#{self.project_root_name_with_offset} (#{@project_root})\n#{machines}"
+          if !@cfg.output[:only_active]
+            "#{self.project_root_name_with_offset} (#{@project_root})\n#{machines}"
+          else
+            if !machines.empty?
+              "#{self.project_root_name_with_offset} (#{@project_root})\n#{machines}"
+            end
+          end
         end
 
+        def visit(&block)
+          block.call(self)
+          @machines.each do |machine|
+            machine.visit(&block)
+          end
+        end
+
+        protected
+
       end
 
     end

data/lib/vagrant/tools/orm/machine.rb

@@ -4,12 +4,15 @@ module Vagrant
 
       class Machine
 
-        attr_accessor :name
+        attr_accessor :name, :parent
 
-        def initialize(machine_path)
+        def initialize(cfg, output, parent, machine_path)
+          @cfg = cfg
+          @output = output
+          self.parent = parent
           @machine_path = machine_path
           self.name = File.basename(machine_path)
-          @provider = Dir["#{@machine_path}/*"].flat_map{|t| Provider.new(t)}
+          @provider = Dir["#{@machine_path}/*"].flat_map{|t| Provider.new(@cfg, @output, parent, t)}
         end
 
         def ids
@@ -20,10 +23,15 @@ module Vagrant
           @provider.map(&:process)
         end
 
-        def to_outputs
-          provider = @provider.map(&:to_outputs).join("")
-          return "- #{self.name} (no provider found)\n" if provider.empty?
-          "- #{self.name} (#{provider})\n"
+        def has_active_providers?
+          @provider.map(&:active?).include?(true)
+        end
+
+        def visit(&block)
+          block.call(self)
+          @provider.each do |provider|
+            provider.visit(&block)
+          end
         end
 
       end

data/lib/vagrant/tools/orm/provider.rb

@@ -6,32 +6,41 @@ module Vagrant
 
       class Provider
 
-        attr_accessor :id
+        attr_accessor :id, :parent
 
-        def initialize(provider_path)
+        def initialize(cfg, output, parent, provider_path)
+          @cfg = cfg
+          @output = output
+          self.parent = parent
           @provider_path = provider_path
           @id_file = "#{@provider_path}/id"
           self.id = File.read(@id_file) if self.valid?
           @process = nil
+          self.process
         end
 
         def valid?
           File.exists?(@id_file)
         end
 
+        def active?
+          !@process.nil?
+        end
+        # alias_method :has_active?, :active?
+
         def process
-          return @process unless @process.nil?
-          Sys::ProcTable.ps do |p|
+          return @process if !@process.nil? || self.id.nil?
+          Helper.iterate_processes do |p|
             @process = p if p.cmdline.include?(self.id)
           end
           @process
         end
 
-        def to_outputs
+        def status_s
           ret = []
           if self.valid?
             p = self.process
-            if p.nil?
+            if !self.active?
               ret << "vmid: #{self.id}"
             else
               ret << "pid: #{p.pid}"
@@ -42,6 +51,10 @@ module Vagrant
           ret.join
         end
 
+        def visit(&block)
+          block.call(self)
+        end
+
       end
 
     end

data/lib/vagrant/tools/output.rb

@@ -0,0 +1,36 @@
+module Vagrant
+  module Tools
+
+    class Output
+
+      def initialize(config)
+        @cfg = config
+        @buffer = []
+      end
+
+      def render()
+        @buffer.each do |buffer|
+          if (!buffer.last.include?(:verbose) || @cfg.verbose)
+            STDOUT.write(buffer.first)
+            STDOUT.write("\n") if !buffer.last.include?(:nonewline)
+            STDOUT.flush
+          end
+        end
+      end
+
+      def append(node, options=[])
+        options = [options] unless options.is_a?(Array)
+        if node.is_a?(Vagrant::Tools::Orm::Config)
+          @buffer << [node.pretty_name, options]
+        elsif node.is_a?(String)
+          @buffer << [node, options]
+        elsif node.is_a?(Array)
+          node.each do |n|
+            @buffer << [n, options]
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/vagrant/tools/root.rb

@@ -6,29 +6,32 @@ module Vagrant
 
     class Root
 
+      attr_accessor :cache
+
       LOOKUP_DIR = ".vagrant"
 
-      def initialize
-        @cfg = Vagrant::Tools.get_config
+      def initialize(cfg, output)
+        @cfg = cfg
+        @output = output
         @dirs = {}
+        self.cache = Cache.new
         self.find_vagrant_configs
       end
 
-      def find_by_project_root(project_root_name)
-        self.get_config_without_offset(project_root_name)
-      end
+      # def find_by_project_root(project_root_name)
+      #   self.get_config_without_offset(project_root_name)
+      # end
 
       def find_vagrant_configs
         unless @dirs.empty?
-          puts "Config already loaded (use -x to force reload)" if @cfg.verbose
+          @output.append("config already loaded (use -x to force reload)", :verbose)
           return @dirs
         end
         prefix = @cfg.prefix
-        cache = Cache.new
-        cache_configs = cache.get_config
+        cache_configs = self.cache.get_config
         # break if config found (unless refreshing)
         if !cache_configs.empty? && !@cfg.refresh_cache
-          puts "Reading config from cache" if @cfg.verbose
+          @output.append("reading config from cache", :verbose)
           cache_configs.each do |config|
             # create new config instance
             self.add_config_dirs(config)
@@ -37,34 +40,68 @@ module Vagrant
         end
         # findin configs via find
         cmd = "find \"#{prefix}\" -type d -name \"#{LOOKUP_DIR}\""
-        puts "Finding vagrant configs: `#{cmd}`..." if @cfg.verbose
+        @output.append("finding vagrant configs: `#{cmd}`...", :verbose)
         Open3.popen3(cmd) do |stdin, stdout, stderr|
           stdin.close_write
-          stdout.read.split("\n").each do |config|
+          stdout.read.split("\n").each do |config_file|
             # create new config instance
-            self.add_config_dirs(config)
+            self.add_config_dirs(config_file)
           end
           stderr.close_read
         end
-        cache.set_config(@dirs)
+        self.cache.set_config(@dirs)
         self
       end
 
-      def to_outputs
-        ret = []
-        if @cfg.target.nil?
-          # print all
-          ret << @dirs.flat_map{|k,t| t.map(&:to_outputs)}
-        else
-          ret << self.get_config_without_offset(@cfg.target).to_outputs      
+      # def to_outputs
+      #   ret = []
+      #   if @cfg.target.nil?
+      #     # print all
+      #     ret << @dirs.flat_map{|k,t| t.map(&:to_outputs)}
+      #   else
+      #     ret << self.get_config_without_offset(@cfg.target).to_outputs      
+      #   end
+      #   ret.join
+      # end
+
+    #     if @cfg.target.nil?
+    #       configs = @dirs.flat_map{|k,t| t}
+    #     else
+    #       configs = [self.get_config_without_offset(@cfg.target)]
+    #     end
+
+    #         # filter `target`
+    # elsif !cfg.target.nil?
+    #   if node.is_a?(Vagrant::Tools::Orm::Root)
+    #     nodes << node
+    #   end
+
+      def visit(&block)
+        configs = @dirs.flat_map{|k,t| t}
+        block.call(self)
+        configs.each do |config|
+          config.visit(&block)
         end
-        ret.join
       end
 
+      def to_s
+        "root"
+      end
+
+      def has_active?
+        false
+      end
+
+      def match_target?(target)
+        false
+      end
+
+
+
       protected
 
       def add_config_dirs(config)
-        orm_config = Orm::Config.new(config)
+        orm_config = Orm::Config.new(@cfg, @output, self, config)
         n = orm_config.project_root_name
         @dirs[n] ||= []
         orm_config.offset = @dirs[n].size + 1 if @dirs[n].size > 0
@@ -72,23 +109,6 @@ module Vagrant
         nil
       end
 
-      def get_config_without_offset(name)
-        tmp = name.split("_")
-        if tmp.size > 1
-          n = tmp.first
-          o = tmp.last.to_i - 1
-          if @dirs.include?(n)
-            return @dirs[n][o]
-          end
-        # elsif @dirs[n].nil?
-          # puts @dirs.inspect
-        else
-          n = name
-          return @dirs[n].first
-        end
-        nil
-      end
-
     end
   end
 end

data/lib/vagrant/tools/version.rb

@@ -1,5 +1,5 @@
 module Vagrant
   module Tools
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/lib/vagrant/tools.rb

@@ -2,6 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + "/tools/config")
 require File.expand_path(File.dirname(__FILE__) + "/tools/cache")
 require File.expand_path(File.dirname(__FILE__) + "/tools/root")
 require File.expand_path(File.dirname(__FILE__) + "/tools/version")
+require File.expand_path(File.dirname(__FILE__) + "/tools/output")
 require File.expand_path(File.dirname(__FILE__) + "/tools/helper")
 require File.expand_path(File.dirname(__FILE__) + "/tools/orm/config")
 require File.expand_path(File.dirname(__FILE__) + "/tools/orm/machine")

data/vagrant-tools.gemspec

@@ -8,9 +8,9 @@ Gem::Specification.new do |spec|
   spec.version       = Vagrant::Tools::VERSION
   spec.authors       = ["Dennis Blommesteijn"]
   spec.email         = ["dennis@blommesteijn.com"]
-  spec.summary       = %q{Tools for Vagrant}
-  spec.description   = %q{Tools for Vagrant}
-  spec.homepage      = ""
+  spec.summary       = %q{Vagrant CLI configuration management tool for Unix}
+  spec.description   = %q{Vagrant CLI configuration management tool for Unix}
+  spec.homepage      = "https://github.com/dblommesteijn/vagrant-tools"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Dennis Blommesteijn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-06 00:00:00.000000000 Z
+date: 2014-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sys-proctable
@@ -52,7 +52,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Tools for Vagrant
+description: Vagrant CLI configuration management tool for Unix
 email:
 - dennis@blommesteijn.com
 executables:
@@ -75,10 +75,11 @@ files:
 - lib/vagrant/tools/orm/config.rb
 - lib/vagrant/tools/orm/machine.rb
 - lib/vagrant/tools/orm/provider.rb
+- lib/vagrant/tools/output.rb
 - lib/vagrant/tools/root.rb
 - lib/vagrant/tools/version.rb
 - vagrant-tools.gemspec
-homepage: ''
+homepage: https://github.com/dblommesteijn/vagrant-tools
 licenses:
 - MIT
 metadata: {}
@@ -101,5 +102,5 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Tools for Vagrant
+summary: Vagrant CLI configuration management tool for Unix
 test_files: []