hotdog 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dad54741d7b612af34df19f0ae934c938411a941
-  data.tar.gz: 951a0d2bafcf5edbc3262e9f1552b4aade13fc0c
+  metadata.gz: f3bcc93be20391d227013b6c05bb9113d68bc404
+  data.tar.gz: 3a8bc479c3122dc4b18ecf37d575e7b49dd8c1f8
 SHA512:
-  metadata.gz: 9c4fdc6b65e2caa37150c2e47bf207cacfec32d775e7f23b9e7b79298935853b5c34dc094d75ee21b48187d9440b3d4d9ae787a212387a5ae3415e1e5caac7df
-  data.tar.gz: 8e71095cbea2abee8f03173cfda463b289326a4a2a0fa187bd45040856e32e287f8ab84c270bacaa785f15ec6dddb052e126941438c6a353ed9d5e417b74140c
+  metadata.gz: 8c9646d739e72b331cdfdf145da4e93b0c44598b64618a20db48eff13185a9bc277550581f2288e20ee548c8001466c454d30d43df900d9cef8e773bcf5f4bef
+  data.tar.gz: d51c0697ca67251ded20b0c2807af26ead5d4f7ed87b3c189ee109ff464c2a5cfccc82efeff20ec8f6cdcd0a2a07ab4ee5c1f374d1df4c14cdf9d5b98994fe03

data/hotdog.gemspec

@@ -23,7 +23,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.3.0"
 
   spec.add_dependency "dogapi", ">= 1.13.0"
+  spec.add_dependency "multi_json", "~> 1.11.2"
+  spec.add_dependency "oj", "~> 2.12.14"
+  spec.add_dependency "parallel", "~> 1.6.1"
   spec.add_dependency "parslet", "~> 1.6.2"
   spec.add_dependency "sqlite3", "~> 1.3.10"
-  spec.add_dependency "parallel", "~> 1.4.1"
 end

data/lib/hotdog/application.rb

@@ -13,6 +13,7 @@ module Hotdog
       @optparse = OptionParser.new
       @optparse.version = Hotdog::VERSION
       @options = {
+        endpoint: ENV.fetch("DATADOG_HOST", "https://app.datadoghq.com"),
         api_key: ENV["DATADOG_API_KEY"],
         application_key: ENV["DATADOG_APPLICATION_KEY"],
         application: self,
@@ -53,7 +54,7 @@ module Hotdog
 
       begin
         command = ( args.shift || "help" )
-        get_command(command).new(self).tap do |cmd|
+        get_command(command).tap do |cmd|
           @optparse.banner = "Usage: hotdog #{command} [options]"
           cmd.define_options(@optparse, @options)
           args = cmd.parse_options(@optparse, args)
@@ -69,7 +70,7 @@ module Hotdog
             options[:headers] = true
           end
 
-          options[:formatter] = get_formatter(options[:format]).new
+          options[:formatter] = get_formatter(options[:format])
 
           if options[:debug] or options[:verbose]
             options[:logger].level = Logger::DEBUG
@@ -86,6 +87,9 @@ module Hotdog
 
     private
     def define_options
+      @optparse.on("--endpoint ENDPOINT", "Datadog API endpoint") do |endpoint|
+        options[:endpoint] = endpoint
+      end
       @optparse.on("--api-key API_KEY", "Datadog API key") do |api_key|
         options[:api_key] = api_key
       end
@@ -139,29 +143,31 @@ module Hotdog
 
     def get_formatter(name)
       begin
-        Hotdog::Formatters.const_get(const_name(name))
+        klass = Hotdog::Formatters.const_get(const_name(name))
       rescue NameError
         if library = find_library("hotdog/formatters", name)
           load library
-          Hotdog::Formatters.const_get(const_name(File.basename(library, ".rb")))
+          klass = Hotdog::Formatters.const_get(const_name(File.basename(library, ".rb")))
         else
           raise(NameError.new("unknown format: #{name}"))
         end
       end
+      klass.new
     end
 
     def get_command(name)
       begin
-        Hotdog::Commands.const_get(const_name(name))
+        klass = Hotdog::Commands.const_get(const_name(name))
       rescue NameError
         if library = find_library("hotdog/commands", name)
           load library
-          Hotdog::Commands.const_get(const_name(File.basename(library, ".rb")))
+          klass = Hotdog::Commands.const_get(const_name(File.basename(library, ".rb")))
         else
           require "hotdog/commands/help"
-          Hotdog::Commands::Help
+          klass = Hotdog::Commands::Help
         end
       end
+      klass.new(self)
     end
 
     def find_library(dirname, name)

data/lib/hotdog/commands/down.rb

@@ -6,13 +6,13 @@ module Hotdog
   module Commands
     class Down < BaseCommand
       def define_options(optparse, options={})
-        @downtime = 86400
-        @start = Time.new
+        options[:downtime] = 86400
+        options[:start] = Time.new
         optparse.on("--downtime DURATION") do |v|
-          @downtime = v.to_i
+          options[:downtime] = v.to_i
         end
         optparse.on("--start TIME") do |v|
-          @start = Time.parse(v)
+          options[:start] = Time.parse(v)
         end
       end
 
@@ -23,8 +23,8 @@ module Hotdog
           else
             scope = arg
           end
-          code, schedule = @dog.schedule_downtime(scope, :start => @start.to_i, :end => (@start+@downtime).to_i)
-          logger.debug("dog.schedule_donwtime(%s, :start => %s, :end => %s) #==> [%s, %s]" % [scope.inspect, @start.to_i, (@start+@downtime).to_i, code.inspect, schedule.inspect])
+          code, schedule = dog.schedule_downtime(scope, :start => options[:start].to_i, :end => (options[:start]+options[:downtime]).to_i)
+          logger.debug("dog.schedule_donwtime(%s, :start => %s, :end => %s) #==> [%s, %s]" % [scope.inspect, options[:start].to_i, (options[:start]+options[:downtime]).to_i, code.inspect, schedule.inspect])
           if code.to_i / 100 != 2
             raise("dog.schedule_downtime(%s, ...) returns [%s, %s]" % [scope.inspect, code.inspect, schedule.inspect])
           end

data/lib/hotdog/commands/pssh.rb

@@ -14,7 +14,9 @@ module Hotdog
         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]
