gemirro 2.0.0 → 3.0.1

data/lib/gemirro/cli/server.rb

@@ -1,119 +1,178 @@
 # frozen_string_literal: true
 
-Gemirro::CLI.options.command 'server' do
-  banner 'Usage: gemirro server [OPTIONS]'
-  description 'Manage web server'
-  separator "\nOptions:\n"
-
-  on :start, 'Run web server'
-  on :stop, 'Stop web server'
-  on :restart, 'Restart web server'
-  on :status, 'Status of web server'
-  on :c=, :config=, 'Path to the configuration file'
-  on :l=, :log_level=, 'Set logger level'
-
-  @pid_file = nil
-
-  run do |opts, _args|
-    load_configuration(opts)
-    start if opts[:start]
-    stop if opts[:stop]
-    restart if opts[:restart]
-    status if opts[:status]
-  end
-
-  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
-
-  # Copy stdout because we'll need to reopen it later on
-  @orig_stdout = $stdout.clone
-  $PROGRAM_NAME = 'gemirro'
-
-  def create_pid
-    File.write(@pid_file, Process.pid.to_s)
-  rescue Errno::EACCES
-    $stdout.reopen @orig_stdout
-    puts "Error: Can't write to #{@pid_file} - Permission denied"
-    exit!
-  end
-
-  def destroy_pid
-    File.delete(@pid_file) if File.exist?(@pid_file) && pid == Process.pid
-  end
-
-  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
-
-  def start
-    puts 'Starting...'
-    if File.exist?(@pid_file) && running?(pid)
-      puts "Error: #{$PROGRAM_NAME} already running"
-      abort
+require 'timeout'
+
+module Gemirro
+  module CLI
+    # `gemirro server` command
+    module ServerCommand
+      ##
+      # @param [Array] argv
+      #
+      def self.run(argv)
+        options = {}
+        option_parser(options).parse!(argv)
+
+        config   = load_configuration(options)
+        pid_file = pid_file_for(config)
+
+        start(pid_file) if options[:start]
+        stop(pid_file) if options[:stop]
+        restart(pid_file) if options[:restart]
+        status(pid_file) if options[:status]
+      end
+
+      ##
+      # @param [Hash] options
+      # @return [Gemirro::Configuration]
+      #
+      def self.load_configuration(options)
+        Gemirro::CLI.load_configuration(options[:config])
+        config = Gemirro.configuration
+        config.logger_level = options[:log_level] if options[:log_level]
+        Gemirro::CLI.ensure_destination!(config)
+        require 'gemirro/server'
+
+        config
+      end
+
+      ##
+      # @param [Gemirro::Configuration] config
+      # @return [String]
+      #
+      def self.pid_file_for(config)
+        File.expand_path(File.join(config.destination, '..', 'gemirro.pid'))
+      end
+
+      ##
+      # @param [String] pid_file
+      # @param [IO] orig_stdout
+      #
+      def self.create_pid(pid_file, orig_stdout)
+        File.write(pid_file, Process.pid.to_s)
+      rescue Errno::EACCES
+        $stdout.reopen orig_stdout
+        puts "Error: Can't write to #{pid_file} - Permission denied"
+        exit!
+      end
+
+      ##
+      # @param [String] pid_file
+      #
+      def self.destroy_pid(pid_file)
+        File.delete(pid_file) if File.exist?(pid_file) && pid(pid_file) == Process.pid
+      end
+
+      ##
+      # @param [String] pid_file
+      # @return [Integer]
+      #
+      def self.pid(pid_file)
+        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
+
+      ##
+      # @param [String] pid_file
+      #
+      def self.start(pid_file)
+        puts 'Starting...'
+        if File.exist?(pid_file) && running?(pid(pid_file))
+          puts "Error: #{$PROGRAM_NAME} already running"
+          abort
+        end
+
+        # Copy stdout because we'll need to reopen it later on
+        orig_stdout = $stdout.clone
+
+        Process.daemon if Gemirro::Utils.configuration.server.daemonize
+        create_pid(pid_file, orig_stdout)
+        $stdout.reopen orig_stdout
+        puts "done! (PID is #{pid(pid_file)})\n"
+        Gemirro::Server.run!
+        destroy_pid(pid_file)
+        $stdout.reopen File::NULL, 'a'
+      end
+
+      ##
+      # @param [String] pid_file
+      #
+      def self.stop(pid_file)
+        process_pid = pid(pid_file)
+        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(pid_file)
+        end
+        puts 'done!'
+      end
+
+      ##
+      # @param [String] pid_file
+      #
+      def self.restart(pid_file)
+        stop(pid_file)
+        start(pid_file)
+      end
+
+      ##
+      # @param [String] pid_file
+      #
+      def self.status(pid_file)
+        if running?(pid(pid_file))
+          puts "#{$PROGRAM_NAME} is running"
+        else
+          puts "#{$PROGRAM_NAME} is not running"
+          abort
+        end
+      end
+
+      ##
+      # @param [Integer] process_id
+      # @return [TrueClass|FalseClass]
+      #
+      def self.running?(process_id)
+        return false if process_id.nil?
+
+        Process.getpgid(process_id.to_i) != -1
+      rescue Errno::ESRCH
+        false
+      end
+
+      ##
+      # @param [Hash] options
+      # @return [OptionParser]
+      #
+      def self.option_parser(options)
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: gemirro server [OPTIONS]'
+          opts.separator ''
+          opts.separator 'Options:'
+          opts.separator ''
+
+          opts.on('--start', 'Run web server') { options[:start] = true }
+          opts.on('--stop', 'Stop web server') { options[:stop] = true }
+          opts.on('--restart', 'Restart web server') { options[:restart] = true }
+          opts.on('--status', 'Status of web server') { options[:status] = true }
+          opts.on('-c', '--config CONFIG', 'Path to the configuration file') { |v| options[:config] = v }
+          opts.on('-l', '--log_level LEVEL', 'Set logger level') { |v| options[:log_level] = v }
+          opts.on('-h', '--help', 'Display this help message.') do
+            puts opts
+            exit
+          end
+        end
+      end
     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 File::NULL, 'a'
