fig18 0.1.39 → 0.1.40

data/lib/fig/options.rb

@@ -6,101 +6,238 @@ module Fig
     # todo should use treetop for these:
     package_name = descriptor =~ /^([^:\/]+)/ ? $1 : nil
     config_name = descriptor =~ /:([^:\/]+)/ ? $1 : nil
-    version_name = descriptor =~ /\/([^:\/]+)/ ? $1 : nil  
+    version_name = descriptor =~ /\/([^:\/]+)/ ? $1 : nil
     return package_name, config_name, version_name
   end
 
+  USAGE = <<EOF
+
+Usage: fig [--debug] [--update] [--config <config>] [--get <var> | --list | <package> | -- <command>]
+
+Relevant env vars: FIG_REMOTE_URL (required), FIG_HOME (path to local repository cache, defaults
+to $HOME/.fighome).
+
+EOF
+
+  LOG_LEVELS = %w[ off fatal error warn info debug all ]
+  LOG_ALIASES = { 'warning' => 'warn' }
+
+  # Returns hash of option values, the remainders of argv, and an exit code if
+  # full program processing occured in this method, otherwise nil.
   def parse_options(argv)
     options = {}
 
     parser = OptionParser.new do |opts|
-      opts.banner = "Usage: fig [--debug] [--update] [--config <config>] [--get <var> | --list | <package> | - <command>]"
-
+      opts.banner = USAGE
       opts.on('-?', '-h','--help','display this help text') do
-        puts opts
-	exit 1
-      end 
+        puts opts.help
+        puts "\n    --  end of fig options; everything following is a command to run in the fig environment.\n\n"
+        return nil, nil, 0
+      end
 
-      options[:debug] = false
-      opts.on('-d', '--debug', 'print debug info') { options[:debug] = true }
+      opts.on('-v', '--version', 'Print fig version') do
+        line = nil
 
-      options[:update] = false
-      opts.on('-u', '--update', 'check remote repository for updates') { options[:update] = true; options[:retrieve] = true }
+        begin
+          File.open(
+            "#{File.expand_path(File.dirname(__FILE__) + '/../../VERSION')}"
+          ) do |file|
+            line = file.gets
+          end
+        rescue
+          $stderr.puts 'Could not retrieve version number. Something has mucked with your gem install.'
+          return nil, nil, 1
+        end
 
-      options[:update_if_missing] = false
-      opts.on('-m', '--update-if-missing', 'check for updates only if package is missing locally') { options[:update_if_missing] = true; options[:retrieve] = true }
+        if line !~ /\d+\.\d+\.\d+/
+          $stderr.puts %Q<"#{line}" does not look like a version number. Something has mucked with your gem install.>
+          return nil, nil, 1
+        end
 
-      options[:config] = "default"
-      opts.on('-c', '--config CFG', 'name of configuration to apply') { |config| options[:config] = config }
+        puts File.basename($0) + ' v' + line
 
-      options[:echo] = nil
-      opts.on('-g', '--get VAR', 'print value of environment variable') { |echo| options[:echo] = echo }
+        return nil, nil, 0
+      end
 
-      options[:publish] = nil
-      opts.on('--publish PKG', 'install package in local and remote repositories') { |publish| options[:publish] = publish }
+      options[:modifiers] = []
+      opts.on(
+        '-p',
+        '--append VAR=VAL',
+        'append (actually, prepend) VAL to environment var VAR, delimited by separator'
+      ) do |var_val|
+        var, val = var_val.split('=')
+        options[:modifiers] << Path.new(var, val)
+      end
 
-      options[:publish_local] = nil
-      opts.on('--publish-local PKG', 'install package in local repositorie only') { |publish_local| options[:publish_local] = publish_local }
+      options[:archives] = []
+      opts.on(
+        '--archive FULLPATH',
+        'include FULLPATH archive in package (when using --publish)'
+      ) do |path|
+        options[:archives] << Archive.new(path)
+      end
 
-      options[:force] = nil
-      opts.on('--force', 'force overwriting of an existing remote package version') { |force| options[:force] = force }
+      options[:cleans] = []
+      opts.on('--clean PKG', 'remove package from $FIG_HOME') do |descriptor|
+        options[:cleans] << descriptor
+      end
 
