fpm-fry 0.2.2 → 0.4.6

data/lib/fpm/fry/source/{package.rb → archive.rb}

@@ -4,32 +4,67 @@ require 'net/http'
 require 'forwardable'
 require 'zlib'
 require 'fpm/fry/source'
+require 'fpm/fry/exec'
 require 'cabin'
+require 'cabin/channel'
+
 module FPM; module Fry ; module Source
-  class Package
+  # Used to build from an archive.
+  #
+  # @example in a recipe
+  #   source 'http://curl.haxx.se/download/curl-7.36.0.tar.gz',
+  #     checksum: '33015795d5650a2bfdd9a4a28ce4317cef944722a5cfca0d1563db8479840e90'
+  #
+  # It is highly advised to supply a checksum ( althought it's not mandatory ). 
+  # This checksum will be used to test for cache validity and data integrity. The 
+  # checksum algorithm is automatically guessed based on the length of the checksum.
+  #
+  #   - 40 characters = sha1
+  #   - 64 characters = sha256
+  # 
+  # Let's be honest: all other checksum algorithms aren't or shouldn't be in use anyway.
+  class Archive
 
     REGEX = %r!\Ahttps?:!
 
+    # @return [:archive]
     def self.name
       :package
     end
 
     def self.aliases
-      [:http]
+      [:package,:http]
     end
 
+    # Guesses if the given url is an archive.
+    # 
+    # @example not an archive
+    #   FPM::Fry::Source::Archive.guess("bzr://something") # => nil
+    #
+    # @example an archive
+    #   FPM::Fry::Source::Archive.guess("https://some/thing.tar.gz") #=> 6
+    #
+    # @return [nil] when it's not an archive
+    # @return [Numeric] number of characters used
     def self.guess( url )
       Source::guess_regex(REGEX, url)
     end
 
+    # Raised when too many redirects happened.
     class RedirectError < CacheFailed
     end
 
+    # Raised when the archive type is not known.
+    class UnknownArchiveType < StandardError
+      include WithData
+    end
+
     class Cache < Struct.new(:package,:tempdir)
       extend Forwardable
 
-      def_delegators :package, :url, :checksum, :checksum_algorithm, :agent, :logger, :file_map
+      def_delegators :package, :url, :checksum, :checksum_algorithm, :logger, :file_map, :to
 
+      # @return [String] cachekey which is equal to the checksum
       def cachekey
         @observed_checksum || checksum
       end
@@ -92,7 +127,7 @@ module FPM; module Fry ; module Source
           case(resp)
           when Net::HTTPRedirection
             if redirs == 0
-              raise RedirectError, "Too many redirects"
+              raise RedirectError.new("Too many redirects", url: url.to_s, location: resp['location'])
             end
             logger.debug("Following redirect", url: url.to_s , location: resp['location'])
             return fetch_url( resp['location'], redirs - 1, &block)
@@ -119,9 +154,33 @@ module FPM; module Fry ; module Source
 
       def copy_to(dst)
         update!
-        cmd = ['tar','-xf',tempfile,'-C',dst]
-        logger.debug("Running tar",cmd: cmd)
-        system(*cmd)
+        Exec['tar','-xf',tempfile,'-C',dst, logger: logger]
+      end
+
+      def prefix
+        update!
+        @prefix ||= prefix!
+      end
+
+      def prefix!
+        longest = nil
+        Exec.popen('tar','-tf',tempfile, logger: logger).each_line.map do |line|
+          line = line.chomp
+          parts = line.split('/')
+          parts.pop unless line[-1] == '/'
+          if longest.nil?
+            longest = parts
+          else
+            longest.each_with_index do | e, i |
+              if parts[i] != e
+                longest = longest[0...i]
+                break
+              end
+            end
+            break if longest.none?
+          end
+        end
+        return Array(longest).join('/')
       end
 
     protected
@@ -142,9 +201,7 @@ module FPM; module Fry ; module Source
 
       def tar_io
         update!
-        cmd = ['bzcat',tempfile]
-        logger.debug("Running bzcat",cmd: cmd)
-        return IO.popen(cmd)
+        return Exec::popen('bzcat', tempfile, logger: logger)
       end
 
     end