@@ -22,6 +24,9 @@ module Hotdog
         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
@@ -31,13 +36,30 @@ module Hotdog
         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 parse_options(optparse, args=[])
+        if args.index("--")
+          @remote_command = args.slice(args.index("--") + 1, args.length).join(" ")
+          optparse.parse(args.slice(0, args.index("--")))
+        else
+          @remote_command = nil
+          optparse.parse(args)
+        end
+      end
+      attr_reader :remote_command
+
       def run(args=[], options={})
-        use_color = STDOUT.tty?
         expression = args.join(" ").strip
-        if expression.empty? || args.empty?
-          exit(1)
+        if expression.empty?
+          # return everything if given expression is empty
+          expression = "*"
         end
 
         begin
@@ -47,61 +69,76 @@ module Hotdog
           exit(1)
         end
 
-        result = evaluate(node, self)
-        result, fields = get_hosts(result)
-
-        if result.empty?
-          STDERR.puts("no match found: #{search_args.join(" ")}")
+        result0 = evaluate(node, self)
+        if 0 < result0.length
+          exec_command(result0, options)
+        else
+          STDERR.puts("no match found: #{expression}")
           exit(1)
         end
+      end
 
-        addresses = result.map {|host| [host.first, host.last] }
-
-        # build ssh command
-        cmdline = ["ssh"]
-        options[:options].each do |option|
-          cmdline << "-o" << option
-        end
-        if path = options[:identity_file]
-          cmdline << "-i" << Shellwords.escape(path)
-        end
-        if port = options[:port]
-          cmdline << "-p" << port.to_s
-        end
-        if options[:forward_agent]
-          cmdline << "-A"
-        end
-
-        cmdline << "-o" << "BatchMode=yes"
-
-        user = options[:user]
-
-        threads = options[:max_parallelism] || addresses.size
-        stats = Parallel.map(addresses, in_threads: threads) { |address,name|
-          if use_color
+      def exec_command(result0, options={})
+        result, fields = get_hosts(result0)
+        hosts = result.flatten
+        threads = options[:max_parallelism] || hosts.size
+        stats = Parallel.map(hosts.zip(hosts), in_threads: threads) { |host, name|
+          if use_color?
             header = "\e[0;36m#{name}\e[00m"
           else
             header = name
           end
-          c = cmdline.dup
-          if user
-            c << (user + "@" + address)
-          else
-            c << address
-          end
-          logger.debug("execute: #{Shellwords.join(c)}")
-          IO.popen([*c, in: :close, err: [:child, :out]]) do |io|
+          cmdline = build_command_string(host, options)
+          logger.debug("execute: #{cmdline}")
+          IO.popen(cmdline, in: :close, err: [:child, :out]) do |io|
             io.each_line do |line|
-              STDOUT.write "#{header}: #{line}"
+              STDOUT.write("#{header}: #{line}")
             end
           end
           $?.success? # $? is thread-local variable
         }
-
         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
+
+      private
+      def use_color?
+        case options[:color]
+        when :always
+          true
+        when :never
+          false
+        else
+          STDOUT.tty?
+        end
+      end
     end
   end
 end

data/lib/hotdog/commands/search.rb

@@ -26,18 +26,18 @@ module Hotdog
           exit(1)
         end
 
-        result = evaluate(node, self)
-        if 0 < result.length
-          _result, fields = get_hosts_with_search_tags(result, node)
-          result = _result.take(options.fetch(:limit, _result.size))
-          STDOUT.print(format(result, fields: fields))
-          if _result.length == result.length
-            logger.info("found %d host(s)." % result.length)
+        result0 = evaluate(node, self)
+        if 0 < result0.length
+          result, fields = get_hosts_with_search_tags(result0, node)
+          if options[:limit]
+            STDOUT.print(format(result.take(options[:limit]), fields: fields))
+            logger.info("found %d host(s), limited to %d in result." % [result.length, options[:limit]])
           else
-            logger.info("found %d host(s), limited to %d in result." % [_result.length, result.length])
+            STDOUT.print(format(result, fields: fields))
+            logger.info("found %d host(s)." % result.length)
           end
         else
-          STDERR.puts("no match found: #{args.join(" ")}")
+          STDERR.puts("no match found: #{expression}")
           exit(1)
         end
       end

data/lib/hotdog/commands/ssh.rb

@@ -15,7 +15,6 @@ module Hotdog
         options[:port] = nil
         options[:identity_file] = nil
         options[:forward_agent] = false
-        options[:verbose] = false
 
         optparse.on("-n", "--index INDEX", "Use this index of host if multiple servers are found", Integer) do |index|
           options[:index] = index
@@ -40,10 +39,22 @@ module Hotdog
         end
       end
 
+      def parse_options(optparse, args=[])
+        if args.index("--")
+          @remote_command = args.slice(args.index("--") + 1, args.length).join(" ")
+          optparse.parse(args.slice(0, args.index("--")))
+        else
+          @remote_command = nil
+          optparse.parse(args)
+        end
+      end
+      attr_reader :remote_command
+
       def run(args=[], options={})
         expression = args.join(" ").strip
         if expression.empty?
-          exit(1)
+          # return everything if given expression is empty
+          expression = "*"
         end
 
         begin
@@ -53,57 +64,66 @@ module Hotdog
           exit(1)
         end
 
-        result = evaluate(node, self)
-
-        if result.length == 1
-          host = result[0]
-        elsif result.empty?
-          STDERR.puts("no match found: #{search_args.join(" ")}")
-          exit(1)
-        else
-          if options[:index] && result.length > options[:index]
-            host = result[options[:index]]
+        result0 = evaluate(node, self)
+        if 0 < result0.length
+          if result0.length == 1
+            exec_command([result0.first], options)
           else
-            result, fields = get_hosts_with_search_tags(result, node)
+            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
+              # 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)
+              STDERR.print(format(result, fields: fields))
+              logger.info("found %d host(s)." % result.length)
+              exit(1)
+            end
           end
+        else
+          STDERR.puts("no match found: #{expression}")
+          exit(1)
         end
+        exit(127)
+      end
 
-        result, fields = get_hosts([host])
-        address = result.flatten.first
+      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)
+      end
 
