linecook 0.6.2 → 1.0.0

data/lib/linecook/commands/init.rb

@@ -1,4 +1,5 @@
 require 'linecook/commands/command'
+require 'linecook/utils'
 require 'fileutils'
 require 'erb'
 require 'ostruct'
@@ -6,7 +7,7 @@ require 'ostruct'
 module Linecook
   module Commands
     
-    # ::desc init a linecook scaffold
+    # :startdoc::desc create a linecook scaffold
     #
     # Initializes a linecook scaffold in the specified directory.  This
     # initializer is currently very basic; it is not a true generator.
@@ -42,7 +43,10 @@ module Linecook
       
       def template(project_dir, project_name=nil)
         project_name ||= File.basename(project_dir)
-        context = OpenStruct.new(:project_name => project_name).send(:binding)
+        context = OpenStruct.new(
+          :project_name => project_name,
+          :const_name => Utils.camelize(project_name)
+        ).send(:binding)
         
         #
         # Copy template files into place
@@ -71,10 +75,10 @@ module Linecook
           end
         end
 
-        # Link up scripts into vbox
-        source = File.join(project_dir, 'scripts')
-        target = File.join(project_dir, 'vbox/scripts')
-        FileUtils.ln_s source, target
+        # Link up project dir into test
+        target = File.join(project_dir, 'test', "#{project_name}_test", "test_#{project_name}")
+        FileUtils.mkdir_p File.dirname(target)
+        FileUtils.ln_s project_dir, target
       end
     end
   end

data/lib/linecook/commands/package.rb

@@ -1,38 +1,56 @@
 require 'linecook/commands/command'
 require 'linecook/cookbook'
-require 'linecook/recipe'
+require 'linecook/package'
+require 'fileutils'
 require 'yaml'
 
 module Linecook
   module Commands
     
-    # ::desc generates a package
+    # :startdoc::desc generates a package
     #
-    # Generates a package.
+    # Generates the package specified at
+    # 'project_dir/packages/package_name.yml'.  The package file should be a
+    # YAML files that specifies a package env.  The full path to package file
+    # can be given instead of package name using the --file option.
     #
+    # If a cookbook file is present in the project_dir then it will be used to
+    # resolve resources available to the package.  See the env command to
+    # interrogate a package env.
     class Package < Command
-      config :cookbook_dir, '.', :short => :d       # the cookbook directory
-      config :force, false, :short => :f, &c.flag   # force creation
+      config :project_dir, '.', :short => :d              # the project directory
+      config :force, false, :short => :f, &c.flag         # force creation
+      config :quiet, false, &c.flag                       # silence output
       
-      def process(source, target=nil)
-        target ||= default_target(source)
+      def process(package_file, package_dir=nil)
+        package_dir ||= default_package_dir(package_file)
+        package_dir = File.expand_path(package_dir)
+        package = Linecook::Package.init(package_file, project_dir)
         
-        if File.exists?(target)
-          if force
-            FileUtils.rm_r(target)
-          else
-            raise "already exists: #{target}"
-          end
+        dependencies = package_dependencies(package) + [package_file]
+        if force || !FileUtils.uptodate?(package_dir, dependencies)
+          package.build
+          package.export(package_dir)
+          $stdout.puts package_dir unless quiet
         end
         
-        log :create, File.basename(target)
+        package_dir
+      end
+      
+      def package_dependencies(package)
+        dependencies = []
+        package.manifest.values.collect do |resources|
+          dependencies.concat resources.values
+        end
         
-        env = Linecook::Cookbook.init(cookbook_dir).env(source)
-        Linecook::Recipe.build(env).export(target)
+        $LOAD_PATH.each do |path|
+          dependencies.concat Dir.glob("#{path}/**/*.rb")
+        end
+        dependencies
       end
       
-      def default_target(source)
-        source.chomp(File.extname(source))
+      def default_package_dir(package_file)
+        package_file.chomp(File.extname(package_file))
       end
     end
   end

data/lib/linecook/commands/run.rb

@@ -0,0 +1,66 @@
+require 'linecook/commands/command'
+require 'linecook/commands/build'
+
+module Linecook
+  module Commands
+    
+    # :startdoc::desc run packages
+    class Run < Command
+      RUN_SCRIPT = File.expand_path('../../../../bin/linecook_run', __FILE__)
+      SCP_SCRIPT = File.expand_path('../../../../bin/linecook_scp', __FILE__)
+      
+      config :project_dir, '.', :short => :d                 # the project directory
+      config :remote_dir, 'linecook', :short => :D           # the remote package dir
+      config :ssh_config_file, 'config/ssh', :short => :F    # the ssh config file
+      config :quiet, false, :short => :q, &c.flag            # silence output
+      config :transfer, true, &c.switch                      # transfer package (or not)
+      config :remote_scripts, ['run'], 
+        :short => :S, 
+        :long => :remote_script, &c.list                     # the remote script(s)
+      
+      def glob_package_dirs(package_names)
+        if package_names.empty?
+          pattern = File.expand_path('packages/*', project_dir)
+          Dir.glob(pattern).select {|path| File.directory?(path) }
+        else
+          package_names.collect do |package_name|
+            File.expand_path("packages/#{package_name}", project_dir)
+          end
+        end
+      end
+      
+      def process(*package_names)
+        package_dirs  = glob_package_dirs(package_names)
+        
+        unless remote_dir[0] == ?/
+          self.remote_dir = "$(pwd)/#{remote_dir}"
+          self.remote_dir.chomp!('/')
+        end
+        
+        opts = {
+          'D' => remote_dir,
+          'F' => ssh_config_file
+        }
+        
+        if transfer
+          sh! "sh #{SCP_SCRIPT} #{format(opts)} #{package_dirs.join(' ')}"
+        end
+
+        remote_scripts.each do |remote_script|
+          script_opts = {'S' => remote_script}.merge(opts)
+          sh! "sh #{RUN_SCRIPT} #{format(script_opts)} #{package_dirs.join(' ')}"
+        end
+      end
+      
+      def format(opts)
+        options = []
+        
+        opts.each_pair do |key, value|
+          options << "-#{key} '#{value}'"
+        end
+        
+        options.sort.join(' ')
+      end
+    end
+  end
+end

