linecook 1.2.1 → 2.0.0

data/lib/linecook/commands/snapshot.rb

@@ -1,8 +1,8 @@
-require 'linecook/commands/vbox_command'
+require 'linecook/commands/virtual_box_command'
 
 module Linecook
   module Commands
-    
+
     # :startdoc::desc take a vm snapshop
     #
     # Takes the specified snapshot of one or more VirtualBox virtual machines.
@@ -20,14 +20,14 @@ module Linecook
     #
     # To reset:
     #
-    #   liencook snapshot --reset CURRENT
+    #   linecook snapshot --reset CURRENT
     #
     # After which there will only be a single 'CURRENT' snapshot, which
     # corresponds to the original snapshot.
     #
-    class Snapshot < VboxCommand
-      config :reset, false, :long => :reset, &c.flag  # reset a snapshot
-      
+    class Snapshot < VirtualBoxCommand
+      config :reset, false    # -r, --reset : reset a snapshot
+
       def process(snapshot, *hosts)
         vm_names = resolve_vm_names(hosts)
         each_vm_name(vm_names) do |vm_name|
@@ -38,75 +38,75 @@ module Linecook
           end
         end
       end
-      
+
       def parse_snapshots(vm_name)
         info = `VBoxManage -q showvminfo #{vm_name}`
         snapshots = {}
-        
+
         stack = [{}]
         parent  = nil