+      def build_command_string(host, options={})
         # build ssh command
-        cmdline = ["ssh"]
-        options[:options].each do |option|
-          cmdline << "-o" << option
+        base_cmdline = ["ssh"]
+        if options[:forward_agent]
+          base_cmdline << "-A"
         end
-        if path = options[:identity_file]
-          cmdline << "-i" << Shellwords.escape(path)
+        if options[:identity_file]
+          base_cmdline << "-i" << options[:identity_file]
         end
-        if port = options[:port]
-          cmdline << "-p" << port.to_s
+        if options[:user]
+          base_cmdline << "-l" << options[:user]
         end
-        if options[:forward_agent]
-          cmdline << "-A"
+        if options[:options]
+          base_cmdline += options[:options].flat_map { |option| ["-o", option] }
+        end
+        if options[:port]
+          base_cmdline << "-p" << options[:port].to_s
         end
         if options[:verbose]
-          cmdline << "-v"
+          base_cmdline << "-v"
         end
-        if user = options[:user]
-          cmdline << (user + "@" + address)
-        else
-          cmdline << address
+        cmdline = base_cmdline + [host]
+        if @remote_command
+          cmdline << "--" << @remote_command
         end
-        logger.debug("execute: #{Shellwords.join(cmdline)}")
-        exec(*cmdline)
-        exit(127)
+        Shellwords.join(cmdline)
       end
     end
   end

data/lib/hotdog/commands/up.rb

@@ -13,7 +13,7 @@ module Hotdog
             arg
           end
         }
-        code, all_downtimes = @dog.get_all_downtimes()
+        code, all_downtimes = dog.get_all_downtimes()
         if code.to_i / 100 != 2
           raise("dog.get_all_downtimes() returns [%s, %s]" % [code.inspect, all_downtimes.inspect])
         end
@@ -23,7 +23,7 @@ module Hotdog
         }
 
         cancel_downtimes.each do |downtime|
