class Object

Public Instance Methods

/api/v1/dependencies() click to toggle source

Return gem dependencies as binary

@return [nil]

# File lib/gemirro/server.rb, line 92
get '/api/v1/dependencies' do
  content_type 'application/octet-stream'
  query_gems.any? ? Marshal.dump(query_gems_list) : 200
end
/api/v1/dependencies.json() click to toggle source

Return gem dependencies as json

@return [nil]

# File lib/gemirro/server.rb, line 102
get '/api/v1/dependencies.json' do
  content_type 'application/json'
  query_gems.any? ? JSON.dump(query_gems_list) : {}
end
create_pid() click to toggle source
# File lib/gemirro/cli/server.rb, line 44
def create_pid
  File.open(@pid_file, 'w') do |f|
    f.write(Process.pid.to_s)
  end
rescue Errno::EACCES
  $stdout.reopen @orig_stdout
  puts "Error: Can't write to #{@pid_file} - Permission denied"
  exit!
end
destroy_pid() click to toggle source
# File lib/gemirro/cli/server.rb, line 54
def destroy_pid
  File.delete(@pid_file) if File.exist?(@pid_file) && pid == Process.pid
end
escape(string) click to toggle source

Escape string

@param [String] string @return [String]

# File lib/gemirro/server.rb, line 272
def escape(string)
  Rack::Utils.escape_html(string)
end
fetch_gem(resource) click to toggle source

Try to fetch gem and download its if it's possible, and build and install indicies.

@param [String] resource @return [Indexer]

# File lib/gemirro/server.rb, line 131
def fetch_gem(resource)
  return unless Utils.configuration.fetch_gem

  name = File.basename(resource)
  result = name.match(URI_REGEXP)
  return unless result

  gem_name, gem_version, gem_platform, gem_type = result.captures
  return unless gem_name && gem_version

  begin
    gem = Utils.stored_gem(gem_name, gem_version, gem_platform)
    gem.gemspec = true if gem_type == GEMSPEC_TYPE

    return if Utils.gems_fetcher.gem_exists?(gem.filename(gem_version)) && gem_type == GEM_TYPE
    return if Utils.gems_fetcher.gemspec_exists?(gem.gemspec_filename(gem_version)) && gem_type == GEMSPEC_TYPE

    Utils.logger
         .info("Try to download #{gem_name} with version #{gem_version}")
    Utils.gems_fetcher.source.gems.clear
    Utils.gems_fetcher.source.gems.push(gem)
    Utils.gems_fetcher.fetch

    update_indexes if Utils.configuration.update_on_fetch
  rescue StandardError => e
    Utils.logger.error(e)
  end
end
gem_dependencies(gem_name) click to toggle source

List of versions and dependencies of each version from a gem name.

@return [Array]

# File lib/gemirro/server.rb, line 210
def gem_dependencies(gem_name)
  Utils.cache.cache(gem_name) do
    gems = Utils.gems_collection(false)
    gem_collection = gems.find_by_name(gem_name)

    return '' if gem_collection.nil?

    gem_collection = Parallel.map(gem_collection, in_threads: 4) do |gem|
      [gem, spec_for(gem.name, gem.number, gem.platform)]
    end
    gem_collection.compact!

    Parallel.map(gem_collection, in_threads: 4) do |gem, spec|
      dependencies = spec.dependencies.select do |d|
        d.type == :runtime
      end

      dependencies = Parallel.map(dependencies, in_threads: 4) do |d|
        [d.name.is_a?(Array) ? d.name.first : d.name, d.requirement.to_s]
      end

      {
        name: gem.name,
        number: gem.number,
        platform: gem.platform,
        dependencies: dependencies
      }
    end
  end
end
homepage(spec) click to toggle source

Homepage link

@param [Gem] spec @return [String]

# File lib/gemirro/server.rb, line 282
def homepage(spec)
  URI.parse(Addressable::URI.escape(spec.homepage))
end
load_configuration(opts) click to toggle source
# File lib/gemirro/cli/server.rb, line 25
def load_configuration(opts)
  Gemirro::CLI.load_configuration(opts[:c])
  config = Gemirro.configuration
  config.logger_level = opts[:l] if opts[:l]
  unless File.directory?(config.destination)
    config.logger.error("The directory #{config.destination} does not exist")
    abort
  end

  @pid_file = File.expand_path(File.join(config.destination,
                                         '..',
                                         'gemirro.pid'))
  require 'gemirro/server'
end
pid() click to toggle source
# File lib/gemirro/cli/server.rb, line 58
def pid
  File.open(@pid_file, 'r') do |f|
    return f.gets.to_i
  end
rescue Errno::ENOENT
  puts "Error: PID File not found #{@pid_file}"
end
query_gems() click to toggle source

Return all gems pass to query

@return [Array]

# File lib/gemirro/server.rb, line 184
def query_gems
  params[:gems].to_s.split(',')
end
query_gems_list() click to toggle source

Return gems list from query params

@return [Array]

# File lib/gemirro/server.rb, line 193
def query_gems_list
  Utils.gems_collection(false) # load collection
  gems = Parallel.map(query_gems, in_threads: 4) do |query_gem|
    gem_dependencies(query_gem)
  end

  gems.flatten!
  gems.reject!(&:empty?)
  gems
end
restart() click to toggle source
# File lib/gemirro/cli/server.rb, line 100
def restart
  stop
  start
end
running?(process_id) click to toggle source
# File lib/gemirro/cli/server.rb, line 114
def running?(process_id)
  return false if process_id.nil?

  Process.getpgid(process_id.to_i) != -1
rescue Errno::ESRCH
  false
end
spec_for(gemname, version, platform = 'ruby') click to toggle source

Return gem specification from gemname and version

@param [String] gemname @param [String] version @return [::Gem::Specification]

# File lib/gemirro/server.rb, line 249
def spec_for(gemname, version, platform = 'ruby')
  gem = Utils.stored_gem(gemname, version.to_s, platform)
  gemspec_path = File.join('quick',
                           Gemirro::Configuration.marshal_identifier,
                           gem.gemspec_filename)
  spec_file = File.join(settings.public_folder,
                        gemspec_path)
  fetch_gem(gemspec_path) unless File.exist?(spec_file)

  return unless File.exist?(spec_file)

  File.open(spec_file, 'r') do |uz_file|
    uz_file.binmode
    Marshal.load(::Gem.inflate(uz_file.read))
  end
end
start() click to toggle source
# File lib/gemirro/cli/server.rb, line 66
def start
  puts 'Starting...'
  if File.exist?(@pid_file) && running?(pid)
    puts "Error: #{$PROGRAM_NAME} already running"
    abort
  end

  Process.daemon if Gemirro::Utils.configuration.server.daemonize
  create_pid
  $stdout.reopen @orig_stdout
  puts "done! (PID is #{pid})\n"
  Gemirro::Server.run!
  destroy_pid
  $stdout.reopen '/dev/null', 'a'
end
status() click to toggle source
# File lib/gemirro/cli/server.rb, line 105
def status
  if running?(pid)
    puts "#{$PROGRAM_NAME} is running"
  else
    puts "#{$PROGRAM_NAME} is not running"
    abort
  end
end
stop() click to toggle source
# File lib/gemirro/cli/server.rb, line 82
def stop
  process_pid = pid
  return if process_pid.nil?

  begin
    Process.kill('TERM', process_pid)
    Timeout.timeout(30) { sleep 0.1 while running?(process_pid) }
  rescue Errno::ESRCH
    puts "Error: Couldn't find process with PID #{process_pid}"
    exit!
  rescue Timeout::Error
    puts 'timeout while sending TERM signal, sending KILL signal now... '
    Process.kill('KILL', process_pid)
    destroy_pid
  end
  puts 'done!'
end
unknown() click to toggle source

Display information about one gem

@return [nil]

# File lib/gemirro/server.rb, line 69
get('/gem/:gemname') do
  gems = Utils.gems_collection
  gem = gems.find_by_name(params[:gemname])
  return not_found if gem.nil?

  erb(:gem, {}, gem: gem)
end
update_indexes() click to toggle source

Update indexes files

@return [Indexer]

# File lib/gemirro/server.rb, line 165
def update_indexes
  indexer = Gemirro::Indexer.new(Utils.configuration.destination)
  indexer.only_origin = true
  indexer.ui = ::Gem::SilentUI.new

  Utils.logger.info('Generating indexes')
  indexer.update_index
  indexer.updated_gems.each do |gem|
    Utils.cache.flush_key(File.basename(gem))
  end
rescue SystemExit => e
  Utils.logger.info(e.message)
end