@@ -152,6 +209,22 @@ module FPM; module Fry ; module Source
     class ZipCache < Cache
 
       def tar_io
+        unpack!
+        return Exec::popen('tar','-c','.', chdir: unpacked_tmpdir)
+      end
+
+      def copy_to(dst)
+        update!
+        Exec['unzip', tempfile, '-d', dst ]
+      end
+
+      def prefix
+        unpack!
+        Source::prefix(unpacked_tmpdir)
+      end
+    private
+
+      def unpack!
         if !::File.directory?( unpacked_tmpdir )
           workdir = unpacked_tmpdir + '.tmp'
           begin
@@ -163,18 +236,6 @@ module FPM; module Fry ; module Source
           copy_to( workdir )
           File.rename(workdir, unpacked_tmpdir)
         end
-        cmd = ['tar','-c','.']
-        logger.debug("Running tar",cmd: cmd, dir: unpacked_tmpdir)
-        ::Dir.chdir(unpacked_tmpdir) do
-          return IO.popen(cmd)
-        end
-      end
-
-      def copy_to(dst)
-        update!
-        cmd = ['unzip', tempfile, '-d', dst ]
-        logger.debug("Running unzip",cmd: cmd)
-        system(*cmd, out: '/dev/null')
       end
 
       def unpacked_tmpdir
@@ -186,12 +247,8 @@ module FPM; module Fry ; module Source
 
       def tar_io
         update!
-        cmd = ['tar','-c',::File.basename(tempfile)]
         dir = File.dirname(tempfile)
-        logger.debug("Running tar",cmd: cmd, dir: dir)
-        ::Dir.chdir(dir) do
-          return IO.popen(cmd)
-        end
+        Exec::popen('tar','-c',::File.basename(tempfile), logger: logger, chdir: dir)
       end
 
       def copy_to(dst)
@@ -199,6 +256,10 @@ module FPM; module Fry ; module Source
         FileUtils.cp( tempfile, dst )
       end
 
+      def prefix
+        ""
+      end
+
     end
 
     CACHE_CLASSES = {
@@ -211,26 +272,45 @@ module FPM; module Fry ; module Source
       '.bundle' => PlainCache
     }
 
-    attr :file_map, :data, :url, :extension, :checksum, :checksum_algorithm, :agent, :logger
+    attr :file_map, :data, :url, :checksum, :checksum_algorithm, :logger, :to
 
+    # @param [URI] url
+    # @param [Hash] options
+    # @option options [Cabin::Channel] :logger (default cabin channel)
+    # @option options [String] :checksum a checksum of the archive
+    # @raise [UnknownArchiveType] when the archive type is unknown
     def initialize( url, options = {} )
       @url = URI(url)
-      @extension = options.fetch(:extension){
-        CACHE_CLASSES.keys.find{|ext|
-          @url.path.end_with?(ext)
-        }
-      }
+      @cache_class = guess_cache_class(@url)
       @logger = options.fetch(:logger){ Cabin::Channel.get }
       @checksum = options[:checksum]
       @checksum_algorithm = guess_checksum_algorithm(options[:checksum])
-      @file_map = options.fetch(:file_map){ {'' => ''} }
+      @file_map = options[:file_map]
+      @to = options[:to]
     end
 
+    # Creates a cache.
+    #
+    # @param [String] tempdir
+    # @return [TarCache] for plain .tar files
+    # @return [TarGzCache] for .tar.gz files
+    # @return [TarBz2Cache] for .tar.bz2 files
+    # @return [ZipCache] for .zip files
+    # @return [PlainCache] for .bin files
     def build_cache(tempdir)
-      CACHE_CLASSES.fetch(extension).new(self, tempdir)
+      @cache_class.new(self, tempdir)
     end
   private
 
+    def guess_cache_class( url )
+      CACHE_CLASSES.each do |ext,klass|
+        if url.path.end_with?(ext)
+          return klass
+        end
+      end
+      raise UnknownArchiveType.new("Unknown archive type", url: url.to_s, known_extensions: CACHE_CLASSES.keys)
+    end
+
     def guess_checksum_algorithm( checksum )
       case(checksum)
       when nil