-      options[:resources] =[]
-      opts.on('--resource PATH', 'resource to include in package (when using --publish)') do |path| 
-        options[:resources] << Resource.new(path) 
+      options[:config] = 'default'
+      opts.on(
+        '-c',
+        '--config CFG',
+        %q<apply configuration CFG, default is 'default'>
+      ) do |config|
+        options[:config] = config
       end
 
-      options[:archives] =[]
-      opts.on('--archive PATH', 'archive to include in package (when using --publish)') do |path| 
-        options[:archives] << Archive.new(path)
+      options[:debug] = false
+      opts.on('-d', '--debug', 'print debug info') do
+        options[:debug] = true
       end
 
-      options[:login] = false
-      opts.on('-l', '--login', 'login into the FTP server as a non-anonymous user') { options[:login] = true }
+      options[:input] = nil
+      opts.on(
+        '--file FILE',
+        %q<read fig file FILE. Use '-' for stdin. See also --no-file>
+      ) do |path|
+        options[:input] = path
+      end
+
+      options[:force] = nil
+      opts.on(
+        '--force',
+        'force-overwrite existing version of a package to the remote repo'
+      ) do |force|
+        options[:force] = force
+      end
+
+      options[:echo] = nil
+      opts.on(
+        '-g',
+        '--get VAR',
+        'print value of environment variable VAR'
+      ) do |echo|
+        options[:echo] = echo
+      end
+
+      opts.on(
+        '-i',
+        '--include PKG',
+        'include PKG (with any variable prepends) in environment'
+      ) do |descriptor|
+        package_name, config_name, version_name = parse_descriptor(descriptor)
+        options[:modifiers] << Include.new(package_name, config_name, version_name, {})
+      end
 
       options[:list] = false
-      opts.on('--list', 'list packages in local repository') { options[:list] = true }
+      opts.on('--list', 'list packages in $FIG_HOME') do
+        options[:list] = true
+      end
+
+      options[:list_configs] = []
+      opts.on(
+        '--list-configs PKG', 'list configurations in package'
+      ) do |descriptor|
+        options[:list_configs] << descriptor
+      end
 
       options[:list_remote] = false
-      opts.on('--list-remote', 'list packages in remote repository') { options[:list_remote] = true }
+      opts.on('--list-remote', 'list packages in remote repo') do
+        options[:list_remote] = true
+      end
 
-      options[:list_configs] = []
-      opts.on('--list-configs PKG', 'list configurations in package') { |descriptor| options[:list_configs] << descriptor }
+      options[:login] = false
+      opts.on(
+        '-l', '--login', 'login to remote repo as a non-anonymous user'
+      ) do
+        options[:login] = true
+      end
 
-      options[:cleans] = []
-      opts.on('--clean PKG', 'remove  package from local repository') { |descriptor| options[:cleans] <<  descriptor }
+      opts.on(
+        '--no-file', 'ignore package.fig file in current directory'
+      ) do |path|
+        options[:input] = :none
+      end
 
-      options[:modifiers] = []
+      options[:publish] = nil
+      opts.on(
+        '--publish PKG', 'install PKG in $FIG_HOME and in remote repo'
+      ) do |publish|
+        options[:publish] = publish
+      end
 
-      opts.on('-i', '--include PKG', 'include package in environment') do |descriptor| 
-        package_name, config_name, version_name = parse_descriptor(descriptor)
-        options[:modifiers] << Include.new(package_name, config_name, version_name, {}) 
+      options[:publish_local] = nil
+      opts.on(
+        '--publish-local PKG', 'install package only in $FIG_HOME'
+      ) do |publish_local|
+        options[:publish_local] = publish_local
       end
 
-#      opts.on('-o', '--override PKG', 'override version of included package') do |descriptor| 
-#        package_name, config_name, version_name = parse_descriptor(descriptor)
-#        options[:modifiers] << Include.new(package_name, config_name, version_name, {}) 
-#      end
+      options[:resources] =[]
+      opts.on(
+        '--resource FULLPATH',
+        'include FULLPATH resource in package (when using --publish)'
+      ) do |path|
+        options[:resources] << Resource.new(path)
+      end
 
-      opts.on('-s', '--set VAR=VAL', 'set environment variable') do |var_val| 
+      opts.on(
+        '-s', '--set VAR=VAL', 'set environment variable VAR to VAL'
+      ) do |var_val|
         var, val = var_val.split('=')