data/lib/linecook/commands/snapshot.rb

@@ -0,0 +1,114 @@
+require 'linecook/commands/vbox_command'
+
+module Linecook
+  module Commands
+    
+    # :startdoc::desc take a vm snapshop
+    #
+    # Takes the specified snapshot of one or more VirtualBox virtual machines.
+    # By default all virtual machines configured in config/ssh will have a
+    # snapshot taken.  If the snapshot name is already taken, the previous
+    # snapshot will be renamed.
+    #
+    # Snapshot can also reset a hierarchy of renamed snapshots using the
+    # --reset flag. For example, if there exists a snapshot 'CURRENT' then
+    # these command will leave you with snapshots CURRENT_0 (the original),
+    # CURRENT_1, and CURRENT (the latest):
+    #
+    #   linecook snapshot CURRENT
+    #   linecook snapshot CURRENT
+    #
+    # To reset:
+    #
+    #   liencook 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
+      
+      def process(snapshot, *hosts)
+        vm_names = resolve_vm_names(hosts)
+        each_vm_name(vm_names) do |vm_name|
+          if reset
+            reset_snapshot(vm_name, snapshot)
+          else
+            snapshot(vm_name, snapshot)
+          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}"
+      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
+  end
+end

data/lib/linecook/commands/ssh.rb

@@ -0,0 +1,39 @@
+require 'linecook/commands/vbox_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
+      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)
+        # Some hackery going on here. On Mac OS X Leopard (10.5), exec fails
+        # (GH-51). As a workaround, we fork and wait. On all other platforms, we
+        # simply exec.
+
+        platform = RUBY_PLATFORM.to_s.downcase
+        pid = nil
+        pid = fork if platform.include?("darwin9") || platform.include?("darwin8")
+        Kernel.exec(ssh)  if pid.nil?
+        Process.wait(pid) if pid
+
+        exit $?.exitstatus
+      end
+    end
+  end
+end

data/lib/linecook/commands/start.rb

@@ -0,0 +1,34 @@
+require 'linecook/commands/vbox_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
+      
+      def process(*hosts)
+        vm_names = resolve_vm_names(hosts)
+        each_vm_name(vm_names) do |vm_name|
+          if running?(vm_name)
+            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
+        end
+      end
+    end
+  end
+end

data/lib/linecook/commands/state.rb

@@ -0,0 +1,32 @@
+require 'linecook/commands/vbox_command'
+
+module Linecook
+  module Commands
+    
+    # :startdoc::desc print the 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
+      
+      def state(vm_name)
+        running?(vm_name) ? "running" : "stopped"
+      end
+      
+      def process(*hosts)
+        vm_names = resolve_vm_names(hosts)
+        if hosts
+          each_host(vm_names) do |host|
+            puts "#{host}: #{state(host_map[host])}"
+          end
+        else
+          each_vm_name(vm_names) do |vm_name|
+            puts "#{vm_name}: #{state(vm_name)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linecook/commands/stop.rb

@@ -0,0 +1,22 @@
+require 'linecook/commands/vbox_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
+      def process(*hosts)
+        vm_names = resolve_vm_names(hosts)
+        each_vm_name(vm_names) do |vm_name|
+          if running?(vm_name)
+            stop(vm_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linecook/commands/vbox_command.rb

@@ -0,0 +1,130 @@
+require 'linecook/commands/command'
+
+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
+      
+      # Matches a host declaration in a ssh config file. After the match:
+      #
+      #   $1:: The host name
+      #        (ex: 'Host name' => 'name')
+      #   $2:: The vm name (if present)
+      #        (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:
+      #
+      #   Host name
+      #
+      # Normally the vm_name is the same as the host name, but an alternate can
+      # be specified as a comment in the form:
+      #
+      #   Host name # [vm_name]
+      #
+      def load_hosts(ssh_config_file)
+        hosts = []
+        
+        File.open(ssh_config_file) do |io|
+          io.each_line do |line|
+            next unless line =~ HOST_REGEXP
+            next if $2 && $2.strip.empty?
+            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] }
+      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
+    end
+  end
+end