data/lib/fpm/fry/source/dir.rb

@@ -1,6 +1,10 @@
 require 'fpm/fry/source'
+require 'fpm/fry/exec'
 require 'fileutils'
 require 'digest'
+require 'cabin/channel'
+require 'fpm/fry/tar'
+
 module FPM; module Fry ; module Source
   class Dir
 
@@ -17,14 +21,10 @@ module FPM; module Fry ; module Source
     class Cache < Struct.new(:package, :dir)
       extend Forwardable
 
-      def_delegators :package, :url, :logger, :file_map
+      def_delegators :package, :url, :logger, :file_map, :to
 
       def tar_io
-        cmd = ['tar','-c','.']
-        logger.debug("Running tar",cmd: cmd, dir: dir)
-        ::Dir.chdir(dir) do
-          return IO.popen(cmd)
-        end
+        Exec::popen('tar','-c','.', chdir: dir, logger: logger)
       end
 
       def copy_to(dst)
@@ -39,9 +39,13 @@ module FPM; module Fry ; module Source
         end
         return dig.hexdigest
       end
+
+      def prefix
+        Source::prefix(dir)
+      end
     end
 
-    attr :url, :logger, :file_map
+    attr :url, :logger, :file_map, :to
 
     def initialize( url, options = {} )
       @url = URI(url)
@@ -49,7 +53,8 @@ module FPM; module Fry ; module Source
         @url.path = File.expand_path(@url.path)
       end
       @logger = options.fetch(:logger){ Cabin::Channel.get }
-      @file_map = options.fetch(:file_map){ {'' => ''} }
+      @file_map = options[:file_map]
+      @to = options[:to]
     end
 
     def build_cache(_)

data/lib/fpm/fry/source/git.rb

@@ -1,16 +1,41 @@
 require 'fileutils'
 require 'forwardable'
-require 'open3'
+require 'fpm/fry/exec'
 require 'fpm/fry/source'
 module FPM; module Fry ; module Source
+  # Used to build directly from git.
+  #
+  # @example in a recipe
+  #     source 'https://github.com/ggreer/the_silver_searcher.git'
+  # 
+  # It automatically recognizes the following url patterns:
+  #
+  #   - git://…
+  #   - git+…://…
+  #   - user@host:….git
+  #   - https://….git
+  #   - https://git.…
+  #
   class Git
 