-        options[:modifiers] << Set.new(var, val) 
+        options[:modifiers] << Set.new(var, val)
       end
 
-      opts.on('-p', '--append VAR=VAL', 'append environment variable') do |var_val| 
-        var, val = var_val.split('=')
-        options[:modifiers] << Path.new(var, val)
+      options[:update] = false
+      opts.on(
+        '-u',
+        '--update',
+        'check remote repo for updates and download to $FIG_HOME as necessary'
+      ) do
+        options[:update] = true; options[:retrieve] = true
       end
 
-      options[:input] = nil
-      opts.on('--file FILE', 'fig file to read (use - for stdin)') { |path| options[:input] = path }
-      opts.on('--no-file', 'ignore package.fig file in current directory') { |path| options[:input] = :none }
+      options[:update_if_missing] = false
+      opts.on(
+        '-m',
+        '--update-if-missing',
+        'check remote repo for updates only if package missing from $FIG_HOME'
+      ) do
+        options[:update_if_missing] = true; options[:retrieve] = true
+      end
+
+      opts.on(
+        '--figrc PATH', 'add PATH to configuration used for Fig'
+      ) do |path|
+        options[:figrc] = path
+      end
+
+      opts.on('--no-figrc', 'ignore ~/.figrc') { options[:no_figrc] = true }
+
+      opts.on(
+        '--log-config PATH', 'use PATH file as configuration for Log4r'
+      ) do |path|
+        options[:log_config] = path
+      end
+
+      level_list = LOG_LEVELS.join(', ')
+      opts.on(
+        '--log-level LEVEL',
+        LOG_LEVELS,
+        LOG_ALIASES,
+        'set logging level to LEVEL',
+        "  (#{level_list})"
+      ) do |log_level|
+        options[:log_level] = log_level
+      end
 
-      options[:home] = ENV['FIG_HOME'] || File.expand_path("~/.fighome")
+      options[:home] = ENV['FIG_HOME'] || File.expand_path('~/.fighome')
     end
 
+    # Need to catch the exception thrown from parser and retranslate into a fig exception
     parser.parse!(argv)
 
-    return options, argv
+    return options, argv, nil
   end
 end

data/lib/fig/os.rb

@@ -10,23 +10,24 @@ require 'net/netrc'
 require 'tempfile'
 require 'highline/import'
 
-module Fig
-  class NotFoundException < Exception
-  end
+require 'fig/logging'
+require 'fig/networkerror'
+require 'fig/notfounderror'
 
+module Fig
   class OS
     def initialize(login)
       @login = login
-      @username = ENV["FIG_USERNAME"]
-      @password = ENV["FIG_PASSWORD"]
+      @username = ENV['FIG_USERNAME']
+      @password = ENV['FIG_PASSWORD']
     end
 
     def get_username()
-      @username ||= ask("Username: ") { |q| q.echo = true }
+      @username ||= ask('Username: ') { |q| q.echo = true }
     end
-    
+
     def get_password()
-      @password ||= ask("Password: ") { |q| q.echo = false }
+      @password ||= ask('Password: ') { |q| q.echo = false }
     end
 
     def ftp_login(ftp, host)
@@ -37,7 +38,7 @@ module Fig
           @password = rc.password
         end
         ftp.login(get_username, get_password)
-      else 
+      else
         ftp.login()
       end
       ftp.passive = true
@@ -46,36 +47,36 @@ module Fig
     def list(dir)
       Dir.entries(dir) - ['.','..']
     end
-    
+
     def exist?(path)
       File.exist?(path)
     end
-    
+
     def mtime(path)
       File.mtime(path)
     end
-    
+
     def read(path)
       File.read(path)
     end
-    
+
     def write(path, content)
-      File.open(path, "wb") { |f| f.binmode; f << content }
+      File.open(path, 'wb') { |f| f.binmode; f << content }
     end
-    
+
     SUCCESS = 0
     NOT_MODIFIED = 3
     NOT_FOUND = 4
-    
+
     def download_list(url)
       begin
         uri = URI.parse(url)
-      rescue 
-        $stderr.puts "Unable to parse url: '#{url}'"
-        exit 10
+      rescue
+        Logging.fatal %Q<Unable to parse url: "#{url}">
+        raise NetworkError.new
       end
       case uri.scheme
-      when "ftp"
+      when 'ftp'
         ftp = Net::FTP.new(uri.host)
         ftp_login(ftp, uri.host)
         ftp.chdir(uri.path)
