fig18 0.1.45-i386-mingw32

data/lib/fig/options.rb

@@ -0,0 +1,248 @@
+require 'optparse'
+require 'fig/package'
+require 'fig/package/archive'
+require 'fig/package/include'
+require 'fig/package/path'
+require 'fig/package/resource'
+require 'fig/package/set'
+
+module Fig
+  def parse_descriptor(descriptor)
+    # todo should use treetop for these:
+    package_name = descriptor =~ /^([^:\/]+)/ ? $1 : nil
+    config_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
+      opts.on('-?', '-h','--help','display this help text') do
+        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
+
+      opts.on('-v', '--version', 'Print fig version') do
+        line = nil
+
+        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
+
+        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
+
+        puts File.basename($0) + ' v' + line
+
+        return nil, nil, 0
+      end
+
+      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] << Package::Path.new(var, val)
+      end
+
+      options[:archives] = []
+      opts.on(
+        '--archive FULLPATH',
+        'include FULLPATH archive in package (when using --publish)'
+      ) do |path|
+        options[:archives] << Package::Archive.new(path)
+      end
+
+      options[:cleans] = []
+      opts.on('--clean PKG', 'remove package from $FIG_HOME') do |descriptor|
+        options[:cleans] << descriptor
+      end
+
+      options[:config] = 'default'
+      opts.on(
+        '-c',
+        '--config CFG',
+        %q<apply configuration CFG, default is 'default'>
+      ) do |config|
+        options[:config] = config
+      end
+
+      options[:debug] = false
+      opts.on('-d', '--debug', 'print debug info') do
+        options[:debug] = true
+      end
+
+      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] << Package::Include.new(package_name, config_name, version_name, {})
+      end
+
+      options[:list] = false
+      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 repo') do
+        options[:list_remote] = true
+      end
+
+      options[:login] = false
+      opts.on(
+        '-l', '--login', 'login to remote repo as a non-anonymous user'
+      ) do
+        options[:login] = true
+      end
+
+      opts.on(
+        '--no-file', 'ignore package.fig file in current directory'
+      ) do |path|
+        options[:input] = :none
+      end
+
+      options[:publish] = nil
+      opts.on(
+        '--publish PKG', 'install PKG in $FIG_HOME and in remote repo'
+      ) do |publish|
+        options[:publish] = publish
+      end
+
+      options[:publish_local] = nil
+      opts.on(
+        '--publish-local PKG', 'install package only in $FIG_HOME'
+      ) do |publish_local|
+        options[:publish_local] = publish_local
+      end
+
+      options[:resources] =[]
+      opts.on(
+        '--resource FULLPATH',
+        'include FULLPATH resource in package (when using --publish)'
+      ) do |path|
+        options[:resources] << Package::Resource.new(path)
+      end
+
+      opts.on(
+        '-s', '--set VAR=VAL', 'set environment variable VAR to VAL'
+      ) do |var_val|
+        var, val = var_val.split('=')
+        options[:modifiers] << Package::Set.new(var, val)
+      end
+
+      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[: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')
+    end
+
+    # Need to catch the exception thrown from parser and retranslate into a fig exception
+    parser.parse!(argv)
+
+    return options, argv, nil
+  end
+end

data/lib/fig/os.rb

@@ -0,0 +1,416 @@
+require 'fileutils'
+# Must specify absolute path of ::Archive when using
+# this module to avoid conflicts with Fig::Package::Archive
+require 'libarchive_ruby' unless RUBY_PLATFORM == 'java'
+require 'uri'
+require 'net/http'
+require 'net/ssh'
+require 'net/sftp'
+require 'net/netrc'
+require 'tempfile'
+require 'highline/import'
+
+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']
+    end
+
+    def get_username()
+      @username ||= ask('Username: ') { |q| q.echo = true }
+    end
+
+    def get_password()
+      @password ||= ask('Password: ') { |q| q.echo = false }
+    end
+
+    def ftp_login(ftp, host)
+      if @login
+        rc = Net::Netrc.locate(host)
+        if rc
+          @username = rc.login
+          @password = rc.password
+        end
+        ftp.login(get_username, get_password)
+      else
+        ftp.login()
+      end
+      ftp.passive = true
+    end
+
+    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 }
+    end
+
+    SUCCESS = 0
+    NOT_MODIFIED = 3
+    NOT_FOUND = 4
+
+    def strip_paths_for_list(ls_output, packages, path)
+      if not ls_output.nil?
+        ls_output = ls_output.gsub(path + '/', '').gsub(path, '').split("\n")
+        ls_output.each do |line|
+          parts = line.gsub(/\\/, '/').sub(/^\.\//, '').sub(/:$/, '').chomp().split('/')
+          packages << parts.join('/') if parts.size == 2
+        end
+      end
+    end
+
+    def download_list(url)
+      begin
+        uri = URI.parse(url)
+      rescue
+        Logging.fatal %Q<Unable to parse url: "#{url}">
+        raise NetworkError.new(%Q<Unable to parse url: "#{url}">)
+      end
+      case uri.scheme
+      when 'ftp'
+        ftp = Net::FTP.new(uri.host)
+        ftp_login(ftp, uri.host)
+        ftp.chdir(uri.path)
+        dirs = ftp.nlst
+        ftp.close
+
+        download_ftp_list(uri, dirs)
+      when 'ssh'
+        packages = []
+        Net::SSH.start(uri.host, uri.user) do |ssh|
+          ls = ssh.exec!("[ -d #{uri.path} ] && find #{uri.path}")
+          strip_paths_for_list(ls, packages, uri.path)
+        end
+        packages
+      when 'file'
+        packages = []
+        ls = %x<[ -d #{uri.path} ] && find #{uri.path}>
+        strip_paths_for_list(ls, packages, uri.path)
+        return packages
+      else
+        Logging.fatal "Protocol not supported: #{url}"
+        raise NetworkError.new("Protocol not supported: #{url}")
+      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
+      threads = []
+      all_packages = []
+      (0..num_threads-1).each { |num| all_packages[num] = [] }
+      (0..num_threads-1).each do |num|
+        threads << Thread.new do
+          packages = all_packages[num]
+          ftp = Net::FTP.new(uri.host)
+          ftp_login(ftp, uri.host)
+          ftp.chdir(uri.path)
+          pos = num
+          while pos < dirs.length
+            pkg = dirs[pos]
+            begin
+              ftp.nlst(dirs[pos]).each do |ver|
+                packages << pkg + '/' + ver
+              end
+            rescue Net::FTPPermError
+              # ignore
+            end
+            pos += num_threads
+          end
+          ftp.close
+        end
+      end
+      threads.each { |thread| thread.join }
+      all_packages.flatten.sort
+    end
+
+    def download(url, path)
+      FileUtils.mkdir_p(File.dirname(path))
+      uri = URI.parse(url)
+      case uri.scheme
+      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
+            log_download(url, path)
+            ftp.getbinaryfile(uri.path, path, 256*1024)
+            return true
+          end
+        rescue Net::FTPPermError => e
+          Logging.warn e
+          raise NotFoundError.new
+        end
+      when 'http'
+        http = Net::HTTP.new(uri.host)
+        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'
+        # TODO need better way to do conditional download
+        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)
+      when 'file'
+        begin
+          FileUtils.cp(uri.path, path)
+        rescue Errno::ENOENT => e
+          raise NotFoundError.new
+        end
+      else
+        Logging.fatal "Unknown protocol: #{url}"
+        raise NetworkError.new("Unknown protocol: #{url}")
+      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
+      path = File.join(dir, basename)
+      download(url, path)
+      case basename
+      when /\.tar\.gz$/
+        unpack_archive(dir, path)
+      when /\.tgz$/
+        unpack_archive(dir, path)
+      when /\.tar\.bz2$/
+        unpack_archive(dir, path)
+      when /\.zip$/
+        unpack_archive(dir, path)
+      else
+        Logging.fatal "Unknown archive type: #{basename}"
+        raise NetworkError.new("Unknown archive type: #{basename}")
+      end
+    end
+
+    def upload(local_file, remote_file, user)
+      Logging.debug "Uploading #{local_file} to #{remote_file}."
+      uri = URI.parse(remote_file)
+      case uri.scheme
+      when 'ssh'
+        ssh_upload(uri.user, uri.host, local_file, remote_file)
+      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_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('/')
+        # 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
+        Net::FTP.open(uri.host) do |ftp|
+          ftp_login(ftp, uri.host)
+          # Assume that the FIG_REMOTE_URL path exists.
+          ftp.chdir(ftp_root_path)
+          remote_project_dirs.each do |dir|
+            # Can't automatically create parent directories, so do it manually.
+           if ftp.nlst().index(dir).nil?
+             ftp.mkdir(dir)
+             ftp.chdir(dir)
+           else
+             ftp.chdir(dir)
+           end
+          end
+          ftp.putbinaryfile(local_file)
+        end
+      when 'file'
+        FileUtils.mkdir_p(File.dirname(uri.path))
+        FileUtils.cp(local_file, uri.path)
+      else
+        Logging.fatal "Unknown protocol: #{uri}"
+        raise NetworkError.new("Unknown protocol: #{uri}")
+      end
+    end
+
+    def clear_directory(dir)
+      FileUtils.rm_rf(dir)
+      FileUtils.mkdir_p(dir)
+    end
+
+    def copy(source, target, msg = nil)
+      if File.directory?(source)
+        FileUtils.mkdir_p(target)
+        Dir.foreach(source) do |child|
+          if child != '.' and child != '..'
+            copy(File.join(source, child), File.join(target, child), msg)
+          end
+        end
+      else
+        if !File.exist?(target) || File.mtime(source) != File.mtime(target)
+          log_info "#{msg} #{target}" if msg
+          FileUtils.mkdir_p(File.dirname(target))
+          FileUtils.cp(source, target)
+          File.utime(File.atime(source), File.mtime(source), target)
+        end
+      end
+    end
+
+    def move_file(dir, from, to)
+      Dir.chdir(dir) { FileUtils.mv(from, to, :force => true) }
+    end
+
+    def log_info(msg)
+      Logging.info msg
+    end
+
+    # Expects files_to_archive as an Array of filenames.
+    def create_archive(archive_name, files_to_archive)
+      if OS.java?
+        `tar czvf #{archive_name} #{files_to_archive.join(' ')}`
+      else
+        # TODO: Need to verify files_to_archive exists.
+        ::Archive.write_open_filename(archive_name, ::Archive::COMPRESSION_GZIP, ::Archive::FORMAT_TAR) do |ar|
+          files_to_archive.each do |fn|
+            ar.new_entry do |entry|
+              entry.copy_stat(fn)
+              entry.pathname = fn
+              ar.write_header(entry)
+              if !entry.directory?
+                ar.write_data(open(fn) {|f| f.binmode; f.read })
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # This method can handle the following archive types:
+    # .tar.bz2
+    # .tar.gz
+    # .tgz
+    # .zip
+    def unpack_archive(dir, file)
+      Dir.chdir(dir) do
+        if OS.java?
+          `tar xzvf #{file}`
+        else
+          ::Archive.read_open_filename(file) do |ar|
+            while entry = ar.next_header
+              ar.extract(entry)
+            end
+          end
+        end
+      end
+    end
+
+    def self.windows?
+      Config::CONFIG['host_os'] =~ /mswin|mingw/
+    end
+
+    def self.java?
+      RUBY_PLATFORM == 'java'
+    end
+
+    def self.unix?
+      !windows?
+    end
+
+    def shell_exec(cmd)
+      if OS.windows?
+        Windows.shell_exec_windows(cmd)
+      else
+        shell_exec_unix(cmd)
+      end
+    end
+
+    private
+
+    def shell_exec_unix(cmd)
+      Kernel.exec(ENV['SHELL'], '-c', cmd.join(' '))
+    end
+
+    def shell_exec_windows(cmd)
+      #command = ['C:/WINDOWS/system32/cmd.exe', '/C', 'call'] + cmd
+      command = ['cmd.exe', '/C'] + cmd
+      command = command.join(' ')
+      Kernel.exec(command)
+    end
+
+    # path = The local path the file should be downloaded to.
+    # cmd = The command to be run on the remote host.
+    def ssh_download(user, host, path, cmd)
+      return_code = nil
+      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| Logging.error "SSH Download ERROR: #{data}" }
+          channel.on_request('exit-status') { |ch, request|
+            return_code = request.read_long
+          }
+        end
+      end
+
+      tempfile.close()
+
+      case return_code
+      when NOT_MODIFIED
+        tempfile.delete
+        return false
+      when NOT_FOUND
+        tempfile.delete
+        raise NotFoundError.new
+      when SUCCESS
+        FileUtils.mv(tempfile.path, path)
+        return true
+      else
+        tempfile.delete
+        Logging.fatal "Unable to download file #{path}: #{return_code}"
+        raise NetworkError.new("Unable to download file #{path}: #{return_code}")
+      end
+    end
+
+    def ssh_upload(user, host, local_file, remote_file)
+      uri = URI.parse(remote_file)
+      dir = uri.path[0, uri.path.rindex('/')]
+      Net::SSH.start(host, user) do |ssh|
+        ssh.exec!("mkdir -p #{dir}")
+      end
+      Net::SFTP.start(host, user) do |sftp|
+        sftp.upload!(local_file, uri.path)
+      end
+    end
+
+    private
+
+    def log_download(url, path)
+      Logging.debug "Downloading #{url} to #{path}."
+    end
+  end
+end

data/lib/fig/package/archive.rb

@@ -0,0 +1,24 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Archive
+  include Fig::Package::Statement
+
+  attr_reader :url
+
+  def initialize(url)
+    @url = url
+  end
+
+  def urls
+    return [@url]
+  end
+
+  def unparse(indent)
+    %Q<#{indent}archive "#{url}">
+  end
+end

data/lib/fig/package/command.rb

@@ -0,0 +1,20 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Command
+  include Fig::Package::Statement
+
+  attr_reader :command
+
+  def initialize(command)
+    @command = command
+  end
+
+  def unparse(indent)
+    %Q<#{indent}command "#{@command}">
+  end
+end