hotdog 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e940923c28e0c281c17da003c2e2d3e0135efe78
-  data.tar.gz: 54316787a42899bdfb71c7900eebe7b600dbabe4
+  metadata.gz: f1b8937e6ed17779e09622476dae786c9f7e04a4
+  data.tar.gz: 59d5cf9204f2b3cf7a272734ca62253f09b01347
 SHA512:
-  metadata.gz: ed99d65cefb7ba8ee9a99f8d63855fc6fb234bda876a92bab531dd29574ffdea86c200a4a26e890f7fe18d17e7b8ec02164a69c6929cd12af6b37b5b810c0715
-  data.tar.gz: 5bf40e301f0567576028475d95017088bff3547ab0a55da2430de8ea9fcdb849ae74202767751a8fb744b5a7505663afb2b842328ee23f5d0ad7daf30ea26993
+  metadata.gz: c763c88d2083cb10007195b7962edd980a47f0145a613081b1a5c9713da91ffed3350daa7bdd1317f7e9d00b928141f69a5005e6fa2026deb127a6e6a1b71173
+  data.tar.gz: 796c96d4b2c954690fc9bbf97339d8ebe4213fc7c3c92fafc5c5a67b90914c208ad4eea7c3a2b21f5c871dc4562c002ff561b443321d949c24038b3491743caf

data/lib/hotdog/application.rb

@@ -53,44 +53,47 @@ module Hotdog
       args = @optparse.order(argv)
 
       begin
-        command = ( args.shift || "help" )
-        get_command(command).tap do |cmd|
-          @optparse.banner = "Usage: hotdog #{command} [options]"
-          cmd.define_options(@optparse, @options)
-          args = cmd.parse_options(@optparse, args)
-          unless options[:api_key]
-            raise("DATADOG_API_KEY is not set")
-          end
-
-          unless options[:application_key]
-            raise("DATADOG_APPLICATION_KEY is not set")
-          end
-
-          if options[:format] == "ltsv"
-            options[:headers] = true
-          end
-
-          options[:formatter] = get_formatter(options[:format])
-
-          if options[:debug] or options[:verbose]
-            options[:logger].level = Logger::DEBUG
-          else
-            options[:logger].level = Logger::INFO
-          end
-
-          cmd.run(args, @options)
+        command_name = ( args.shift || "help" )
+        begin
+          command = get_command(command_name)
+        rescue NameError
+          STDERR.puts("hotdog: '#{command_name}' is not a hotdog command.")
+          get_command("help").parse_options(@optparse, ["commands"])
+          exit(1)
         end
-      rescue OptionParser::ParseError => error
-        STDERR.puts("hotdog: #{error.message}")
-        require "hotdog/commands/help"
-        get_command(command).tap do |cmd|
-          if Hotdog::Commands::Help === cmd
-            STDERR.puts("hotdog: '#{command}' is not a hotdog command.")
-          else
-            cmd.parse_options(@optparse, ["--help"])
-          end
+
+        @optparse.banner = "Usage: hotdog #{command_name} [options]"
+        command.define_options(@optparse, @options)
+
+        begin
+          args = command.parse_options(@optparse, args)
+        rescue OptionParser::ParseError => error
+          STDERR.puts("hotdog: #{error.message}")
+          command.parse_options(@optparse, ["--help"])
+          exit(1)
+        end
+
+        unless options[:api_key]
+          raise("DATADOG_API_KEY is not set")
         end
-        exit(1)
+
+        unless options[:application_key]
+          raise("DATADOG_APPLICATION_KEY is not set")
+        end
+
+        if options[:format] == "ltsv"
+          options[:headers] = true
+        end
+
+        options[:formatter] = get_formatter(options[:format])
+
+        if options[:debug] or options[:verbose]
+          options[:logger].level = Logger::DEBUG
+        else
+          options[:logger].level = Logger::INFO
+        end
+
+        command.run(args, @options)
       rescue Errno::EPIPE
         # nop
       end
@@ -174,8 +177,7 @@ module Hotdog
           load library
           klass = Hotdog::Commands.const_get(const_name(File.basename(library, ".rb")))
         else
-          require "hotdog/commands/help"
-          klass = Hotdog::Commands::Help
+          raise(NameError.new("unknown command: #{name}"))
         end
       end
       klass.new(self)

data/lib/hotdog/commands/help.rb

@@ -6,8 +6,29 @@ module Hotdog
   module Commands
     class Help < BaseCommand
       def run(args=[], options={})
