rubygems-update 1.8.30 → 2.0.0.preview2

data/lib/rubygems/security/trust_dir.rb

@@ -0,0 +1,104 @@
+class Gem::Security::TrustDir
+
+  DEFAULT_PERMISSIONS = {
+    :trust_dir    => 0700,
+    :trusted_cert => 0600,
+  }
+
+  def initialize dir, permissions = DEFAULT_PERMISSIONS
+    @dir = dir
+    @permissions = permissions
+
+    @digester = Gem::Security::DIGEST_ALGORITHM
+  end
+
+  attr_reader :dir
+
+  ##
+  # Returns the path to the trusted +certificate+
+
+  def cert_path certificate
+    name_path certificate.subject
+  end
+
+  ##
+  # Enumerates trusted certificates.
+
+  def each_certificate
+    return enum_for __method__ unless block_given?
+
+    glob = File.join @dir, '*.pem'
+
+    Dir[glob].each do |certificate_file|
+      begin
+        certificate = load_certificate certificate_file
+
+        yield certificate, certificate_file
+      rescue OpenSSL::X509::CertificateError
+        next # HACK warn
+      end
+    end
+  end
+
+  ##
+  # Returns the issuer certificate of the given +certificate+ if it exists in
+  # the trust directory.
+
+  def issuer_of certificate
+    path = name_path certificate.issuer
+
+    return unless File.exist? path
+
+    load_certificate path
+  end
+
+  ##
+  # Returns the path to the trusted certificate with the given ASN.1 +name+
+
+  def name_path name
+    digest = @digester.hexdigest name.to_s
+
+    File.join @dir, "cert-#{digest}.pem"
+  end
+
+  ##
+  # Loads the given +certificate_file+
+
+  def load_certificate certificate_file
+    pem = File.read certificate_file
+
+    OpenSSL::X509::Certificate.new pem
+  end
+
+  ##
+  # Add a certificate to trusted certificate list.
+
+  def trust_cert certificate
+    verify
+
+    destination = cert_path certificate
+
+    open destination, 'wb', @permissions[:trusted_cert] do |io|
+      io.write certificate.to_pem
+    end
+  end
+
+  ##
+  # Make sure the trust directory exists.  If it does exist, make sure it's
+  # actually a directory.  If not, then create it with the appropriate
+  # permissions.
+
+  def verify
+    if File.exist? @dir then
+      raise Gem::Security::Exception,
+        "trust directory #{@dir} is not a directory" unless
+          File.directory? @dir
+
+      FileUtils.chmod 0700, @dir
+    else
+      FileUtils.mkdir_p @dir, :mode => @permissions[:trust_dir]
+    end
+  end
+
+end
+

data/lib/rubygems/server.rb

@@ -3,7 +3,7 @@ require 'zlib'
 require 'erb'
 
 require 'rubygems'
-require 'rubygems/doc_manager'
+require 'rubygems/rdoc'
 
 ##
 # Gem::Server and allows users to serve gems for consumption by
@@ -17,9 +17,6 @@ require 'rubygems/doc_manager'
 # * "/quick/" - Individual gemspecs
 # * "/gems" - Direct access to download the installable gems
 # * "/rdoc?q=" - Search for installed rdoc documentation
-# * legacy indexes:
-#   * "/Marshal.#{Gem.marshal_version}" - Full SourceIndex dump of metadata
-#     for installed gems
 #
 # == Usage
 #
@@ -430,53 +427,25 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; }
         options[:launch], options[:addresses]).run
   end
 
-  ##
-  # Only the first directory in gem_dirs is used for serving gems
-
   def initialize(gem_dirs, port, daemon, launch = nil, addresses = nil)
+    Gem::RDoc.load_rdoc
     Socket.do_not_reverse_lookup = true
 
-    @gem_dirs = Array gem_dirs
-    @port = port
-    @daemon = daemon
-    @launch = launch
+    @gem_dirs  = Array gem_dirs
+    @port      = port
+    @daemon    = daemon
+    @launch    = launch
     @addresses = addresses
-    logger = WEBrick::Log.new nil, WEBrick::BasicLog::FATAL
-    @server = WEBrick::HTTPServer.new :DoNotListen => true, :Logger => logger
 
-    @spec_dirs = @gem_dirs.map do |gem_dir|
-      spec_dir = File.join gem_dir, 'specifications'
-
-      unless File.directory? spec_dir then
-        raise ArgumentError, "#{gem_dir} does not appear to be a gem repository"
-      end
+    logger  = WEBrick::Log.new nil, WEBrick::BasicLog::FATAL
+    @server = WEBrick::HTTPServer.new :DoNotListen => true, :Logger => logger
 
-      spec_dir
-    end
+    @spec_dirs = @gem_dirs.map { |gem_dir| File.join gem_dir, 'specifications' }
+    @spec_dirs.reject! { |spec_dir| !File.directory? spec_dir }
 
     Gem::Specification.dirs = @gem_dirs
-  end
 