-  end
-
-  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
-
-  def restart
-    stop
-    start
-  end
-
-  def status
-    if running?(pid)
-      puts "#{$PROGRAM_NAME} is running"
-    else
-      puts "#{$PROGRAM_NAME} is not running"
-      abort
-    end
-  end
-
-  def running?(process_id)
-    return false if process_id.nil?
-
-    Process.getpgid(process_id.to_i) != -1
-  rescue Errno::ESRCH
-    false
   end
 end

data/lib/gemirro/cli/update.rb

@@ -1,27 +1,52 @@
 # frozen_string_literal: true
 
-Gemirro::CLI.options.command 'update' do
-  banner 'Usage: gemirro update [OPTIONS]'
-  description 'Updates the list of Gems'
-  separator "\nOptions:\n"
+module Gemirro
+  module CLI
+    # `gemirro update` command
+    module UpdateCommand
+      ##
+      # @param [Array] argv
+      #
+      def self.run(argv)
+        options = {}
+        option_parser(options).parse!(argv)
 
-  on :c=, :config=, 'Path to the configuration file'
-  on :l=, :log_level=, 'Set logger level'
+        Gemirro::CLI.load_configuration(options[:config])
+        config = Gemirro.configuration
+        config.logger_level = options[:log_level] if options[:log_level]
 
-  run do |opts, _args|
-    Gemirro::CLI.load_configuration(opts[:c])
-    config.logger_level = opts[:l] if opts[:l]
+        source = config.source
+        versions = Gemirro::VersionsFetcher.new(source).fetch
+        gems     = Gemirro::GemsFetcher.new(source, versions)
 
-    source = Gemirro.configuration.source
-    versions = Gemirro::VersionsFetcher.new(source).fetch
-    gems     = Gemirro::GemsFetcher.new(source, versions)
+        gems.fetch
 