-          code, cancel = @dog.cancel_downtime(downtime["id"])
+          code, cancel = dog.cancel_downtime(downtime["id"])
           if code.to_i / 100 != 2
             raise("dog.cancel_downtime(%s) returns [%s, %s]" % [downtime["id"].inspect, code.inspect, cancel.inspect])
           end

data/lib/hotdog/commands.rb

@@ -2,8 +2,12 @@
 
 require "fileutils"
 require "dogapi"
-require "json"
+require "multi_json"
+require "oj"
+require "open-uri"
+require "parallel"
 require "sqlite3"
+require "uri"
 
 module Hotdog
   module Commands
@@ -18,7 +22,7 @@ module Hotdog
         @application = application
         @logger = application.options[:logger]
         @options = application.options
-        @dog = Dogapi::Client.new(options[:api_key], options[:application_key])
+        @dog = nil # lazy initialization
         @prepared_statements = {}
       end
       attr_reader :application
@@ -31,13 +35,7 @@ module Hotdog
 
       def execute(q, args=[])
         update_db
-        begin
-          logger.debug("execute: #{q} -- #{args.inspect}")
-          prepare(@db, q).execute(args)
-        rescue
-          logger.error("failed: #{q} -- #{args.inspect}")
-          raise
-        end
+        execute_db(@db, q, args)
       end
 
       def fixed_string?()
@@ -183,9 +181,12 @@ module Hotdog
           if (not options[:force] and File.exist?(persistent) and Time.new < File.mtime(persistent) + options[:expiry]) or options[:offline]
             begin
               persistent_db = SQLite3::Database.new(persistent)
-              persistent_db.execute("SELECT id, name FROM hosts LIMIT 1")
-              persistent_db.execute("SELECT id, name, value FROM tags LIMIT 1")
-              persistent_db.execute("SELECT host_id, tag_id FROM hosts_tags LIMIT 1")
+              persistent_db.execute(<<-EOS)
+                SELECT hosts_tags.host_id FROM hosts_tags
+                  INNER JOIN hosts ON hosts_tags.host_id = hosts.id
+                  INNER JOIN tags ON hosts_tags.tag_id = tags.id
+                    LIMIT 1;
+              EOS
               @db = persistent_db
               return
             rescue SQLite3::SQLException
@@ -198,12 +199,28 @@ module Hotdog
           end
 
           memory_db = SQLite3::Database.new(":memory:")
-          create_table_hosts(memory_db)
-          create_index_hosts(memory_db)
-          create_table_tags(memory_db)
-          create_index_tags(memory_db)
-          create_table_hosts_tags(memory_db)
-          create_index_hosts_tags(memory_db)
+          execute_db(memory_db, <<-EOS)
+            CREATE TABLE IF NOT EXISTS hosts (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              name VARCHAR(255) NOT NULL COLLATE NOCASE
+            );
+          EOS
+          execute_db(memory_db, "CREATE UNIQUE INDEX IF NOT EXISTS hosts_name ON hosts ( name );")
+          execute_db(memory_db, <<-EOS)
+            CREATE TABLE IF NOT EXISTS tags (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              name VARCHAR(200) NOT NULL COLLATE NOCASE,
+              value VARCHAR(200) NOT NULL COLLATE NOCASE
+            );
+          EOS
+          execute_db(memory_db, "CREATE UNIQUE INDEX IF NOT EXISTS tags_name_value ON tags ( name, value );")
+          execute_db(memory_db, <<-EOS)
+            CREATE TABLE IF NOT EXISTS hosts_tags (
+              host_id INTEGER NOT NULL,
+              tag_id INTEGER NOT NULL
+            );
+          EOS
+          execute_db(memory_db, "CREATE UNIQUE INDEX IF NOT EXISTS hosts_tags_host_id_tag_id ON hosts_tags ( host_id, tag_id );")
 
           all_tags = get_all_tags()
 
@@ -211,23 +228,13 @@ module Hotdog
             known_tags = all_tags.keys.map { |tag| split_tag(tag) }.uniq
             known_tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2) do |known_tags|
               q = "INSERT OR IGNORE INTO tags (name, value) VALUES %s" % known_tags.map { "(?, ?)" }.join(", ")
-              begin
-                prepare(memory_db, q).execute(known_tags)
-              rescue
-                logger.error("failed: #{q} -- #{known_tags.inspect}")
-                raise
-              end
+              execute_db(memory_db, q, known_tags)
             end
 
             known_hosts = all_tags.values.reduce(:+).uniq
             known_hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT) do |known_hosts|
               q = "INSERT OR IGNORE INTO hosts (name) VALUES %s" % known_hosts.map { "(?)" }.join(", ")
-              begin
-                prepare(memory_db, q).execute(known_hosts)
-              rescue
-                logger.error("failed: #{q} -- #{known_hosts.inspect}")
-                raise
-              end
+              execute_db(memory_db, q, known_hosts)
             end
 
             all_tags.each do |tag, hosts|