-  def Marshal(req, res)
-    Gem::Specification.reset
-
-    add_date res
-
-    index = Gem::Deprecate.skip_during { Marshal.dump Gem.source_index }
-
-    if req.request_method == 'HEAD' then
-      res['content-length'] = index.length
-      return
-    end
-
-    if req.path =~ /Z$/ then
-      res['content-type'] = 'application/x-deflate'
-      index = Gem.deflate index
-    else
-      res['content-type'] = 'application/octet-stream'
-    end
-
-    res.body << index
+    @have_rdoc_4_plus = nil
   end
 
   def add_date res
@@ -485,6 +454,19 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; }
     end.max
   end
 
+  def doc_root gem_name
+    if have_rdoc_4_plus? then
+      "/doc_root/#{gem_name}/"
+    else
+      "/doc_root/#{gem_name}/rdoc/index.html"
+    end
+  end
+
+  def have_rdoc_4_plus?
+    @have_rdoc_4_plus ||=
+      Gem::Requirement.new('>= 4').satisfied_by? Gem::RDoc.rdoc_version
+  end
+
   def latest_specs(req, res)
     Gem::Specification.reset
 
@@ -614,14 +596,14 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; }
         "authors"             => spec.authors.sort.join(", "),
         "date"                => spec.date.to_s,
         "dependencies"        => deps,
-        "doc_path"            => "/doc_root/#{spec.full_name}/rdoc/index.html",
+        "doc_path"            => doc_root(spec.full_name),
         "executables"         => executables,
         "only_one_executable" => (executables && executables.size == 1),
         "full_name"           => spec.full_name,
         "has_deps"            => !deps.empty?,
         "homepage"            => spec.homepage,
         "name"                => spec.name,
-        "rdoc_installed"      => Gem::DocManager.new(spec).rdoc_installed?,
+        "rdoc_installed"      => Gem::RDoc.new(spec).rdoc_installed?,
         "summary"             => spec.summary,
         "version"             => spec.version.to_s,
       }
@@ -630,7 +612,7 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; }
     specs << {
       "authors" => "Chad Fowler, Rich Kilmer, Jim Weirich, Eric Hodel and others",
       "dependencies" => [],
-      "doc_path" => "/doc_root/rubygems-#{Gem::VERSION}/rdoc/index.html",
+      "doc_path" => doc_root("rubygems-#{Gem::VERSION}"),
       "executables" => [{"executable" => 'gem', "is_last" => true}],
       "only_one_executable" => true,
       "full_name" => "rubygems-#{Gem::VERSION}",
@@ -730,15 +712,15 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; }
     when 1
       new_path = File.basename(found_gems[0])
       res.status = 302
-      res['Location'] = "/doc_root/#{new_path}/rdoc/index.html"
+      res['Location'] = doc_root new_path
       return true
     else
       doc_items = []
       found_gems.each do |file_name|
         base_name = File.basename(file_name)
         doc_items << {
-          :name => base_name,
-          :url => "/doc_root/#{base_name}/rdoc/index.html",
+          :name    => base_name,
+          :url     => doc_root(new_path),
           :summary => ''
         }
       end
@@ -756,9 +738,6 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; }
 
     WEBrick::Daemon.start if @daemon
 
-    @server.mount_proc "/Marshal.#{Gem.marshal_version}", method(:Marshal)
-    @server.mount_proc "/Marshal.#{Gem.marshal_version}.Z", method(:Marshal)
-
     @server.mount_proc "/specs.#{Gem.marshal_version}", method(:specs)
     @server.mount_proc "/specs.#{Gem.marshal_version}.gz", method(:specs)
 
@@ -779,10 +758,21 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; }
 
     @server.mount_proc "/rdoc", method(:rdoc)
 
-    paths = { "/gems" => "/cache/", "/doc_root" => "/doc/" }
-    paths.each do |mount_point, mount_dir|
-      @server.mount(mount_point, WEBrick::HTTPServlet::FileHandler,
-                    File.join(@gem_dirs.first, mount_dir), true)
+    file_handlers = {
+      '/gems' => '/cache/',
+    }
+
+    if have_rdoc_4_plus? then
+      @server.mount '/doc_root', RDoc::Servlet, '/doc_root'
+    else
+      file_handlers['/doc_root'] = '/doc/'
+    end
+
+    @gem_dirs.each do |gem_dir|
+      file_handlers.each do |mount_point, mount_dir|
+        @server.mount(mount_point, WEBrick::HTTPServlet::FileHandler,
+                      File.join(gem_dir, mount_dir), true)
+      end
     end
 
     trap("INT") { @server.shutdown; exit! }

data/lib/rubygems/source.rb