-    gems.fetch
+        source.gems.each do |gem|
+          gem.gemspec = true
+        end
 
-    source.gems.each do |gem|
-      gem.gemspec = true
-    end
+        gems.fetch
+      end
+
+      ##
+      # @param [Hash] options
+      # @return [OptionParser]
+      #
+      def self.option_parser(options)
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: gemirro update [OPTIONS]'
+          opts.separator ''
+          opts.separator 'Options:'
+          opts.separator ''
 
-    gems.fetch
+          opts.on('-c', '--config CONFIG', 'Path to the configuration file') { |v| options[:config] = v }
+          opts.on('-l', '--log_level LEVEL', 'Set logger level') { |v| options[:log_level] = v }
+          opts.on('-h', '--help', 'Display this help message.') do
+            puts opts
+            exit
+          end
+        end
+      end
+    end
   end
 end

data/lib/gemirro/cli.rb

@@ -6,21 +6,62 @@ module Gemirro
   # CLI mode
   module CLI
     ##
-    # Hash containing the default Slop options.
+    # Names of the commands available, in the order they're listed by
+    # `--help`, together with a short description.
     #
     # @return [Hash]
     #
-    SLOP_OPTIONS = {
-      strict: true,
-      help: true,
-      banner: 'Usage: gemirro [COMMAND] [OPTIONS]'
+    COMMANDS = {
+      'index' => 'Retrieve specs list from source.',
+      'init' => 'Sets up a new mirror',
+      'list' => 'List available gems.',
+      'server' => 'Manage web server',
+      'update' => 'Updates the list of Gems'
     }.freeze
 
     ##
-    # @return [Slop]
+    # Entry point, called from `bin/gemirro`.
     #
-    def self.options
-      @options ||= default_options
+    # @param [Array] argv
+    #
+    def self.run(argv = ARGV)
+      $PROGRAM_NAME = 'gemirro'
+      command = argv.first
+      case command
+      when '-v', '--version'
+        puts version_information
+      when '-h', '--help', nil
+        puts usage
+      when *COMMANDS.keys
+        argv.shift
+        require "gemirro/cli/#{command}"
+        const_get("#{command.capitalize}Command").run(argv)
+      else
+        puts "Unknown command: #{command}"
+        puts usage
+        exit 1
+      end
+    rescue OptionParser::ParseError => e
+      puts e.message
+      exit 1
+    end
+
+    ##
+    # Returns a String containing the top level usage/help banner.
+    #
+    # @return [String]
+    #
+    def self.usage
+      lines = ['Usage: gemirro [COMMAND] [OPTIONS]', '', 'Options:', '']
+      lines << '    -v, --version      Shows the current version'
+      lines << '    -h, --help         Display this help message.'
+      lines << '' << 'Available commands:' << ''
+      COMMANDS.each do |name, description|
+        lines << "  #{name.ljust(9)}#{description}"
+      end
+      lines << '' << 'See `<command> --help` for more information on a specific command.'
+
+      lines.join("\n")
     end
 
     ##
@@ -41,19 +82,6 @@ module Gemirro
       require(config_file)
     end
 
-    ##
-    # @return [Slop]
-    #
-    def self.default_options
-      Slop.new(SLOP_OPTIONS.dup) do
-        separator "\nOptions:\n"
-
-        on :v, :version, 'Shows the current version' do
-          puts CLI.version_information
-        end
-      end
-    end
-
     ##
     # Returns a String containing some platform/version related information.
     #
@@ -62,5 +90,18 @@ module Gemirro
     def self.version_information
       "gemirro v#{Gemirro::VERSION} on #{RUBY_DESCRIPTION}"
     end
+
+    ##
+    # Aborts with an error if the configured destination directory
+    # doesn't exist yet.
+    #
+    # @param [Gemirro::Configuration] config
+    #
+    def self.ensure_destination!(config)
+      return if File.directory?(config.destination)
+
+      config.logger.error("The directory #{config.destination} does not exist")
+      abort
+    end
   end
 end

data/lib/gemirro/configuration.rb

@@ -166,9 +166,11 @@ module Gemirro
     # @param [String] version
     #
     def ignore_gem(name, version, platform)
-      ignored_gems[platform] ||= {}
-      ignored_gems[platform][name] ||= []
-      ignored_gems[platform][name] << version
+      ignored_gems_mutex.synchronize do
+        ignored_gems[platform] ||= {}
+        ignored_gems[platform][name] ||= []
+        ignored_gems[platform][name] << version
+      end
     end
 
     ##
@@ -179,13 +181,25 @@ module Gemirro
     # @return [TrueClass|FalseClass]
     #
     def ignore_gem?(name, version, platform)
-      if ignored_gems[platform][name]
-        ignored_gems[platform][name].include?(version)
-      else
-        false
+      ignored_gems_mutex.synchronize do
+        if ignored_gems[platform][name]
+          ignored_gems[platform][name].include?(version)
+        else
+          false
+        end
       end
     end
 
+    ##
+    # Guards {#ignored_gems} against concurrent mutation, since gems can
+    # be fetched from multiple threads at once (see {GemsFetcher#fetch}).
+    #
+    # @return [Mutex]
+    #
+    def ignored_gems_mutex
+      @ignored_gems_mutex ||= Mutex.new
+    end
+
     ##
     # Define the source to mirror.
     #
@@ -193,9 +207,9 @@ module Gemirro
     # @param [String] url
     # @param [Proc] block
     #
-    def define_source(name, url, &block)
+    def define_source(name, url, &)
       source = Source.new(name, url)
-      source.instance_eval(&block)
+      source.instance_eval(&)
 
       @source = source
     end

data/lib/gemirro/gem_version.rb

@@ -17,6 +17,7 @@ module Gemirro
   #
   class GemVersion
     include Comparable
+
     attr_reader :name, :number, :platform
 
     ##

data/lib/gemirro/gem_version_collection.rb

@@ -59,8 +59,8 @@ module Gemirro
     ##
     # Each method
     #
-    def each(&block)
-      @gems.each(&block)
+    def each(&)
+      @gems.each(&)
     end
 
     ##
@@ -69,7 +69,7 @@ module Gemirro
     # @param [Proc] block
     # @return [Array]
     #
-    def by_name(&block)
+    def by_name(&)
       if @grouped.nil?
         @grouped = @gems.group_by(&:name).map do |name, collection|
           [name, GemVersionCollection.new(collection)]
@@ -85,7 +85,7 @@ module Gemirro
       end
 
       if block_given?
-        @grouped.each(&block)
+        @grouped.each(&)
       else
         @grouped
       end

data/lib/gemirro/gems_fetcher.rb

@@ -23,10 +23,12 @@ module Gemirro
     end
 
     ##
-    # Fetches the Gems.
+    # Fetches the Gems, in parallel across
+    # `Gemirro.configuration.update_thread_count` threads since each Gem is
+    # an independent network round-trip.
     #
     def fetch
-      @source.gems.each do |gem|
+      Parallel.each(@source.gems, in_threads: Utils.configuration.update_thread_count) do |gem|
         versions_for(gem).each do |versions|
           gem.platform = versions[1] if versions
           version = versions[0] if versions
@@ -78,11 +80,7 @@ module Gemirro
     #
     def fetch_gemspec(gem, version)
       filename = gem.gemspec_filename(version)
-      satisfied = if gem.only_latest?
-                    true
-                  else
-                    gem.requirement.satisfied_by?(version)
-                  end
+      satisfied = gem.only_latest? || gem.requirement.satisfied_by?(version)
 
       if gemspec_exists?(filename) || !satisfied
         Utils.logger.debug("Skipping #{filename}")
@@ -162,8 +160,8 @@ module Gemirro
     ##
     # @see Gemirro::Configuration#ignore_gem?
     #
-    def ignore_gem?(*args)
-      Utils.configuration.ignore_gem?(*args)
+    def ignore_gem?(*)
+      Utils.configuration.ignore_gem?(*)
     end
   end
 end