@@ -237,10 +244,18 @@ module Hotdog
                         "( SELECT id FROM hosts WHERE name IN (%s) ) AS host, " \
                         "( SELECT id FROM tags WHERE name = ? AND value = ? LIMIT 1 ) AS tag;" % hosts.map { "?" }.join(", ")
                 begin
-                  prepare(memory_db, q).execute(hosts + split_tag(tag))
-                rescue
-                  logger.error("failed: #{q} -- #{(hosts + split_tag(tag)).inspect}")
-                  raise
+                  execute_db(memory_db, q, (hosts + split_tag(tag)))
+                rescue SQLite3::RangeException => error
+                  # FIXME: bulk insert occationally fails even if there are no errors in bind parameters
+                  #        `bind_param': bind or column index out of range (SQLite3::RangeException)
+                  logger.warn("bulk insert failed due to #{error.message}. fallback to normal insert.")
+                  hosts.each do |host|
+                    q = "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
+                          "SELECT host.id, tag.id FROM " \
+                            "( SELECT id FROM hosts WHERE name = ? ) AS host, " \
+                            "( SELECT id FROM tags WHERE name = ? AND value = ? LIMIT 1 ) AS tag;"
+                    execute_db(memory_db, q, [host] + split_tag(tag))
+                  end
                 end
               end
             end
@@ -257,19 +272,37 @@ module Hotdog
         end
       end
 
-      def get_all_tags() #==> Hash<Tag,Array<Host>>
-        code, all_tags = @dog.all_tags()
-        logger.debug("dog.all_tags() #==> [%s, ...]" % [code.inspect])
-        if code.to_i / 100 != 2
-          raise("dog.all_tags() returns [%s, ...]" % [code.inspect])
+      def execute_db(db, q, args=[])
+        begin
+          logger.debug("execute: #{q} -- #{args.inspect}")
+          prepare(db, q).execute(args)
+        rescue
+          logger.error("failed: #{q} -- #{args.inspect}")
+          raise
         end
-        code, all_downtimes = @dog.get_all_downtimes()
-        logger.debug("dog.get_all_downtimes() #==> [%s, ...]" % [code.inspect])
-        if code.to_i / 100 != 2
-          raise("dog.get_all_downtimes() returns [%s, ...]" % [code.inspect])
+      end
+
+      def get_all_tags() #==> Hash<Tag,Array<Host>>
+        endpoint = options[:endpoint]
+        requests = {all_downtime: "/api/v1/downtime", all_tags: "/api/v1/tags/hosts"}
+        query = URI.encode_www_form(api_key: options[:api_key], application_key: options[:application_key])
+        begin
+          responses = Hash[Parallel.map(requests) { |name, request_path|
+            uri = URI.join(endpoint, "#{request_path}?#{query}")
+            begin
+              response = uri.open("User-Agent" => "hotdog/#{Hotdog::VERSION}") { |fp| fp.read }
+              [name, MultiJson.load(response)]
+            rescue OpenURI::HTTPError => error
+              code, body = error.io.status
+              raise(RuntimeError.new("dog.get_#{name}() returns [#{code.inspect}, ...]"))
+            end
+          }]
+        rescue => error
+          STDERR.puts(error.message)
+          exit(1)
         end
         now = Time.new.to_i
-        downtimes = all_downtimes.select { |downtime|
+        downtimes = responses.fetch(:all_downtime, []).select { |downtime|
           # active downtimes
           downtime["active"] and ( downtime["start"].nil? or downtime["start"] < now ) and ( downtime["end"].nil? or now <= downtime["end"] )
         }.flat_map { |downtime|
@@ -279,7 +312,11 @@ module Hotdog
         if not downtimes.empty?
           logger.info("ignore host(s) with scheduled downtimes: #{downtimes.inspect}")
         end
-        Hash[all_tags["tags"].map { |tag, hosts| [tag, hosts.reject { |host| downtimes.include?(host) }] }]
+        Hash[responses.fetch(:all_tags, {}).fetch("tags", []).map { |tag, hosts| [tag, hosts.reject { |host| downtimes.include?(host) }] }]
+      end
+
+      def dog()
+        @dog ||= Dogapi::Client.new(options[:api_key], options[:application_key])
       end
 
       def split_tag(tag)
@@ -296,95 +333,9 @@ module Hotdog
       end
 
       def copy_db(src, dst)
-        # create index later for better insert performance
-        dst.transaction do
-          create_table_hosts(dst)
-          create_table_tags(dst)
-          create_table_hosts_tags(dst)
-
-          hosts = prepare(src, "SELECT id, name FROM hosts").execute().to_a
-          hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2) do |hosts|
-            q = "INSERT INTO hosts (id, name) VALUES %s" % hosts.map { "(?, ?)" }.join(", ")
-            begin
-              prepare(dst, q).execute(hosts)
-            rescue
-              logger.error("failed: #{q} -- #{hosts.inspect}")
-              raise
-            end
-          end
-
-          tags = prepare(src, "SELECT id, name, value FROM tags").execute().to_a
-          tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 3) do |tags|
-            q = "INSERT INTO tags (id, name, value) VALUES %s" % tags.map { "(?, ?, ?)" }.join(", ")
-            begin
-              prepare(dst, q).execute(tags)
-            rescue
-              logger.error("failed: #{q} -- #{tags.inspect}")
-              raise
-            end
-          end
-
-          hosts_tags = prepare(src, "SELECT host_id, tag_id FROM hosts_tags").to_a
-          hosts_tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2) do |hosts_tags|
-            q = "INSERT INTO hosts_tags (host_id, tag_id) VALUES %s" % hosts_tags.map { "(?, ?)" }.join(", ")
-            begin
-              prepare(dst, q).execute(hosts_tags)
-            rescue
-              logger.error("failed: #{q} -- #{hosts_tags.inspect}")
-              raise
-            end
-          end
-
-          create_index_hosts(dst)
-          create_index_tags(dst)
-          create_index_hosts_tags(dst)
-        end
-      end
-
-      def create_table_hosts(db)
-        q = "CREATE TABLE IF NOT EXISTS hosts ( " \
-              "id INTEGER PRIMARY KEY AUTOINCREMENT, " \
-              "name VARCHAR(255) NOT NULL COLLATE NOCASE " \
-            ");"
-        logger.debug(q)
-        db.execute(q)
-      end
-
-      def create_index_hosts(db)
-        q = "CREATE UNIQUE INDEX IF NOT EXISTS hosts_name ON hosts ( name );"
-        logger.debug(q)
-        db.execute(q)
-      end
-
-      def create_table_tags(db)
-        q = "CREATE TABLE IF NOT EXISTS tags ( " \
-              "id INTEGER PRIMARY KEY AUTOINCREMENT, " \
-              "name VARCHAR(200) NOT NULL COLLATE NOCASE, " \
-              "value VARCHAR(200) NOT NULL COLLATE NOCASE " \
-            ");"
-        logger.debug(q)
-        db.execute(q)
-      end
-
-      def create_index_tags(db)
-        q = "CREATE UNIQUE INDEX IF NOT EXISTS tags_name_value ON tags ( name, value );"
-        logger.debug(q)
-        db.execute(q)
-      end
-
-      def create_table_hosts_tags(db)
-        q = "CREATE TABLE IF NOT EXISTS hosts_tags ( " \
-              "host_id INTEGER NOT NULL, " \
-              "tag_id INTEGER NOT NULL " \
-            ");"
-        logger.debug(q)
-        db.execute(q)
-      end
-
-      def create_index_hosts_tags(db)
-        q = "CREATE UNIQUE INDEX IF NOT EXISTS hosts_tags_host_id_tag_id ON hosts_tags ( host_id, tag_id );"
-        logger.debug(q)
-        db.execute(q)
+        backup = SQLite3::Backup.new(dst, "main", src, "main")
+        backup.step(-1)
+        backup.finish
       end
     end
   end

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.5.4"
+  VERSION = "0.6.0"
 end

data/spec/core/application_spec.rb

@@ -23,9 +23,9 @@ describe "application" do
   end
 
   it "returns proper class by name" do
-    expect(app.__send__(:get_command, "hosts")).to be(Hotdog::Commands::Hosts)
-    expect(app.__send__(:get_command, "search")).to be(Hotdog::Commands::Search)
-    expect(app.__send__(:get_command, "tags")).to be(Hotdog::Commands::Tags)
+    expect(app.__send__(:get_command, "hosts")).to be_a(Hotdog::Commands::Hosts)
+    expect(app.__send__(:get_command, "search")).to be_a(Hotdog::Commands::Search)
+    expect(app.__send__(:get_command, "tags")).to be_a(Hotdog::Commands::Tags)
   end
 
   it "raises error if the action is base-command" do

data/spec/optparse/down_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands/down"
+
+describe "option parser for down" do
+  let(:app) {
+    Hotdog::Application.new
+  }
+
+  let(:cmd) {
+    Hotdog::Commands::Down.new(app)
+  }
+
+  before(:each) do
+    allow(app).to receive(:get_command).with("down") {
+      cmd
+    }
+  end
+
+  it "cannot handle subcommand options before subcommand" do
+    expect {
+      app.main(["--downtime", "86400", "down", "foo", "bar", "baz"])
+    }.to raise_error(OptionParser::InvalidOption)
+  end
+
+  it "can handle subcommand options after subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      downtime: 12345,
+      verbose: false,
+    ))
+    app.main(["down", "--downtime", "12345", "foo", "bar", "baz"])
+  end
+
+  it "can handle common options before subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      downtime: 12345,
+      verbose: true,
+    ))
+    app.main(["--verbose", "down", "--downtime", "12345", "foo", "bar", "baz"])
+  end
+
+  it "can handle common options after subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      downtime: 12345,
+      verbose: true,
+    ))
+    app.main(["down", "--downtime", "12345", "--verbose", "foo", "bar", "baz"])
+  end
+end

data/spec/optparse/hosts_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands/hosts"
+
+describe "option parser for hosts" do
+  let(:app) {
+    Hotdog::Application.new
+  }
+
+  let(:cmd) {
+    Hotdog::Commands::Hosts.new(app)
+  }
+
+  before(:each) do
+    allow(app).to receive(:get_command).with("hosts") {
+      cmd
+    }
+  end
+
+  it "can handle common options before subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      verbose: true,
+    ))
+    app.main(["--verbose", "hosts", "foo", "bar", "baz"])
+  end
+
+  it "can handle common options after subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      verbose: true,
+    ))
+    app.main(["hosts", "--verbose", "foo", "bar", "baz"])
+  end
+end

data/spec/optparse/pssh_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands/pssh"
+
+describe "option parser for pssh" do
+  let(:app) {
+    Hotdog::Application.new
+  }
+
+  let(:cmd) {
+    Hotdog::Commands::Pssh.new(app)
+  }
+
+  before(:each) do
+    allow(app).to receive(:get_command).with("pssh") {
+      cmd
+    }
+  end
+
+  it "cannot handle subcommand options before subcommand" do
+    expect {
+      app.main(["-P", "42", "pssh", "foo", "bar", "baz"])
+    }.to raise_error(OptionParser::InvalidOption)
+  end
+
+  it "can handle subcommand options after subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      max_parallelism: 42,
+      verbose: false,
+    ))
+    app.main(["pssh", "-P", "42", "foo", "bar", "baz"])
+  end
+
+  it "can handle common options before subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      max_parallelism: 42,
+      verbose: true,
+    ))
+    app.main(["--verbose", "pssh", "-P", "42", "foo", "bar", "baz"])
+  end
+
+  it "can handle common options after subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      max_parallelism: 42,
+      verbose: true,
+    ))
+    app.main(["pssh", "-P", "42", "--verbose", "foo", "bar", "baz"])
+  end
+
+  it "can handle subcommand options with remote command, 1" do
+    allow(cmd).to receive(:run).with([], a_hash_including(
+      max_parallelism: 42,
+      verbose: true,
+    ))
+    app.main(["pssh", "-P", "42", "--verbose", "--", "foo", "bar", "baz"])
+    expect(cmd.remote_command).to eq("foo bar baz")
+  end
+
+  it "can handle subcommand options with remote command, 2" do
+    allow(cmd).to receive(:run).with(["foo"], a_hash_including(
+      max_parallelism: 42,
+      verbose: true,
+    ))
+    app.main(["pssh", "-P", "42", "--verbose", "foo", "--", "bar", "baz"])
+    expect(cmd.remote_command).to eq("bar baz")
+  end
+
+  it "can handle subcommand options with remote command, 3" do
+    allow(cmd).to receive(:run).with(["foo"], a_hash_including(
+      max_parallelism: 42,
+      verbose: true,
+    ))
+    app.main(["pssh", "-P", "42", "--verbose", "foo", "--", "bar", "--", "baz"])
+    expect(cmd.remote_command).to eq("bar -- baz")
+  end
+end

data/spec/optparse/search_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands/search"
+
+describe "option parser for search" do
+  let(:app) {
+    Hotdog::Application.new
+  }
+
+  let(:cmd) {
+    Hotdog::Commands::Search.new(app)
+  }
+
+  before(:each) do
+    allow(app).to receive(:get_command).with("search") {
+      cmd
+    }
+  end
+
+  it "can handle common options before subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      verbose: true,
+    ))
+    app.main(["--verbose", "search", "foo", "bar", "baz"])
+  end
+
+  it "can handle common options after subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      verbose: true,
+    ))
+    app.main(["search", "--verbose", "foo", "bar", "baz"])
+  end
+end