@@ -83,12 +84,12 @@ module Fig
         ftp.close
 
         download_ftp_list(uri, dirs)
-      when "ssh"
+      when 'ssh'
         packages = []
         Net::SSH.start(uri.host, uri.user) do |ssh|
           ls = ssh.exec!("[ -d #{uri.path} ] && find #{uri.path}")
           if not ls.nil?
-            ls = ls.gsub(uri.path + "/", "").gsub(uri.path, "").split("\n")
+            ls = ls.gsub(uri.path + '/', '').gsub(uri.path, '').split("\n")
             ls.each do |line|
               parts = line.gsub(/\\/, '/').sub(/^\.\//, '').sub(/:$/, '').chomp().split('/')
               packages << parts.join('/') if parts.size == 2
@@ -97,16 +98,16 @@ module Fig
         end
         packages
       else
-        $stderr.puts "Protocol not supported: #{url}"
-        exit 10
+        Logging.fatal "Protocol not supported: #{url}"
+        raise NetworkError.new
       end
     end
 
     def download_ftp_list(uri, dirs)
       # Run a bunch of these in parallel since they're slow as hell
-      num_threads = (ENV["FIG_FTP_THREADS"] || "16").to_i
+      num_threads = (ENV['FIG_FTP_THREADS'] || '16').to_i
       threads = []
-      all_packages = []        
+      all_packages = []
       (0..num_threads-1).each { |num| all_packages[num] = [] }
       (0..num_threads-1).each do |num|
         threads << Thread.new do
@@ -137,46 +138,49 @@ module Fig
       FileUtils.mkdir_p(File.dirname(path))
       uri = URI.parse(url)
       case uri.scheme
-      when "ftp"
+      when 'ftp'
         ftp = Net::FTP.new(uri.host)
         ftp_login(ftp, uri.host)
         begin
           if File.exist?(path) && ftp.mtime(uri.path) <= File.mtime(path)
+            Logging.debug "#{path} is up to date."
             return false
-          else 
-            $stderr.puts "downloading #{url}"
+          else
+            log_download(url, path)
             ftp.getbinaryfile(uri.path, path, 256*1024)
             return true
           end
-        rescue Net::FTPPermError
-          raise NotFoundException.new
+        rescue Net::FTPPermError => e
+          Logging.warn e
+          raise NotFoundError.new
         end
-      when "http"
+      when 'http'
         http = Net::HTTP.new(uri.host)
-        $stderr.puts "downloading #{url}"
-        File.open(path, "wb") do |file|
+        log_download(url, path)
+        File.open(path, 'wb') do |file|
           file.binmode
           http.get(uri.path) do |block|
             file.write(block)
           end
         end
-      when "ssh"
+      when 'ssh'
         # TODO need better way to do conditional download
-        #       timestamp = `ssh #{uri.user + '@' if uri.user}#{uri.host} "ruby -e 'puts File.mtime(\\"#{uri.path}\\").to_i'"`.to_i
-        timestamp = File.exist?(path) ? File.mtime(path).to_i : 0 
+        timestamp = File.exist?(path) ? File.mtime(path).to_i : 0
+        # Requires that remote installation of fig be at the same location as the local machine.
         cmd = `which fig-download`.strip + " #{timestamp} #{uri.path}"
+        log_download(url, path)
         ssh_download(uri.user, uri.host, path, cmd)
       else
-        $stderr.puts "Unknown protocol: #{url}"
-        exit 10
+        Logging.fatal "Unknown protocol: #{url}"
+        raise NetworkError.new
       end
-   end
-    
+    end
+
     def download_resource(url, dir)
       FileUtils.mkdir_p(dir)
       download(url, File.join(dir, URI.parse(url).path.split('/').last))
     end
-    
+
     def download_archive(url, dir)
       FileUtils.mkdir_p(dir)
       basename = URI.parse(url).path.split('/').last
@@ -192,25 +196,25 @@ module Fig
       when /\.zip$/
         unpack_archive(dir, path)
       else
-        $stderr.puts "Unknown archive type: #{basename}"
-        exit 10
+        Logging.fatal "Unknown archive type: #{basename}"
+        raise NetworkError.new
       end
     end
-    
+
     def upload(local_file, remote_file, user)
-      puts "uploading #{local_file} to #{remote_file}"
+      Logging.debug "Uploading #{local_file} to #{remote_file}."
       uri = URI.parse(remote_file)
       case uri.scheme
-      when "ssh"
+      when 'ssh'
         ssh_upload(uri.user, uri.host, local_file, remote_file)
-      when "ftp"
+      when 'ftp'
         #      fail unless system "curl -T #{local_file} --create-dirs --ftp-create-dirs #{remote_file}"
        require 'net/ftp'
-        ftp_uri = URI.parse(ENV["FIG_REMOTE_URL"])
+        ftp_uri = URI.parse(ENV['FIG_REMOTE_URL'])
         ftp_root_path = ftp_uri.path
-        ftp_root_dirs = ftp_uri.path.split("/")
-        remote_publish_path = uri.path[0, uri.path.rindex("/")]
-        remote_publish_dirs = remote_publish_path.split("/")
+        ftp_root_dirs = ftp_uri.path.split('/')
+        remote_publish_path = uri.path[0, uri.path.rindex('/')]
+        remote_publish_dirs = remote_publish_path.split('/')
         # Use array subtraction to deduce which project/version folder to upload to,
         # i.e. [1,2,3] - [2,3,4] = [1]
         remote_project_dirs = remote_publish_dirs - ftp_root_dirs
@@ -231,26 +235,17 @@ module Fig
         end
       end
     end
-    
+
     def clear_directory(dir)
       FileUtils.rm_rf(dir)
       FileUtils.mkdir_p(dir)
     end
 
-    def exec(dir,command)
-      Dir.chdir(dir) {
-        unless system command
-          $stderr.puts "Command failed"
-          exit 10
-        end
-      }
-    end
-    
     def copy(source, target, msg = nil)
       if File.directory?(source)
         FileUtils.mkdir_p(target)
         Dir.foreach(source) do |child|
-          if child != "." and child != ".."
+          if child != '.' and child != '..'
             copy(File.join(source, child), File.join(target, child), msg)
           end
         end
@@ -267,9 +262,9 @@ module Fig
     def move_file(dir, from, to)
       Dir.chdir(dir) { FileUtils.mv(from, to, :force => true) }
     end
-    
+
     def log_info(msg)
-      $stderr.puts msg
+      Logging.info msg
     end
 
     # Expects files_to_archive as an Array of filenames.
@@ -339,8 +334,8 @@ module Fig
     end
 
     def shell_exec_windows(cmd)
-      #command = ["C:/WINDOWS/system32/cmd.exe", "/C", "call"] + cmd
-      command = ["cmd.exe", "/C"] + cmd
+      #command = ['C:/WINDOWS/system32/cmd.exe', '/C', 'call'] + cmd
+      command = ['cmd.exe', '/C'] + cmd
       command = command.join(' ')
       Kernel.exec(command)
     end
@@ -349,13 +344,13 @@ module Fig
     # cmd = The command to be run on the remote host.
     def ssh_download(user, host, path, cmd)
       return_code = nil
-      tempfile = Tempfile.new("tmp")
+      tempfile = Tempfile.new('tmp')
       Net::SSH.start(host, user) do |ssh|
         ssh.open_channel do |channel|
           channel.exec(cmd)
           channel.on_data() { |ch, data| tempfile << data }
-          channel.on_extended_data() { |ch, type, data| $stderr.puts "SSH Download ERROR: #{data}" }
-          channel.on_request("exit-status") { |ch, request|
+          channel.on_extended_data() { |ch, type, data| Logging.error "SSH Download ERROR: #{data}" }
+          channel.on_request('exit-status') { |ch, request|
             return_code = request.read_long
           }
         end
@@ -369,15 +364,14 @@ module Fig
         return false
       when NOT_FOUND
         tempfile.delete
-        $stderr.puts "File not found: #{path}"
-        exit 10
+        raise NotFoundError.new
       when SUCCESS
         FileUtils.mv(tempfile.path, path)
         return true
       else
         tempfile.delete
-        $stderr.puts "Unable to download file: #{return_code}"
-        exit 1
+        Logging.fatal "Unable to download file #{path}: #{return_code}"
+        raise NetworkError.new
       end
     end
 
@@ -392,5 +386,10 @@ module Fig
       end
     end
 
+    private
+
+    def log_download(url, path)
+      Logging.debug "Downloading #{url} to #{path}."
+    end
   end
 end