require 'fileutils' require 'rubygems' require 'rubygems/source_info_cache_entry' require 'rubygems/user_interaction' ## # SourceInfoCache stores a copy of the gem index for each gem source. # # There are two possible cache locations, the system cache and the user cache: # * The system cache is preferred if it is writable or can be created. # * The user cache is used otherwise # # Once a cache is selected, it will be used for all operations. # SourceInfoCache will not switch between cache files dynamically. # # Cache data is a Hash mapping a source URI to a SourceInfoCacheEntry. # #-- # To keep things straight, this is how the cache objects all fit together: # # Gem::SourceInfoCache # @cache_data = { # source_uri => Gem::SourceInfoCacheEntry # @size = source index size # @source_index = Gem::SourceIndex # ... # } class Gem::SourceInfoCache include Gem::UserInteraction ## # The singleton Gem::SourceInfoCache. If +all+ is true, a full refresh will # be performed if the singleton instance is being initialized. def self.cache(all = false) return @cache if @cache @cache = new @cache.refresh all if Gem.configuration.update_sources @cache end def self.cache_data cache.cache_data end ## # The name of the system cache file. def self.latest_system_cache_file File.join File.dirname(system_cache_file), "latest_#{File.basename system_cache_file}" end ## # The name of the latest user cache file. def self.latest_user_cache_file File.join File.dirname(user_cache_file), "latest_#{File.basename user_cache_file}" end ## # Reset all singletons, discarding any changes. def self.reset @cache = nil @system_cache_file = nil @user_cache_file = nil end ## # Search all source indexes. See Gem::SourceInfoCache#search. def self.search(*args) cache.search(*args) end ## # Search all source indexes returning the source_uri. See # Gem::SourceInfoCache#search_with_source. def self.search_with_source(*args) cache.search_with_source(*args) end ## # The name of the system cache file. (class method) def self.system_cache_file @system_cache_file ||= Gem.default_system_source_cache_dir end ## # The name of the user cache file. def self.user_cache_file @user_cache_file ||= ENV['GEMCACHE'] || Gem.default_user_source_cache_dir end def initialize # :nodoc: @cache_data = nil @cache_file = nil @dirty = false @only_latest = true end ## # The most recent cache data. def cache_data return @cache_data if @cache_data cache_file # HACK writable check @only_latest = true @cache_data = read_cache_data latest_cache_file @cache_data end ## # The name of the cache file. def cache_file return @cache_file if @cache_file @cache_file = (try_file(system_cache_file) or try_file(user_cache_file) or raise "unable to locate a writable cache file") end ## # Write the cache to a local file (if it is dirty). def flush write_cache if @dirty @dirty = false end def latest_cache_data latest_cache_data = {} cache_data.each do |repo, sice| latest = sice.source_index.latest_specs new_si = Gem::SourceIndex.new new_si.add_specs(*latest) latest_sice = Gem::SourceInfoCacheEntry.new new_si, sice.size latest_cache_data[repo] = latest_sice end latest_cache_data end ## # The name of the latest cache file. def latest_cache_file File.join File.dirname(cache_file), "latest_#{File.basename cache_file}" end ## # The name of the latest system cache file. def latest_system_cache_file self.class.latest_system_cache_file end ## # The name of the latest user cache file. def latest_user_cache_file self.class.latest_user_cache_file end ## # Merges the complete cache file into this Gem::SourceInfoCache. def read_all_cache_data if @only_latest then @only_latest = false all_data = read_cache_data cache_file cache_data.update all_data do |source_uri, latest_sice, all_sice| all_sice.source_index.gems.update latest_sice.source_index.gems Gem::SourceInfoCacheEntry.new all_sice.source_index, latest_sice.size end begin refresh true rescue Gem::RemoteFetcher::FetchError end end end ## # Reads cached data from +file+. def read_cache_data(file) # Marshal loads 30-40% faster from a String, and 2MB on 20061116 is small data = open file, 'rb' do |fp| fp.read end cache_data = Marshal.load data cache_data.each do |url, sice| next unless sice.is_a?(Hash) update cache = sice['cache'] size = sice['size'] if cache.is_a?(Gem::SourceIndex) and size.is_a?(Numeric) then new_sice = Gem::SourceInfoCacheEntry.new cache, size cache_data[url] = new_sice else # irreperable, force refetch. reset_cache_for url, cache_data end end cache_data rescue Errno::ENOENT {} rescue => e if Gem.configuration.really_verbose then say "Exception during cache_data handling: #{e.class} - #{e}" say "Cache file was: #{file}" say "\t#{e.backtrace.join "\n\t"}" end {} end ## # Refreshes each source in the cache from its repository. If +all+ is # false, only latest gems are updated. def refresh(all) Gem.sources.each do |source_uri| cache_entry = cache_data[source_uri] if cache_entry.nil? then cache_entry = Gem::SourceInfoCacheEntry.new nil, 0 cache_data[source_uri] = cache_entry end update if cache_entry.refresh source_uri, all end flush end def reset_cache_for(url, cache_data) say "Reseting cache for #{url}" if Gem.configuration.really_verbose sice = Gem::SourceInfoCacheEntry.new Gem::SourceIndex.new, 0 sice.refresh url, false # HACK may be unnecessary, see ::cache and #refresh cache_data[url] = sice cache_data end def reset_cache_data @cache_data = nil @only_latest = true end ## # Force cache file to be reset, useful for integration testing of rubygems def reset_cache_file @cache_file = nil end ## # Searches all source indexes. See Gem::SourceIndex#search for details on # +pattern+ and +platform_only+. If +all+ is set to true, the full index # will be loaded before searching. def search(pattern, platform_only = false, all = false) read_all_cache_data if all cache_data.map do |source_uri, sic_entry| next unless Gem.sources.include? source_uri # TODO - Remove this gunk after 2008/11 unless pattern.kind_of?(Gem::Dependency) pattern = Gem::Dependency.new(pattern, Gem::Requirement.default) end sic_entry.source_index.search pattern, platform_only end.flatten.compact end # Searches all source indexes for +pattern+. If +only_platform+ is true, # only gems matching Gem.platforms will be selected. Returns an Array of # pairs containing the Gem::Specification found and the source_uri it was # found at. def search_with_source(pattern, only_platform = false, all = false) read_all_cache_data if all results = [] cache_data.map do |source_uri, sic_entry| next unless Gem.sources.include? source_uri # TODO - Remove this gunk after 2008/11 unless pattern.kind_of?(Gem::Dependency) pattern = Gem::Dependency.new(pattern, Gem::Requirement.default) end sic_entry.source_index.search(pattern, only_platform).each do |spec| results << [spec, source_uri] end end results end ## # Set the source info cache data directly. This is mainly used for unit # testing when we don't want to read a file system to grab the cached source # index information. The +hash+ should map a source URL into a # SourceInfoCacheEntry. def set_cache_data(hash) @cache_data = hash update end ## # The name of the system cache file. def system_cache_file self.class.system_cache_file end ## # Determine if +path+ is a candidate for a cache file. Returns +path+ if # it is, nil if not. def try_file(path) return path if File.writable? path return nil if File.exist? path dir = File.dirname path unless File.exist? dir then begin FileUtils.mkdir_p dir rescue RuntimeError, SystemCallError return nil end end return path if File.writable? dir nil end ## # Mark the cache as updated (i.e. dirty). def update @dirty = true end ## # The name of the user cache file. def user_cache_file self.class.user_cache_file end ## # Write data to the proper cache files. def write_cache if not File.exist?(cache_file) or not @only_latest then open cache_file, 'wb' do |io| io.write Marshal.dump(cache_data) end end open latest_cache_file, 'wb' do |io| io.write Marshal.dump(latest_cache_data) end end reset end