data/spec/optparse/ssh_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands/ssh"
+
+describe "option parser for ssh" do
+  let(:app) {
+    Hotdog::Application.new
+  }
+
+  let(:cmd) {
+    Hotdog::Commands::Ssh.new(app)
+  }
+
+  before(:each) do
+    allow(app).to receive(:get_command).with("ssh") {
+      cmd
+    }
+  end
+
+  it "cannot handle subcommand options before subcommand" do
+    expect {
+      app.main(["--index", "42", "ssh", "foo", "bar", "baz"])
+    }.to raise_error(OptionParser::InvalidOption)
+  end
+
+  it "can handle subcommand options after subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      index: 42,
+      verbose: false,
+    ))
+    app.main(["ssh", "--index", "42", "foo", "bar", "baz"])
+  end
+
+  it "can handle common options before subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      index: 42,
+      verbose: true,
+    ))
+    app.main(["--verbose", "ssh", "--index", "42", "foo", "bar", "baz"])
+  end
+
+  it "can handle common options after subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      index: 42,
+      verbose: true,
+    ))
+    app.main(["ssh", "--index", "42", "--verbose", "foo", "bar", "baz"])
+  end
+
+  it "can handle subcommand options with remote command, 1" do
+    allow(cmd).to receive(:run).with([], a_hash_including(
+      index: 42,
+      verbose: true,
+    ))
+    app.main(["ssh", "--index", "42", "--verbose", "--", "foo", "bar", "baz"])
+    expect(cmd.remote_command).to eq("foo bar baz")
+  end
+
+  it "can handle subcommand options with remote command, 2" do
+    allow(cmd).to receive(:run).with(["foo"], a_hash_including(
+      index: 42,
+      verbose: true,
+    ))
+    app.main(["ssh", "--index", "42", "--verbose", "foo", "--", "bar", "baz"])
+    expect(cmd.remote_command).to eq("bar baz")
+  end
+
+  it "can handle subcommand options with remote command, 3" do
+    allow(cmd).to receive(:run).with(["foo"], a_hash_including(
+      index: 42,
+      verbose: true,
+    ))
+    app.main(["ssh", "--index", "42", "--verbose", "foo", "--", "bar", "--", "baz"])
+    expect(cmd.remote_command).to eq("bar -- baz")
+  end
+end

data/spec/optparse/tags_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands/tags"
+
+describe "option parser for tags" do
+  let(:app) {
+    Hotdog::Application.new
+  }
+
+  let(:cmd) {
+    Hotdog::Commands::Tags.new(app)
+  }
+
+  before(:each) do
+    allow(app).to receive(:get_command).with("tags") {
+      cmd
+    }
+  end
+
+  it "can handle common options before subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      verbose: true,
+    ))
+    app.main(["--verbose", "tags", "foo", "bar", "baz"])
+  end
+
+  it "can handle common options after subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      verbose: true,
+    ))
+    app.main(["tags", "--verbose", "foo", "bar", "baz"])
+  end
+end

data/spec/optparse/up_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands/up"
+
+describe "option parser for up" do
+  let(:app) {
+    Hotdog::Application.new
+  }
+
+  let(:cmd) {
+    Hotdog::Commands::Up.new(app)
+  }
+
+  before(:each) do
+    allow(app).to receive(:get_command).with("up") {
+      cmd
+    }
+  end
+
+  it "can handle common options before subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      verbose: true,
+    ))
+    app.main(["--verbose", "up", "foo", "bar", "baz"])
+  end
+
+  it "can handle common options after subcommand" do
+    allow(cmd).to receive(:run).with(["foo", "bar", "baz"], a_hash_including(
+      verbose: true,
+    ))
+    app.main(["up", "--verbose", "foo", "bar", "baz"])
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors:
 - Yamashita Yuu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-02 00:00:00.000000000 Z
+date: 2015-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,47 +67,75 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.13.0
 - !ruby/object:Gem::Dependency
-  name: parslet
+  name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.2
+        version: 1.11.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.2
+        version: 1.11.2
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: oj
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.10
+        version: 2.12.14
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.10
+        version: 2.12.14
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.1
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.1
+        version: 1.6.2
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.10
 description: Yet another command-line tool for Datadog
 email:
 - peek824545201@gmail.com
@@ -153,6 +181,13 @@ files:
 - spec/formatter/text_spec.rb
 - spec/formatter/tsv_spec.rb
 - spec/formatter/yaml_spec.rb
+- spec/optparse/down_spec.rb
+- spec/optparse/hosts_spec.rb
+- spec/optparse/pssh_spec.rb
+- spec/optparse/search_spec.rb
+- spec/optparse/ssh_spec.rb
+- spec/optparse/tags_spec.rb
+- spec/optparse/up_spec.rb
 - spec/parser/glob_expression_spec.rb
 - spec/parser/parser_spec.rb
 - spec/parser/regexp_expression_spec.rb
@@ -192,6 +227,13 @@ test_files:
 - spec/formatter/text_spec.rb
 - spec/formatter/tsv_spec.rb
 - spec/formatter/yaml_spec.rb
+- spec/optparse/down_spec.rb
+- spec/optparse/hosts_spec.rb
+- spec/optparse/pssh_spec.rb
+- spec/optparse/search_spec.rb
+- spec/optparse/ssh_spec.rb
+- spec/optparse/tags_spec.rb
+- spec/optparse/up_spec.rb
 - spec/parser/glob_expression_spec.rb
 - spec/parser/parser_spec.rb
 - spec/parser/regexp_expression_spec.rb