-        
+
         info.each_line do |line|
           next unless line =~ /^(\s+)Name\: (.*?) \(/
           depth = $1.length / 3
           name = $2
-          
+
           if depth > stack.length
             stack.push stack.last[parent]
           elsif depth < stack.length
             stack.pop
           end
-          
+
           snapshot = {}
           snapshots[name]  = snapshot
           stack.last[name] = snapshot
           parent = name
         end
-        
+
         snapshots
       end
-      
+
       def reset_snapshot(vm_name, snapshot)
         stop(vm_name) if running?(vm_name)
-        
+
         snapshot = snapshot.upcase
         restore(vm_name, snapshot)
-        
+
         snapshots = parse_snapshots(vm_name)
         parent = snapshots.keys.select {|key| key =~ /\A#{snapshot}(?:_\d+)\z/ }.first
         parent ||= snapshot
-        
+
         children = snapshots[parent]
         children.each do |key, value|
           inside_out_each(key, value) do |child|
             sh! "VBoxManage -q snapshot #{vm_name} delete #{child}"
           end
         end
-        
+
         unless parent == snapshot
           sh! "VBoxManage -q snapshot #{vm_name} edit #{parent} --name #{snapshot}"
         end
       end
-      
+
       def snapshot(vm_name, snapshot)
         snapshot = snapshot.upcase
         snapshots = parse_snapshots(vm_name)
-        
+
         count = snapshots.keys.grep(/\A#{snapshot}(?:_|\z)/).length
         if count > 0
           sh! "VBoxManage -q snapshot #{vm_name} edit #{snapshot} --name #{snapshot}_#{count - 1}"
         end
-        
-        sh! "VBoxManage -q snapshot #{vm_name} take #{snapshot}"
+
+        sh! "VBoxManage -q snapshot #{vm_name} take #{snapshot} --pause"
       end
-      
+
       private
-      
+
       def inside_out_each(key, value, &block) # :nodoc:
         value.each_pair do |k, v|
           inside_out_each(k, v, &block)
         end
-        
+
         yield(key)
       end
     end

data/lib/linecook/commands/ssh.rb

@@ -1,24 +1,24 @@
-require 'linecook/commands/vbox_command'
+require 'linecook/commands/virtual_box_command'
 
 module Linecook
   module Commands
-    
+
     # :startdoc::desc ssh to a vm
     #
     # Connects to a virtual machine using ssh, as configured in config/ssh.
-    # 
-    class Ssh < VboxCommand
+    #
+    class Ssh < VirtualBoxCommand
       undef_config :names
-      
+
       def default_host
         load_hosts(ssh_config_file).collect {|host, vm_name| host }.first
       end
-      
+
       def process(host=default_host)
         if host.to_s.strip.empty?
           raise CommandError.new("no host specified")
         end
-        
+
         ssh = "ssh -F '#{ssh_config_file}' '#{host}' --"
 
         # Patterned after vagrant/ssh.rb (circa 0.6.6)

data/lib/linecook/commands/start.rb

@@ -1,18 +1,18 @@
-require 'linecook/commands/vbox_command'
+require 'linecook/commands/virtual_box_command'
 
 module Linecook
   module Commands
-    
+
     # :startdoc::desc start a vm
     #
     # Starts one or more VirtualBox virtual machines, and resets to a snapshot
     # if provided. By default all virtual machines configured in config/ssh
     # will be reset and started in this way.
-    class Start < VboxCommand
-      config :type, 'headless'             # vm type (headless|gui)
-      config :snapshot, '', :short => :s   # start snapshot
-      config :socket, false, &c.flag
-      
+    class Start < VirtualBoxCommand
+      config :type, 'headless'          # vm type (headless|gui)
+      config :snapshot, ''              # start snapshot
+      config :use_master_socket, false  # -m, --master-socket : use a master socket
+
       def process(*hosts)
         vm_names = resolve_vm_names(hosts)
         each_vm_name(vm_names) do |vm_name|
@@ -20,13 +20,13 @@ module Linecook
             stop(vm_name)
             sleep 0.5
           end
-          
+
           unless snapshot.empty?
             restore(vm_name, snapshot)
           end
-          
+
           start(vm_name, type)
-          start_ssh_socket(vm_name) if socket
+          start_ssh_socket(vm_name) if use_master_socket
         end
       end
     end

data/lib/linecook/commands/state.rb

@@ -1,20 +1,20 @@
-require 'linecook/commands/vbox_command'
+require 'linecook/commands/virtual_box_command'
 
 module Linecook
   module Commands
-    
-    # :startdoc::desc print the vm state
+
+    # :startdoc::desc print a vm state
     #
     # Prints the state of one or more VirtualBox virtual machines. By default
     # all virtual machines configured in config/ssh will print their state.
     #
-    class State < VboxCommand
-      config :hosts, false, :short => :n, &c.flag   # print state by host
-      
+    class State < VirtualBoxCommand
+      config :hosts, false       # -s, --hosts : print state by host
+
       def state(vm_name)
         `VBoxManage showvminfo #{vm_name}` =~ /^State:\s+(.*)$/ ? $1 : 'unknown'
       end
-      
+
       def process(*hosts)
         vm_names = resolve_vm_names(hosts)
         if hosts

data/lib/linecook/commands/stop.rb

@@ -1,14 +1,14 @@
-require 'linecook/commands/vbox_command'
+require 'linecook/commands/virtual_box_command'
 
 module Linecook
   module Commands
-    
+
     # :startdoc::desc stop a vm
     #
     # Stops one or more VirtualBox virtual machines using 'poweroff'.  By
     # default all virtual machines configured in config/ssh will be stopped.
     #
-    class Stop < VboxCommand
+    class Stop < VirtualBoxCommand
       def process(*hosts)
         vm_names = resolve_vm_names(hosts)
         each_vm_name(vm_names) do |vm_name|

data/lib/linecook/commands/{vbox_command.rb → virtual_box_command.rb}

@@ -1,14 +1,16 @@
-require 'linecook/commands/command'
+require 'linecook/command'
+require 'linecook/command_utils'
 
 module Linecook
   module Commands
-    class VboxCommand < Command
-      registry.delete_if {|key, value| value == self }
-      
-      config :ssh_config_file, 'config/ssh', :writer => false # the ssh config file
-      config :quiet, false, &c.flag                           # silence output
-      config :names, false, &c.flag                           # use vm names
-      
+    class VirtualBoxCommand < Command
+      include CommandUtils
+
+      config :ssh_config_file, 'config/ssh', {   # -F FILE : the ssh config file
+        :writer => :ssh_config_file= 
+      }
+      config :names, false                       # -n, --names : use vm names
+
       # Matches a host declaration in a ssh config file. After the match:
       #
       #   $1:: The host name
@@ -17,7 +19,7 @@ module Linecook
       #        (ex: 'Host name # [vm_name]' => 'vm_name')
       #
       HOST_REGEXP = /^\s*Host\s+([^\s#]+)(?:\s*#\s*\[(.*?)\])?/
-      
+
       # Returns a hash of (host, vm_name) pairs as declared in a ssh config
       # file.  Basically this means parsing out the name in each config like:
       #
@@ -30,7 +32,7 @@ module Linecook
       #
       def load_hosts(ssh_config_file)
         hosts = []
-        
+
         File.open(ssh_config_file) do |io|
           io.each_line do |line|
             next unless line =~ HOST_REGEXP
@@ -38,90 +40,90 @@ module Linecook
             hosts << [$1, $2 || $1]
           end
         end
-        
+
         hosts
       end
-      
+
       def ssh_config_file=(ssh_config_file)
         @ssh_config_file = ssh_config_file
         @host_list = nil
         @host_map  = nil
       end
-      
+
       def host_list
         @host_list ||= load_hosts(ssh_config_file)
       end
-      
+
       def host_map
         @host_map ||= Hash[*host_list.flatten]
       end
-      
+
       def resolve_vm_names(hosts)
         names ? hosts : hosts.collect {|host| host_map[host] || host }
       end
-      
+
       def each_host(hosts=[])
         if hosts.empty?
           hosts = host_list.collect {|host, vm_name| host }
           hosts.delete('*')
         end
-        
+
         hosts.uniq.each do |host|
           yield(host)
         end
       end
-      
+
       def each_vm_name(vm_names=[])
         if vm_names.empty?
           vm_names = host_list.collect {|host, vm_name| vm_name }
           vm_names.delete('*')
         end
-        
+
         vm_names.uniq.each do |vm_name|
           yield(vm_name)
         end
       end
-      
+
       def ssh(host, cmd)
         sh "ssh -q -F '#{ssh_config_file}' '#{host}' -- #{cmd}"
       end
-      
+
       def ssh!(host, cmd)
         unless ssh(host, cmd)
           raise CommandError, "non-zero exit status: #{$?.exitstatus}"
         end
       end
-      
+
       def running?(vm_name)
         `VBoxManage -q list runningvms`.include?(vm_name)
       end
-      
+
       def start(vm_name, type='headless')
         sh! "VBoxManage -q startvm #{vm_name} --type #{type}"
       end
-      
+
       def stop(vm_name)
         sh! "VBoxManage -q controlvm #{vm_name} poweroff"
       end
-      
+
       def restore(vm_name, snapshot)
         sh! "VBoxManage -q snapshot #{vm_name} restore #{snapshot.upcase}"
       end
-      
+
       def discardstate(vm_name)
         sh! "VBoxManage discardstate #{vm_name}"
       end
-      
+
       def share(vm_name, name, local_dir, remote_dir)
         share_dir = "#{local_dir}/#{vm_name}"
         FileUtils.mkdir_p(share_dir) unless File.exists?(share_dir)
-        
+
         ssh vm_name, "sudo umount '#{remote_dir}' > /dev/null 2>&1"
         sh "VBoxManage sharedfolder remove '#{vm_name}' --name '#{name}' --transient > /dev/null 2>&1"
         sh! "VBoxManage sharedfolder add '#{vm_name}' --name '#{name}' --hostpath '#{share_dir}' --transient"
         ssh! vm_name, "sudo mount -t vboxsf -o uid=1000,gid=100 '#{name}' '#{remote_dir}'"
       end
-      
+
       def start_ssh_socket(vm_name)
         sh "ssh -MNf -F '#{ssh_config_file}' '#{vm_name}' >/dev/null 2>&1 </dev/null"
       end

data/lib/linecook/cookbook.rb

@@ -1,160 +1,178 @@
-require 'linecook/utils'
-require 'lazydoc'
-
 module Linecook
   class Cookbook
     class << self
-      def config_file(project_dir='.')
-        Dir.glob(File.join(project_dir, '{C,c}ookbook')).first
-      end
-      
-      def setup(config={}, project_dir='.')
-        unless config.kind_of?(Hash)
-          config = Utils.load_config(config)
-        end
-        
-        config[PATHS_KEY] ||= [project_dir]
-        config[GEMS_KEY]  ||= gems
-        
-        new(config, project_dir)
+      attr_writer :default_path_map
+      def default_path_map
+        @default_path_map ||= {
+          :attributes => ['attributes'],
+          :files      => ['files'],
+          :templates  => ['templates'],
+          :recipes    => ['recipes']
+        }
       end
-      
-      def init(project_dir='.')
-        setup config_file(project_dir), project_dir
+
+      attr_writer :default_file_name
+      def default_file_name
+        @default_file_name ||= 'cookbook.yml'
       end
-      
-      def gems
+
+      def gemspecs(latest=true)
         return [] unless Object.const_defined?(:Gem)
-        
-        Gem.source_index.latest_specs.select do |spec|
-          config_file(spec.full_gem_path) != nil
-        end.collect do |spec|
-          spec.name
+
+        index = Gem.source_index
+        specs = latest ? index.latest_specs : index.gems.values
+
+        specs.select do |spec|
+          cookbook_file = File.expand_path(default_file_name, spec.full_gem_path)
+          File.exists?(cookbook_file)
         end
       end
     end
-    
-    MANIFEST_KEY  = 'manifest'
-    PATHS_KEY     = 'paths'
-    GEMS_KEY      = 'gems'
-    REWRITE_KEY   = 'rewrite'
-    
-    PATTERNS  = [
-      ['attributes', '**/*{.rb,.yaml,.yml,.json}', true],
-      ['files',      '**/*'],
-      ['recipes',    '**/*.rb', true],
-      ['templates',  '**/*']
-    ]
-    
-    attr_reader :project_dir
-    attr_reader :config
-    
-    def initialize(config={}, project_dir='.')
-      @project_dir = project_dir
-      @config = config
-    end
-    
-    def paths
-      Utils.arrayify config[PATHS_KEY]
-    end
-    
-    def gems
-      Utils.arrayify config[GEMS_KEY]
-    end
-    
-    def rewrites
-      config[REWRITE_KEY]
+
+    attr_reader :registry
+
+    def initialize(*project_dirs)
+      @registry = {}
+      project_dirs.each do |dir|
+        case dir
+        when String then add(dir)
+        when Hash   then add('.', dir)
+        else add(*dir)
+        end
+      end
     end
-    
-    def overrides
-      config[MANIFEST_KEY]
+
+    # Returns an array of directories comprising the path for type.
+    def path(type)
+      registry[type] || []
     end
-    
-    def full_gem_paths
-      return [] if gems.empty?
-      specs = latest_specs
-      
-      gems.collect do |name| 
-        spec = specs[name] or raise "no such gem: #{name.inspect}"
-        spec.full_gem_path
+
+    def add(dir, path_map=nil)
+      resolve_path_map(dir, path_map).each_pair do |type, paths|
+        (registry[type] ||= []).concat(paths)
       end
     end
-    
-    def rewrite(manifest)
-      replacements = {}
-      
-      rewrites.each_pair do |pattern, substitution|
-        manifest.keys.each do |key|
-          replacement = key.sub(pattern, substitution)
-          next if key == replacement
-          raise "multiple replacements for: #{key}" if replacements.has_key?(key)
-          
-          replacements[key] = replacement
+
+    def rm(dir, path_map=nil)
+      resolve_path_map(dir, path_map).each_pair do |type, paths|
+        if current = registry[type]
+          current = current - paths
+          if current.empty?
+            registry.delete(type)
+          else
+            registry[type] = current
+          end
         end
-      end if rewrites
-      
-      replacements.each do |key, replacement|
-        manifest[replacement] = manifest.delete(key)
       end
-      
-      manifest
     end
-    
-    def glob(*paths)
-      manifest = Hash.new {|hash, key| hash[key] = {} }
-      
-      paths.each do |path|
-        PATTERNS.each do |(type, glob, chomp_extname)|
-          resource_dir = File.expand_path(File.join(path, type), project_dir)
-          pattern = File.join(resource_dir, glob)
-          
-          Dir.glob(pattern).each do |full_path|
-            next unless File.file?(full_path)
-            
-            name = relative_path(resource_dir, full_path)
-            name.chomp!(File.extname(full_path)) if chomp_extname
-            
-            manifest[type][name] = full_path
+
+    # Same as find but returns nil if no file can be found.
+    def _find_(type, filename, extnames=nil)
+      if type.nil? || filename.nil?
+        return nil
+      end
+
+      if absolute?(filename)
+        return File.exists?(filename) ? filename : nil
+      end
+
+      path(type).each do |dir|
+        each_full_path(dir, filename, extnames) do |full_path|
+          if File.exists?(full_path) && subpath?(dir, full_path)
+            return full_path
           end
         end
       end
-      
-      manifest
+
+      nil
+    end
+
+    # Searches for a file by expanding filename vs each directory in the path
+    # for type. The first existing full path is returned.  If an array of
+    # extnames is provided, then each extname is tried for each directory,
+    # much as with Kernal.require. Absolute paths that exists are returned
+    # directly.  Raises an error if the file cannot be found.
+    def find(type, source_name, extnames=nil)
+      _find_(type, source_name, extnames) or begin
+        case
+        when type.nil?
+          raise "could not find file: #{source_name.inspect} (nil type specified)"
+        when source_name.nil?
+          raise "could not find file: #{source_name.inspect}"
+        when absolute?(source_name)
+          raise "no such file: #{source_name.inspect}"
+        else
+          try_string = try_extnames?(source_name, extnames) ? " (tried #{extnames.join(', ')})" : nil
+          raise "could not find file: #{source_name.inspect}#{try_string}"
+        end
+      end
     end
-    
-    def manifest
-      manifest = glob(*(full_gem_paths + paths))
-      
-      if overrides
-        manifest = Utils.deep_merge(manifest, overrides)
+
+    protected
+
+    if Dir.pwd[0] == ?/
+      def absolute?(path)
+        path && path[0] == ?/
       end
-      
-      manifest.each_key do |key|
-        manifest[key] = rewrite manifest[key]
+    else
+      def absolute?(path)
+        path && path =~ /^[A-z]:\//
       end
-      
-      manifest
     end
-    
-    def merge(config={})
-      duplicate = dup
-      dup.config.merge!(config)
-      dup
+
+    def subpath?(dir, full_path)
+      full_path.index(dir) == 0
+    end
+
+    def try_extnames?(path, extnames)
+      extnames && File.extname(path).empty?
+    end
+
+    def each_full_path(dir, path, extnames=nil)
+      full_path = File.expand_path(path, dir)
+      yield full_path
+
+      if try_extnames?(path, extnames)
+        extnames.each do |extname|
+          full_path = File.expand_path("#{path}#{extname}", dir)
+          yield full_path
+        end
+      end
     end
-    
-    private
-    
-    def relative_path(dir, path) # :nodoc:
-      start = dir.length + 1
-      path[start, path.length - start]
+
+    def resolve_path_map(dir, path_map=nil)
+      path_map ||= self.class.default_file_name
+
+      case path_map
+      when Hash
+        expand_path_map(dir, path_map)
+      when String
+        cookbook_file = File.expand_path(path_map, dir)
+        path_map = File.exists?(cookbook_file) ? YAML.load_file(cookbook_file) : nil
+        path_map ||= self.class.default_path_map
+
+        unless path_map.kind_of?(Hash)
+          raise "could not load path map: #{cookbook_file.inspect} (does not load a Hash)"
+        end
+
+        expand_path_map(dir, path_map)
+      else
+        raise "could not resolve path map: #{path_map.inspect} (must be String, Hash, or nil)"
+      end
     end
-    
-    def latest_specs # :nodoc:
-      latest = {}
-      Gem.source_index.latest_specs.each do |spec|
-        latest[spec.name] = spec
+
+    def expand_path_map(dir, path_map)
+      results = Hash.new {|hash, key| hash[key] = [] }
+
+      path_map.each_pair do |type, paths|
+        unless paths.kind_of?(Array)
+          paths = [paths]
+        end
+        paths.each do |path|
+          results[type.to_sym] << File.expand_path(path, dir)
+        end
       end
-      latest
+      results
     end
   end
 end