-        ruby = File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
-        exit(system(ruby, $0, "--help") ? 0 : 1)
+        commands = command_files.map { |file| File.basename(file, ".rb") }.sort.uniq
+        if "commands" == args.first
+          STDOUT.puts("hotdog commands are:")
+          commands.each do |command|
+            STDOUT.puts("- #{command}")
+          end
+        else
+          ruby = File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
+          if commands.include?(args.first)
+            exit(system(ruby, $0, args.first, "--help") ? 0 : 1)
+          else
+            exit(system(ruby, $0, "--help") ? 0 : 1)
+          end
+        end
+      end
+
+      private
+      def load_path()
+        $LOAD_PATH.map { |path| File.join(path, "hotdog/commands") }.select { |path| File.directory?(path) }
+      end
+
+      def command_files()
+        load_path.flat_map { |path| Dir.glob(File.join(path, "*.rb")) }.select { |file| File.file?(file) }
       end
     end
   end

data/lib/hotdog/commands/pssh.rb

@@ -1,130 +1,25 @@
 #!/usr/bin/env ruby
 
 require "json"
+require "parallel"
 require "parslet"
-require "hotdog/commands/search"
 require "shellwords"
-require "parallel"
+require "hotdog/commands/ssh"
 
 module Hotdog
   module Commands
-    class Pssh < Search
-      def define_options(optparse, options={})
-        options[:options] = []
-        options[:user] = nil
-        options[:port] = nil
-        options[:identity_file] = nil
-        options[:forward_agent] = false
-        options[:max_parallelism] = nil
-        options[:color] = :auto
-
-        optparse.on("-o SSH_OPTION", "Passes this string to ssh command through shell. This option may be given multiple times") do |option|
-          options[:options] += [option]
-        end
-        optparse.on("-i SSH_IDENTITY_FILE", "SSH identity file path") do |path|
-          options[:identity_file] = path
-        end
-        optparse.on("-A", "Enable agent forwarding", TrueClass) do |b|
-          options[:forward_agent] = b
-        end
-        optparse.on("-p PORT", "Port of the remote host", Integer) do |port|
-          options[:port] = port
-        end
-        optparse.on("-u SSH_USER", "SSH login user name") do |user|
-          options[:user] = user
-        end
-        optparse.on("-P PARALLELISM", "Max parallelism", Integer) do |n|
-          options[:max_parallelism] = n
-        end
-        optparse.on("-v", "--verbose", "Enable verbose ode") do |v|
-          options[:verbose] = v
-        end
-        optparse.on("--color=WHEN", "--colour=WHEN", "Enable colors") do |color|
-          options[:color] = color
-        end
-      end
-
-      def run(args=[], options={})
-        expression = args.join(" ").strip
-        if expression.empty?
-          # return everything if given expression is empty
-          expression = "*"
-        end
-
-        begin
-          node = parse(expression)
-        rescue Parslet::ParseFailed => error
-          STDERR.puts("syntax error: " + error.cause.ascii_tree)
-          exit(1)
-        end
-
-        result0 = evaluate(node, self)
-        if 0 < result0.length
-          exec_command(result0, options)
-        else
-          STDERR.puts("no match found: #{expression}")
-          exit(1)
-        end
-      end
-
+    class Pssh < SshAlike
       private
-      def exec_command(result0, options={})
-        result, fields = get_hosts(result0)
-        hosts = result.flatten
-        threads = options[:max_parallelism] || hosts.size
+      def run_main(hosts, options={})
         use_color_p = use_color?