-    REGEX = %r!\A(?:git:|\S+@\S+:\S+\.git\z|https?:.*\.git\z|ssh:.*\.git\z)!
+    REGEX = %r!\A(?:git:|\S+@\S+:\S+\.git\z|https?:(?://git\.|.*\.git\z)|ssh:.*\.git\z|git\+[a-z0-9]+:)!
 
+    # @return [:git]
     def self.name
       :git
     end
 
+    # Guesses if this url is a git url.
+    #
+    # @example not a git url
+    #   FPM::Fry::Source::Git.guess( "bzr://something" ) #=> nil
+    #
+    # @example a git url
+    #   FPM::Fry::Source::Git.guess( "git://something" ) #=> 4
+    #
+    # @param [URI,String] url
+    # @return [nil] when this uri doesn't match
+    # @return [Numeric] number of characters that were used
     def self.guess( url )
       Source::guess_regex(REGEX, url)
     end
@@ -18,76 +43,87 @@ module FPM; module Fry ; module Source
     class Cache < Struct.new(:package, :tempdir)
       extend Forwardable
 
-      def_delegators :package, :url, :rev, :logger, :file_map
-
-      def update
-        begin
-          if !File.exists? repodir
-            if (ecode = git('init', '--bare')) != 0
-              raise CacheFailed.new("Initializing git repository failed", exit_code: ecode)
-            end
-          end
-          if (ecode = git('fetch','--depth=1', url.to_s, rev)) != 0
-            raise CacheFailed.new("Failed to fetch from remote", exit_code: ecode, url: url.to_s, rev: rev)
-          end
-          return self
-        rescue Errno::ENOENT
-          raise "Cannot find git binary. Is it installed?"
-        end
-      end
+      def_delegators :package, :url, :rev, :logger, :file_map, :to
 
       def tar_io
-        cmd = [package.git, "--git-dir=#{repodir}",'archive','--format=tar','FETCH_HEAD']
-        logger.debug("Running git",cmd: cmd)
-        IO.popen(cmd)
+        Exec::popen(package.git, "--git-dir=#{repodir}",'archive','--format=tar','FETCH_HEAD', logger: logger)
       end
 
       def copy_to(dst)
-        cmd = [package.git, "--git-dir=#{repodir}", "--work-tree=#{dst}",'checkout','FETCH_HEAD','--','*']
-        logger.debug("Running git",cmd: cmd)
-        system(*cmd, chdir: dst)
+        Exec[
+          package.git, "--git-dir=#{repodir}", "--work-tree=#{dst}",'checkout','FETCH_HEAD','--','*',
+          chdir: dst, logger: logger
+        ]
       end
 
       def cachekey
-        cmd = [package.git, "--git-dir=#{repodir}",'rev-parse','FETCH_HEAD^{tree}']
-        logger.debug("Running git",cmd: cmd)
-        return IO.popen(cmd).read.chomp
+        Exec::exec(package.git, "--git-dir=#{repodir}",'rev-parse','FETCH_HEAD^{tree}', logger: logger).chomp
+      end
+
+      def prefix
+        ""
       end
+
     private
-      def repodir
-        File.join(tempdir,File.basename(url.path))
+      def initialize(*_)
+        super
+        update
       end
 
-      def git(*args)
-        cmd = [package.git, "--git-dir=#{repodir}",*args]
-        logger.debug("Running git",cmd: cmd.join(' '))
-        Open3.popen3(*cmd) do |sin, out, err, thr|
-          sin.close
-          out.each_line do |line|
-            logger.debug(line.chomp)
-          end
-          err.each_line do |line|
-            logger.debug(line.chomp)
+      def update
+        begin
+          if !File.exists? repodir
+            Exec::exec(package.git, "--git-dir=#{repodir}",'init', '--bare', description: "initializing git repository", logger: logger)
           end
-          return thr.value.exitstatus
+          Exec::exec(package.git, "--git-dir=#{repodir}",'fetch','--depth=1', url.to_s, rev, description: 'fetching from remote', logger: logger)
+          return self
+        rescue => e
+          raise CacheFailed.new(e, url: url.to_s, rev: rev)
         end
       end
-
+      def repodir
+        File.join(tempdir,File.basename(url.path))
+      end
     end
 
-    attr :logger, :git, :rev, :file_map, :url
+    # @return [Cabin::Channel] logger
+    attr :logger
+
+    # @return [String] the git binary (default: "git")
+    attr :git
+
+    # @return [String] the git rev to pull (default "HEAD")
+    attr :rev
+
+    # @return [Hash<String,String>,nil] the file map for generating a docker file
+    attr :file_map
+
+    # @return [URI] the uri to pull from
+    attr :url
+
+    # @return [String,nil]
+    attr :to
 
+    # @param [URI] url the url to pull from
+    # @param [Hash] options
+    # @option options [Cabin::Channel] :logger (cabin default channel)
+    # @option options [String] :branch git branch to pull
+    # @option options [String] :tag git tag to pull
+    # @option options [Hash<String,String>] :file_map ({""=>""}) the file map to create the docker file from
     def initialize( url, options = {} )
       url = url.sub(/\A(\S+@\S+):(\S+\.git)\z/,'ssh://\1/\2')
       @url = URI(url)
       @logger = options.fetch(:logger){ Cabin::Channel.get }
       @rev = options[:branch] || options[:tag] || options[:rev] || 'HEAD'
-      @file_map = options.fetch(:file_map){ {'' => ''} }
+      @file_map = options[:file_map]
       @git = options[:git] || 'git'
+      @to = options[:to]
     end
 
+    # @param [String] tempdir
+    # @return [Cache]
     def build_cache(tempdir)
-      Cache.new(self, tempdir).update
+      Cache.new(self, tempdir)
     end
 
   end