@@ -0,0 +1,144 @@
+require 'uri'
+require 'fileutils'
+
+class Gem::Source
+  FILES = {
+    :released   => 'specs',
+    :latest     => 'latest_specs',
+    :prerelease => 'prerelease_specs',
+  }
+
+  def initialize(uri)
+    unless uri.kind_of? URI
+      uri = URI.parse(uri.to_s)
+    end
+
+    @uri = uri
+    @api_uri = nil
+  end
+
+  attr_reader :uri
+
+  def api_uri
+    require 'rubygems/remote_fetcher'
+    @api_uri ||= Gem::RemoteFetcher.fetcher.api_endpoint uri
+  end
+
+  def <=>(other)
+    if !@uri
+      return 0 unless other.uri
+      return -1
+    end
+
+    return 1 if !other.uri
+
+    @uri.to_s <=> other.uri.to_s
+  end
+
+  include Comparable
+
+  def ==(other)
+    case other
+    when self.class
+      @uri == other.uri
+    else
+      false
+    end
+  end
+
+  alias_method :eql?, :==
+
+  def hash
+    @uri.hash
+  end
+
+  ##
+  # Returns the local directory to write +uri+ to.
+
+  def cache_dir(uri)
+    # Correct for windows paths
+    escaped_path = uri.path.sub(/^\/([a-z]):\//i, '/\\1-/')
+    root = File.join Gem.user_home, '.gem', 'specs'
+    File.join root, "#{uri.host}%#{uri.port}", File.dirname(escaped_path)
+  end
+
+  def update_cache?
+    @update_cache ||= File.stat(Gem.user_home).uid == Process.uid
+  end
+
+  def fetch_spec(name)
+    fetcher = Gem::RemoteFetcher.fetcher
+
+    spec_file_name = name.spec_name
+
+    uri = @uri + "#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}"
+
+    cache_dir = cache_dir uri
+
+    local_spec = File.join cache_dir, spec_file_name
+
+    if File.exist? local_spec then
+      spec = Gem.read_binary local_spec
+      spec = Marshal.load(spec) rescue nil
+      return spec if spec
+    end
+
+    uri.path << '.rz'
+
+    spec = fetcher.fetch_path uri
+    spec = Gem.inflate spec
+
+    if update_cache? then
+      FileUtils.mkdir_p cache_dir
+
+      open local_spec, 'wb' do |io|
+        io.write spec
+      end
+    end
+
+    # TODO: Investigate setting Gem::Specification#loaded_from to a URI
+    Marshal.load spec
+  end
+
+  ##
+  # Loads +type+ kind of specs fetching from +@uri+ if the on-disk cache is
+  # out of date.
+  #
+  # +type+ is one of the following:
+  #
+  # :released   => Return the list of all released specs
+  # :latest     => Return the list of only the highest version of each gem
+  # :prerelease => Return the list of all prerelease only specs
+  #
+
+  def load_specs(type)
+    file       = FILES[type]
+    fetcher    = Gem::RemoteFetcher.fetcher
+    file_name  = "#{file}.#{Gem.marshal_version}"
+    spec_path  = @uri + "#{file_name}.gz"
+    cache_dir  = cache_dir spec_path
+    local_file = File.join(cache_dir, file_name)
+    retried    = false
+
+    FileUtils.mkdir_p cache_dir if update_cache?
+
+    spec_dump = fetcher.cache_update_path(spec_path, local_file)
+
+    begin
+      Gem::NameTuple.from_list Marshal.load(spec_dump)
+    rescue ArgumentError
+      if update_cache? && !retried
+        FileUtils.rm local_file
+        retried = true
+        retry
+      else
+        raise Gem::Exception.new("Invalid spec cache file in #{local_file}")
+      end
+    end
+  end
+
+  def download(spec, dir=Dir.pwd)
+    fetcher = Gem::RemoteFetcher.fetcher
+    fetcher.download spec, @uri.to_s, dir
+  end
+end

data/lib/rubygems/source_list.rb

@@ -0,0 +1,87 @@
+require 'rubygems/source'
+
+class Gem::SourceList
+  def initialize
+    @sources = []
+  end
+
+  attr_reader :sources
+
+  def self.from(ary)
+    list = new
+
+    if ary
+      ary.each do |x|
+        list << x
+      end
+    end
+
+    return list
+  end
+
+  def initialize_copy(other)
+    @sources = @sources.dup
+  end
+
+  def <<(obj)
+    src = case obj
+          when URI
+            Gem::Source.new(obj)
+          when Gem::Source
+            obj
+          else
+            Gem::Source.new(URI.parse(obj))
+          end
+
+    @sources << src
+    src
+  end
+
+  def replace(other)
+    @sources.clear
+
+    other.each do |x|
+      self << x
+    end
+
+    self
+  end
+
+  def each
+    @sources.each { |s| yield s.uri.to_s }
+  end
+
+  def each_source(&b)
+    @sources.each(&b)
+  end
+
+  def ==(other)
+    to_a == other
+  end
+
+  def to_a
+    @sources.map { |x| x.uri.to_s }
+  end
+
+  alias_method :to_ary, :to_a
+
+  def first
+    @sources.first
+  end
+
+  def include?(other)
+    if other.kind_of? Gem::Source
+      @sources.include? other
+    else
+      @sources.find { |x| x.uri.to_s == other.to_s }
+    end
+  end
+
+  def delete(uri)
+    if uri.kind_of? Gem::Source
+      @sources.delete uri
+    else
+      @sources.delete_if { |x| x.uri.to_s == uri.to_s }
+    end
+  end
+end