rubycut-babushka 0.10.6

data/lib/babushka/renderable.rb

@@ -0,0 +1,67 @@
+module Babushka
+  class Renderable
+    include ShellHelpers
+    include RunHelpers
+
+    SEAL_REGEXP = /# Generated by babushka-[\d\.]+ at [a-zA-Z\d\-\:\s+]+, from [0-9a-f]{40}+\. [0-9a-f]{40}/
+
+    attr_reader :path
+    def initialize path
+      @path = path
+    end
+
+    def render source, opts = {}
+      shell("cat > '#{path}'",
+        :input => inkan_output_for(source, opts),
+        :sudo => opts[:sudo]
+      ).tap {|result|
+        if result
+          sudo "chmod #{opts[:perms]} '#{path}'" if opts[:perms]
+        end
+      }
+    end
+
+    def exists?
+      path.p.exists?
+    end
+
+    def clean?
+      Inkan.legitimate? path
+    end
+
+    def from? source
+      exists? && source_sha == sha_of(source)
+    end
+
+    private
+
+    def inkan_output_for source, opts = {}
+      Inkan.render {|inkan|
+        inkan.credit = "Generated #{_by_babushka}, from #{sha_of(source)}"
+        inkan.comment = opts[:comment] if opts[:comment]
+        inkan.comment_suffix = opts[:comment_suffix] if opts[:comment_suffix]
+        inkan.print render_erb(source, opts[:context])
+      }
+    end
+
+    def render_erb source, custom_context
+      require 'erb'
+      (custom_context || self).instance_eval {
+        ERB.new(source.p.read).result(binding)
+      }
+    end
+
+    def sha_of source
+      require 'digest/sha1'
+      raise "Source doesn't exist: #{source.p}" unless source.p.exists?
+      Digest::SHA1.hexdigest(source.p.read)
+    end
+
+    def source_sha
+      File.open(path.p) {|f|
+        first_line = f.gets
+        first_line[/\A#!/] ? f.gets : first_line
+      }.scan(/, from ([0-9a-f]{40})\./).flatten.first
+    end
+  end
+end

data/lib/babushka/resource.rb

@@ -0,0 +1,215 @@
+module Babushka
+  class ResourceError < StandardError
+  end
+  class Resource
+    include LogHelpers
+    extend LogHelpers
+    include ShellHelpers
+    extend ShellHelpers
+    include PathHelpers
+    extend PathHelpers
+
+    def self.get url, &block
+      filename = URI.unescape(url.to_s).p.basename
+      if filename.to_s.blank?
+        log_error "Not a valid URL to download: #{url}"
+      else
+        download_path = in_download_dir {|path|
+          downloaded_file = download(url, filename)
+          path / downloaded_file if downloaded_file
+        }
+        block.call download_path unless download_path.nil?
+      end
+    end
+
+    def self.extract url, &block
+      get url do |download_path|
+        in_build_dir {
+          Resource.for(download_path).extract(&block)
+        }
+      end
+    end
+
+    def self.download url, filename = url.to_s.p.basename
+      if filename.p.exists? && !filename.p.empty?
+        log_ok "Already downloaded #{filename}."
+        filename
+      elsif (result = shell(%Q{curl -I -X GET "#{url}"})).nil?
+        log_error "Couldn't download #{url}: `curl` exited with non-zero status."
+      else
+        response_code = result.val_for(/HTTP\/1\.\d/) # not present for ftp://, etc.
+        if response_code && response_code[/^[23]/].nil?
+          log_error "Couldn't download #{url}: #{response_code}."
+        elsif !(location = result.val_for('Location')).nil?
+          log "Following redirect from #{url}"
+          download URI.escape(location), location.p.basename
+        else
+          success = log_block "Downloading #{url}" do
+            shell %Q{curl -# -o "#{filename}.tmp" "#{url}" && mv -f "#{filename}.tmp" "#{filename}"}, :progress => /[\d\.]+%/
+          end
+          filename if success
+        end
+      end
+    end
+
+    def self.detect_type_by_extension path
+      TYPES.keys.detect {|key|
+        TYPES[key][:exts].any? {|extension|
+          path.has_extension? extension
+        }
+      }
+    end
+    
+    def self.detect_type_by_contents path
+      TYPES.keys.detect {|key|
+        shell("file '#{path}'")[TYPES[key][:file_match]]
+      }
+    end
+
+    def self.type path
+      detect_type_by_extension(path) || detect_type_by_contents(path)
+    end
+
+    TYPES = {
+      :deb => {:file_match => 'Debian binary package', :exts => %w[deb]},
+      :pkg => {:file_match => 'xar archive', :exts => %w[pkg]},
+      :tar => {:file_match => 'tar archive', :exts => %w[tar]},
+      :gzip => {:file_match => 'gzip compressed data', :exts => %w[tgz tar.gz]},
+      :bzip2 => {:file_match => 'bzip2 compressed data', :exts => %w[tbz2 tar.bz2]},
+      :zip => {:file_match => 'Zip archive data', :exts => %w[zip]},
+      :dmg => {:file_match => 'VAX COFF executable not stripped', :exts => %w[dmg]}
+    }
+
+    attr_reader :path, :name
+
+    def initialize path, opts = {}
+      @path = path.p
+      @name = TYPES[type][:exts].inject(filename) {|fn,t| fn.gsub(/\.#{t}$/, '') }
+    end
+
+    def filename
+      path.basename.to_s
+    end
+
+    def type
+      self.class.type path
+    end
+
+    def supported?
+      !type.nil?
+    end
+
+    def extract &block
+      cd(archive_prefix, :create => true) { process_extract(&block) }
+    end
+
+    def process_extract &block
+      shell("mkdir -p '#{name}'") and
+      cd(name) {
+        unless log_shell("Extracting #{filename}", extract_command)
+          log_error "Couldn't extract #{path} - probably a bad download."
+        else
+          cd(content_subdir) {
+            block.nil? or block.call(self)
+          }
+        end
+      }
+    end
+
+    def content_subdir
+      identity_dirs.reject {|dir|
+        %w[app pkg bundle tmbundle prefPane].map {|i|
+          /\.#{i}$/
+        }.any? {|dont_descend|
+          dir[dont_descend]
+        }
+      }.first
+    end
+
+    def identity_dirs
+      everything = Dir.glob('*')
+      if everything.length == 1 && File.directory?(everything.first)
+        everything
+      else
+        Dir.glob('*/').map {|dir| dir.chomp('/') }.select {|dir|
+          dir.downcase.gsub(/[ \-_\.]/, '') == name.downcase.gsub(/[ \-_\.]/, '')
+        }
+      end
+    end
+
+    def archive_prefix
+      BuildPrefix
+    end
+  end
+
+  class FileResource < Resource
+    def extract &block
+      in_download_dir {
+        block.call(self)
+      }
+    end
+  end
+
+  class TarResource < Resource
+    def extract_command
+      "tar -#{extract_option(type)}xf '#{path}'"
+    end
+    def extract_option type
+      {
+        :tar => '',
+        :gzip => 'z',
+        :bzip2 => 'j'
+      }[type]
+    end
+  end
+
+  class ZipResource < Resource
+    def extract_command
+      "unzip -o '#{path}'"
+    end
+  end
+
+  class DmgResource < Resource
+    def extract &block
+      in_download_dir {
+        output = log_shell "Attaching #{filename}", "hdiutil attach '#{filename.p.basename}'"
+        if output.nil?
+          log_error "Couldn't mount #{filename.p}."
+        elsif (path = mountpoint_for(output)).nil?
+          raise "Couldn't find where `hdiutil` mounted #{filename.p}."
+        else
+          cd(path) {
+            block.call(self)
+          }.tap {
+            log_shell "Detaching #{filename}", "hdiutil detach '#{path}'"
+          }
+        end
+      }
+    end
+
+    def mountpoint_for output
+      output.scan(/\s+(\/Volumes\/[^\n]+)/).flatten.first
+    end
+  end
+  
+  class Resource
+    CLASSES = {
+      :deb => FileResource,
+      :pkg => FileResource,
+      :tar => TarResource,
+      :gzip => TarResource,
+      :bzip2 => TarResource,
+      :zip => ZipResource,
+      :dmg => DmgResource
+    }
+
+    def self.for path, opts = {}
+      path = path.p
+      filename = path.basename.to_s
+      raise ResourceError, "The archive #{filename} does not exist." unless path.exists?
+      klass = CLASSES[type(path)]
+      raise ResourceError, "Don't know how to extract #{filename}." if klass.nil?
+      klass.new(path, opts)
+    end
+  end
+end

data/lib/babushka/run_reporter.rb

@@ -0,0 +1,60 @@
+module Babushka
+  class RunReporter
+  class << self
+    include LogHelpers
+
+    def queue dep, result, reportable
+      if dep.dep_source.type != :public
+        debug "Not reporting #{dep.contextual_name}, since it's not in a public source."
+      else
+        queue_report dep, (reportable ? 'error' : (result ? 'ok' : 'fail'))
+      end
+    end
+
+    def post_reports
+      require 'net/http'
+
+      while Base.task.running? && (report = most_recent_report)
+        post_report report
+      end
+    end
+
+
+    private
+
+    def post_report report
+      submit_report_to_webservice(report.p.read).tap {|result|
+        report.p.rm if result
+      }
+    end
+
+    require 'net/http'
+    def submit_report_to_webservice data
+      Net::HTTP.start('babushka.me') {|http|
+        http.open_timeout = http.read_timeout = 5
+        http.post '/runs.json', data
+      }.is_a?(Net::HTTPSuccess)
+    rescue Errno::ECONNREFUSED, SocketError
+      log_error "Couldn't connect to the babushka webservice." unless Base.task.running?
+    rescue Timeout::Error, Errno::ETIMEDOUT
+      debug "Timeout while submitting run report."
+    end
+
+    def most_recent_report
+      ReportPrefix.p.glob('*').sort.last
+    end
+
+    def queue_report dep, result
+      ReportPrefix.p.mkdir
+      (ReportPrefix / Time.now.to_f).open('w') {|f|
+        f << run_report_for(dep, result).to_http_params
+      }
+    end
+
+    def run_report_for dep, result
+      Base.task.task_info(dep, result)
+    end
+
+  end
+  end
+end

data/lib/babushka/shell.rb

@@ -0,0 +1,108 @@
+module Babushka
+  class Shell
+    include LogHelpers
+
+    class ShellCommandFailed < StandardError
+      attr_reader :cmd, :stdout, :stderr
+      def initialize cmd, stdout, stderr
+        @cmd, @stdout, @stderr = cmd, stdout, stderr
+        message = if stderr.empty?
+          "Shell command failed: '#{cmd.join(' ')}'"
+        else
+          "Shell command failed: '#{cmd.join(' ')}':\n#{stderr}"
+        end
+        super message
+      end
+    end
+
+    attr_reader :cmd, :opts, :env, :result, :stdout, :stderr
+
+    def initialize *cmd
+      @opts = cmd.extract_options!
+      raise "You can't use :spinner and :progress together in Babushka::Shell." if opts[:spinner] && opts[:progress]
+      @env = cmd.first.is_a?(Hash) ? cmd.shift : {}
+      @cmd = cmd
+      @progress = nil
+    end
+
+    def ok?; result == 0 end
+
+    def run &block
+      @stdout, @stderr = '', ''
+      @result = invoke
+      print "#{" " * (@progress.length + 1)}#{"\b" * (@progress.length + 1)}" unless @progress.nil?
+
+      if block_given?
+        yield(self)
+      elsif ok?
+        stdout.chomp
+      else
+        raise ShellCommandFailed.new(cmd, stdout, stderr)
+      end
+    end
+
+    private
+
+    def invoke
+      debug "$ #{@cmd.join(' ')}".colorize('grey')
+      Babushka::Open3.popen3 @cmd, popen_opts do |stdin,stdout,stderr,thread|
+        unless @opts[:input].nil?
+          stdin << @opts[:input]
+          stdin.close
+        end
+
+        spinner_offset = -1
+        should_spin = @opts[:spinner] && !Base.task.opt(:debug)
+
+        # For very short-running commands, check for output in a tight loop.
+        # The sleep below would at least halve the speed of quick #shell calls.
+        # This means really quick calls (e.g. `whoami`, `pwd`, etc) aren't
+        # delayed, but the CPU is only pegged for a fraction of a second on
+        # slower calls (e.g. `gem env`, `make`, etc).
+        1_000.times { break if stdout.ready_for_read? || stderr.ready_for_read? }
+
+        loop {
+          read_from stdout, @stdout do
+            print " #{%w[| / - \\][spinner_offset = ((spinner_offset + 1) % 4)]}\b\b" if should_spin
+          end
+          read_from stderr, @stderr, :stderr
+
+          if stdout.closed? && stderr.closed?
+            break
+          else
+            # We sleep here because otherwise babushka itself would peg the CPU
+            # while waiting for output from long-running shell commands.
+            sleep 0.05
+          end
+        }
+      end
+    end
+
+    def read_from io, buf, log_as = nil
+      while !io.closed? && io.ready_for_read?
+        output = nil
+        # Only try reading up to a backspace if we're looking for progress output.
+        output = io.gets("\r") if @opts[:progress]
+        output = io.gets if output.nil?
+
+        if output.nil?
+          io.close
+        else
+          debug output.chomp, :log => @opts[:log], :as => log_as
+          buf << output
+          if @opts[:progress] && (@progress = output[@opts[:progress]])
+            print " #{@progress}#{"\b" * (@progress.length + 1)}"
+          end
+          yield if block_given?
+        end
+      end
+    end
+
+    def popen_opts
+      {}.tap {|opts|
+        opts[:chdir] = @opts[:cd].p.to_s if @opts[:cd]
+        opts[:env] = @env if @env
+      }
+    end
+  end
+end