-        stats = Parallel.map(hosts.zip(hosts), in_threads: threads) { |host, name|
-          cmdline = build_command_string(host, options)
-          logger.debug("execute: #{cmdline}")
-          IO.popen(cmdline, in: :close, err: [:child, :out]) do |io|
-            io.each_with_index do |s, i|
-              STDOUT.write("\e[0;36m") if use_color_p
-              STDOUT.write("#{name}:#{i}:")
-              STDOUT.write("\e[0m") if use_color_p
-              STDOUT.write(s)
-            end
-          end
-          $?.success? # $? is thread-local variable
+        stats = Parallel.map(hosts, in_threads: parallelism(hosts)) { |host|
+          cmdline = build_command_string(host, @remote_command, options)
+          exec_command(host, cmdline, true, use_color_p)
         }
-        unless stats.all?
-          exit(1)
-        end
-      end
-
-      def build_command_string(host, options={})
-        # build ssh command
-        base_cmdline = ["ssh"]
-        if options[:forward_agent]
-          base_cmdline << "-A"
-        end
-        if options[:identity_file]
-          base_cmdline << "-i" << options[:identity_file]
-        end
-        if options[:user]
-          base_cmdline << "-l" << options[:user]
-        end
-        base_cmdline << "-o" << "BatchMode=yes"
-        if options[:options]
-          base_cmdline += options[:options].flat_map { |option| ["-o", option] }
-        end
-        if options[:port]
-          base_cmdline << "-p" << options[:port].to_s
-        end
-        cmdline = base_cmdline + [host]
-        if @remote_command
-          cmdline << "--" << @remote_command
-        end
-        Shellwords.join(cmdline)
-      end
-
-      def use_color?
-        case options[:color]
-        when :always
-          true
-        when :never
-          false
+        if stats.all?
+          exit(0)
         else
-          STDOUT.tty?
+          exit(1)
         end
       end
     end

data/lib/hotdog/commands/search.rb

@@ -742,11 +742,7 @@ module Hotdog
         def evaluate(environment, options={})
           values = environment.execute(@query, @values).map { |row| row.first }
           if values.empty? and @fallback
-            @fallback.evaluate(environment, options).tap do |values|
-              if values.empty?
-                environment.logger.info("no result: #{self.dump.inspect}")
-              end
-            end
+            @fallback.evaluate(environment, options)
           else
             values
           end

data/lib/hotdog/commands/ssh.rb

@@ -2,29 +2,21 @@
 
 require "json"
 require "parslet"
-require "hotdog/commands/search"
 require "shellwords"
+require "hotdog/commands/search"
 
 module Hotdog
   module Commands
-    class Ssh < Search
+    class SshAlike < Search
       def define_options(optparse, options={})
-        options[:index] = nil
         options[:options] = []
         options[:user] = nil
         options[:port] = nil
         options[:identity_file] = nil
         options[:forward_agent] = false
+        options[:color] = :auto
+        options[:max_parallelism] = nil
 
-        optparse.on("-D BIND_ADDRESS", "Specifies a local \"dynamic\" application-level port forwarding") do |bind_address|
-          options[:dynamic_port_forward] = bind_address
-        end
-        optparse.on("-L BIND_ADDRESS", "Specifies that the given port on the local (client) host is to be forwarded to the given host and port on the remote side") do |bind_address|
-          options[:port_forward] = bind_address
-        end
-        optparse.on("-n", "--index INDEX", "Use this index of host if multiple servers are found", Integer) do |index|
-          options[:index] = index
-        end
         optparse.on("-o SSH_OPTION", "Passes this string to ssh command through shell. This option may be given multiple times") do |option|
           options[:options] += [option]
         end
@@ -43,6 +35,15 @@ module Hotdog
         optparse.on("-v", "--verbose", "Enable verbose ode") do |v|
           options[:verbose] = v
         end
+        optparse.on("--filter=COMMAND", "Command to filter search result.") do |command|
+          options[:filter_command] = command
+        end
+        optparse.on("-P PARALLELISM", "Max parallelism", Integer) do |n|
+          options[:max_parallelism] = n
+        end
+        optparse.on("--color=WHEN", "--colour=WHEN", "Enable colors") do |color|
+          options[:color] = color
+        end
       end
 
       def run(args=[], options={})
@@ -60,73 +61,161 @@ module Hotdog
         end
 
         result0 = evaluate(node, self)
-        if 0 < result0.length
-          if result0.length == 1
-            exec_command([result0.first], options)
+        result, fields = get_hosts_with_search_tags(result0, node)
+        hosts = filter_hosts(result.flatten)
+        validate_hosts!(hosts)
+        run_main(hosts, options)
+      end
+
+      private
+      def parallelism(hosts)
+        options[:max_parallelism] || hosts.size
+      end
+
+      def filter_hosts(hosts)
+        if options[:filter_command]
+          use_color_p = use_color?
+          filtered_hosts = Parallel.map(hosts, in_threads: parallelism(hosts)) { |host|
+            cmdline = build_command_string(host, options[:filter_command], options)
+            [host, exec_command(host, cmdline, false, use_color_p)]
+          }.select { |host, stat|
+            stat
+          }.map { |host, stat|
+            host
+          }
+          if hosts == filtered_hosts
+            hosts
           else
-            if options[:index] and options[:index] < result0.length
-              exec_command([result0[options[:index]]], options)
-            else
-              result, fields = get_hosts_with_search_tags(result0, node)
-
-              # add "index" field
-              result = result.each_with_index.map { |host, i| [i] + host }
-              fields = ["index"] + fields
-
-              STDERR.print(format(result, fields: fields))
-              logger.info("found %d host(s)." % result.length)
-              exit(1)
-            end
+            logger.info("filtered host(s): #{(hosts - filtered_hosts).inspect}")
+            filtered_hosts
           end
         else
-          STDERR.puts("no match found: #{expression}")
+          hosts
+        end
+      end
+
+      def validate_hosts!(hosts)
+        if hosts.length < 1
+          STDERR.puts("no match found")
           exit(1)
         end
-        exit(127)
       end
 
-      private
-      def exec_command(result0, options={})
-        result, fields = get_hosts(result0)
-        hosts = result.flatten
-        cmdline = build_command_string(hosts.first, options)
-        logger.debug("execute: #{cmdline}")
-        exec(cmdline)
+      def run_main(hosts, options={})
+        raise(NotImplementedError)
       end
 
-      def build_command_string(host, options={})
-        # build ssh command
-        base_cmdline = ["ssh"]
+      def build_command_options(options={})
+        cmdline = []
         if options[:forward_agent]
-          base_cmdline << "-A"
-        end
-        if options[:dynamic_port_forward]
-          base_cmdline << "-D" << options[:dynamic_port_forward]
-        end
-        if options[:port_forward]
-          base_cmdline << "-L" << options[:port_forward]
+          cmdline << "-A"
         end
         if options[:identity_file]
-          base_cmdline << "-i" << options[:identity_file]
+          cmdline << "-i" << options[:identity_file]
         end
         if options[:user]
-          base_cmdline << "-l" << options[:user]
+          cmdline << "-l" << options[:user]
         end
         if options[:options]
-          base_cmdline += options[:options].flat_map { |option| ["-o", option] }
+          cmdline += options[:options].flat_map { |option| ["-o", option] }
         end
         if options[:port]
-          base_cmdline << "-p" << options[:port].to_s
+          cmdline << "-p" << options[:port].to_s
         end
         if options[:verbose]
-          base_cmdline << "-v"
+          cmdline << "-v"
         end
-        cmdline = base_cmdline + [host]
-        if @remote_command
-          cmdline << "--" << @remote_command
+        cmdline
+      end
+
+      def build_command_string(host, command=nil, options={})
+        # build ssh command
+        cmdline = ["ssh"] + build_command_options(options) + [host]
+        if command
+          cmdline << "--" << command
         end
         Shellwords.join(cmdline)
       end
+
+      def use_color?
+        case options[:color]
+        when :always
+          true
+        when :never
+          false
+        else
+          STDOUT.tty?
+        end
+      end
+
+      def exec_command(identifier, cmdline, output=true, colorize=false)
+        logger.debug("execute: #{cmdline}")
+        IO.popen(cmdline, in: :close, err: [:child, :out]) do |io|
+          io.each_with_index do |s, i|
+            if output
+              STDOUT.write("\e[0;36m") if colorize
+              STDOUT.write("#{identifier}:#{i}:")
+              STDOUT.write("\e[0m") if colorize
+              STDOUT.write(s)
+            end
+          end
+        end
+        $?.success? # $? is thread-local variable
+      end
+    end
+
+    class Ssh < SshAlike
+      def define_options(optparse, options={})
+        super
+        options[:index] = nil
+        optparse.on("-D BIND_ADDRESS", "Specifies a local \"dynamic\" application-level port forwarding") do |bind_address|
+          options[:dynamic_port_forward] = bind_address
+        end
+        optparse.on("-L BIND_ADDRESS", "Specifies that the given port on the local (client) host is to be forwarded to the given host and port on the remote side") do |bind_address|
+          options[:port_forward] = bind_address
+        end
+        optparse.on("-n", "--index INDEX", "Use this index of host if multiple servers are found", Integer) do |index|
+          options[:index] = index
+        end
+      end
+
+      private
+      def filter_hosts(hosts)
+        hosts = super
+        if options[:index] and options[:index] < hosts.length
+          [hosts[options[:index]]]
+        else
+          hosts
+        end
+      end
+
+      def validate_hosts!(hosts)
+        super
+        if hosts.length != 1
+          result = hosts.each_with_index.map { |host, i| [i, host] }
+          STDERR.print(format(result, fields: ["index", "host"]))
+          logger.error("found %d hosts." % result.length)
+          exit(1)
+        end
+      end
+
+      def run_main(hosts, options={})
+        cmdline = build_command_string(hosts.first, @remote_command, options)
+        logger.debug("execute: #{cmdline}")
+        exec(cmdline)
+        exit(127)
+      end
+
+      def build_command_options(options={})
+        arguments = super
+        if options[:dynamic_port_forward]
+          arguments << "-D" << options[:dynamic_port_forward]
+        end
+        if options[:port_forward]
+          arguments << "-L" << options[:port_forward]
+        end
+        arguments
+      end
     end
   end
 end

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.6.3"
+  VERSION = "0.6.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors:
 - Yamashita Yuu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-14 00:00:00.000000000 Z
+date: 2015-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler