hotdog 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 704ccd17864c284a1daa3550e9c955469e718ee4
-  data.tar.gz: 0d5e59e8c274f25ebd179e92123380c5336d7cec
+  metadata.gz: 9919088eda80ed6ec42ab4448a1e9474a8f6b3cf
+  data.tar.gz: b4659b72b4ee22337f1d74d14dad1d0d686b8bf0
 SHA512:
-  metadata.gz: 03d9ceb9147a75449c9b7542f3deecdb331cd0736d902603101508fbd1ef87881c82503b223dcd2c710f5f69c8408b173b95b1a17c57bbb08b5ca27857bfcc14
-  data.tar.gz: 5d32974bbbb07110a678538b5275ca792a1d76eb5ae086ad1b9831ff434d1937d4eae8f0ae4048df393bec2f81664223da444ba9aeee3467224b78bf4e0d375d
+  metadata.gz: 6cdebee0eaf5a3c347aa9fb8fae6f589467cf040edcad75d1d220d2b29a7842a7619f1b1149fe58bb1b116e6fc59ae248b48af5291655e03da4866ade02d1005
+  data.tar.gz: 9af471697553ce75493da82aedfa9f79c59f65de5a74407b7fbf626bc04571dcfb5e29be495021eecea48fd3814cecabf6abd87cb9f8abe3a36550a934f01868

data/lib/hotdog/application.rb

@@ -51,7 +51,8 @@ module Hotdog
         force: false,
         format: "text",
         headers: false,
-        status: STATUS_RUNNING,
+        source: nil,
+        status: nil,
         listing: false,
         logger: @logger,
         max_time: 5,
@@ -159,11 +160,21 @@ module Hotdog
       end
     end
 
+    def source()
+      options.fetch(:source, SOURCE_DATADOG)
+    end
+
+    def source_name(source=self.source)
+      {
+        SOURCE_DATADOG => "datadog",
+      }.fetch(source, "unknown")
+    end
+
     def status()
       options.fetch(:status, STATUS_RUNNING)
     end
 
-    def status_name()
+    def status_name(status=self.status)
       {
         STATUS_PENDING       => "pending",
         STATUS_RUNNING       => "running",
@@ -171,7 +182,7 @@ module Hotdog
         STATUS_TERMINATED    => "terminated",
         STATUS_STOPPING      => "stopping",
         STATUS_STOPPED       => "stopped",
-      }.fetch(self.status, "unknown")
+      }.fetch(status, "unknown")
     end
 
     private
@@ -215,22 +226,38 @@ module Hotdog
       @optparse.on("-h", "--[no-]headers", "Display headeres for each columns") do |v|
         options[:headers] = v
       end
+      @optparse.on("--source=SOURCE", "Specify custom host source") do |v|
+        case v
+        when /\A\d\z/i
+          options[:source] = v.to_i
+        when /\A(?:all|any)\z/i
+          options[:source] = nil
+        when /\A(?:datadog)\z/i
+          options[:source] = SOURCE_DATADOG
+        else
+          raise(OptionParser::InvalidArgument.new("unknown source: #{v}"))
+        end
+      end
       @optparse.on("--status=STATUS", "Specify custom host status") do |v|
         case v
-        when /\Apending\z/i
+        when /\A\d\z/i
+          options[:status] = v.to_i
+        when /\A(?:all|any)\z/i
+          options[:status] = nil
+        when /\A(?:pending)\z/i
           options[:status] = STATUS_PENDING
-        when /\Arunning\z/i
+        when /\A(?:running)\z/i
           options[:status] = STATUS_RUNNING
-        when /\Ashutting-down\z/i
+        when /\A(?:shutting-down)\z/i
           options[:status] = STATUS_SHUTTING_DOWN
-        when /\Aterminated\z/i
+        when /\A(?:terminated)\z/i
           options[:status] = STATUS_TERMINATED
-        when /\Astopping\z/i
+        when /\A(?:stopping)\z/i
           options[:status] = STATUS_STOPPING
-        when /\Astopped\z/i
+        when /\A(?:stopped)\z/i
           options[:status] = STATUS_STOPPED
         else
-          options[:status] = v.to_i
+          raise(OptionParser::InvalidArgument.new("unknown status: #{v}"))
         end
       end
       @optparse.on("-l", "--[no-]listing", "Use listing format") do |v|

data/lib/hotdog/commands/down.rb

@@ -60,9 +60,10 @@ module Hotdog
               @db.transaction do
                 sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
                 hosts.each_slice(sqlite_limit_compound_select - 1) do |hosts|
-                  q = "UPDATE hosts SET status = ? WHERE name IN (%s);" % hosts.map { "?" }.join(", ")
-                  execute_db(@db, q, [STATUS_STOPPING] + hosts)
+                  execute_db(@db, "DELETE FROM hosts_tags WHERE tag_id IN ( SELECT id FROM tags WHERE name = '@status' ) AND host_id IN ( SELECT id FROM hosts WHERE name IN (%s) );" % hosts.map { "?" }.join(", "), hosts)
+                  execute_db(@db, "UPDATE hosts SET status = ? WHERE name IN (%s);" % hosts.map { "?" }.join(", "), [STATUS_STOPPING] + hosts)
                 end
+                associate_tag_hosts(@db, "@status:#{application.status_name(STATUS_STOPPING)}", hosts)
               end
             end
           end

data/lib/hotdog/commands/search.rb

@@ -120,6 +120,14 @@ module Hotdog
           # return everything if given expression is empty
           expression = "*"
         end
+        if options[:source]
+          source_name = application.source_name(options[:source])
+          expression = "@source:#{source_name} AND (#{expression})"
+        end
+        if options[:status]
+          status_name = application.status_name(options[:status])
+          expression = "@status:#{status_name} AND (#{expression})"
+        end
         if options[:limit]
           expression = "LIMIT((#{expression}), #{options[:limit]})"
         end

data/lib/hotdog/commands/ssh.rb

@@ -15,6 +15,8 @@ module Hotdog
         default_option(options, :max_parallelism, Parallel.processor_count * 2)
         default_option(options, :shuffle, false)
         default_option(options, :ssh_config, nil)
+        # we must not need to run ssh against terminated hosts
+        default_option(options, :status, STATUS_RUNNING)
         optparse.on("-C", "Enable compression.") do |v|
           options[:ssh_options]["Compression"] = "yes"
         end

data/lib/hotdog/commands.rb

@@ -61,11 +61,7 @@ module Hotdog
 
       private
       def default_option(options, key, default_value)
-        if options.key?(key)
-          options[key]
-        else
-          options[key] = default_value
-        end
+        options[key] = default_value
       end
 
       def prepare(db, query)
@@ -81,15 +77,6 @@ module Hotdog
       end
 
       def get_hosts(host_ids, tags=nil)
-        status = application.status
-        n = Array(host_ids).length
-        host_ids = Array(host_ids).each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
-          execute("SELECT id FROM hosts WHERE status = ? AND id IN (%s);" % host_ids.map { "?" }.join(", "), [status] + host_ids).map { |row| row[0] }
-        }
-        m = host_ids.length
-        if n != m
-          logger.warn("filtered out #{n - m} host(s) out of #{n} due to status != #{application.status_name}.")
-        end
         tags ||= @options[:tags]
         update_db
         if host_ids.empty?
@@ -263,6 +250,7 @@ module Hotdog
             db = SQLite3::Database.new(persistent_db_path)
             copy_db(memory_db, db)
             close_db(memory_db)
+            $did_reload = true
             @db = db
           end
         end
@@ -295,6 +283,25 @@ module Hotdog
           execute_db(db, "CREATE TABLE IF NOT EXISTS hosts_tags (host_id INTEGER NOT NULL, tag_id INTEGER NOT NULL);")
           execute_db(db, "CREATE UNIQUE INDEX IF NOT EXISTS hosts_tags_host_id_tag_id ON hosts_tags (host_id, tag_id);")
 
+          execute_db(db, "CREATE TABLE IF NOT EXISTS source_names (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(200) NOT NULL COLLATE NOCASE);")
+          {
+            SOURCE_DATADOG => application.source_name(SOURCE_DATADOG),
+          }.each do |source_id, source_name|
+            execute_db(db, "INSERT OR IGNORE INTO source_names (id, name) VALUES (?, ?);", [source_id, source_name])
+          end
+                     
+          execute_db(db, "CREATE TABLE IF NOT EXISTS status_names (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(200) NOT NULL COLLATE NOCASE);")
+          {
+            STATUS_PENDING       => application.status_name(STATUS_PENDING),
+            STATUS_RUNNING       => application.status_name(STATUS_RUNNING),
+            STATUS_SHUTTING_DOWN => application.status_name(STATUS_SHUTTING_DOWN),
+            STATUS_TERMINATED    => application.status_name(STATUS_TERMINATED),
+            STATUS_STOPPING      => application.status_name(STATUS_STOPPING),
+            STATUS_STOPPED       => application.status_name(STATUS_STOPPED),
+          }.each do |status_id, status_name|
+            execute_db(db, "INSERT OR IGNORE INTO status_names (id, name) VALUES (?, ?);", [status_id, status_name])
+          end
+
           known_tags = all_tags.keys.map { |tag| split_tag(tag) }.uniq
           create_tags(db, known_tags)
 
@@ -362,20 +369,48 @@ module Hotdog
       end
 
       def create_hosts(db, hosts, downtimes)
-        hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2) do |hosts|
-          q = "INSERT OR IGNORE INTO hosts (name, status) VALUES %s;" % hosts.map { "(?, ?)" }.join(", ")
+        hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 3) do |hosts|
+          q = "INSERT OR IGNORE INTO hosts (name, source, status) VALUES %s;" % hosts.map { "(?, ?, ?)" }.join(", ")
           execute_db(db, q, hosts.map { |host|
+            source = SOURCE_DATADOG
             status = downtimes.include?(host) ? STATUS_STOPPED : STATUS_RUNNING
-            [host, status]
+            [host, source, status]
           })
         end
+
         # create virtual `host` tag
         execute_db(db, "INSERT OR IGNORE INTO tags (name, value) SELECT 'host', hosts.name FROM hosts;")
-        q = "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
+        execute_db(db,
+            "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
+              "SELECT hosts.id, tags.id FROM hosts " \
+                "INNER JOIN tags ON tags.name = 'host' AND hosts.name = tags.value;"
+        )
+
+        # create virtual `@host` tag
+        execute_db(db, "INSERT OR IGNORE INTO tags (name, value) SELECT '@host', hosts.name FROM hosts;")
+        execute_db(db,
+            "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
+              "SELECT hosts.id, tags.id FROM hosts " \
+                "INNER JOIN tags ON tags.name = '@host' AND hosts.name = tags.value;"
+        )
+
+        # create virtual `@source` tag
+        execute_db(db, "INSERT OR IGNORE INTO tags (name, value) SELECT '@source', name FROM source_names;")
+        execute_db(db,
+            "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
+              "SELECT hosts.id, tags.id FROM hosts " \
+                "INNER JOIN source_names ON hosts.source = source_names.id " \
+                "INNER JOIN tags ON tags.name = '@source' AND source_names.name = tags.value;"
+        )
+
+        # create virtual `@status` tag
+        execute_db(db, "INSERT OR IGNORE INTO tags (name, value) SELECT '@status', name FROM status_names;")
+        execute_db(db,
+            "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
               "SELECT hosts.id, tags.id FROM hosts " \
-                "INNER JOIN ( SELECT * FROM tags WHERE name = 'host' ) AS tags " \
-                  "ON hosts.name = tags.value;"
-        execute_db(db, q)
+                "INNER JOIN status_names ON hosts.status = status_names.id " \
+                "INNER JOIN tags ON tags.name = '@status' AND status_names.name = tags.value;"
+        )
       end
 
       def create_tags(db, tags)

data/lib/hotdog/expression/semantics.rb

@@ -59,9 +59,13 @@ module Hotdog
             (min / (sqlite_limit_compound_select - 2)).upto(max / (sqlite_limit_compound_select - 2)).flat_map { |i|
               range = ((sqlite_limit_compound_select - 2) * i)...((sqlite_limit_compound_select - 2) * (i + 1))
               selected = values.select { |n| range === n }
-              q = "SELECT id FROM hosts " \
-                    "WHERE ? <= id AND id < ? AND id NOT IN (%s);"
-              environment.execute(q % selected.map { "?" }.join(", "), [range.first, range.last] + selected).map { |row| row.first }
+              if 0 < selected.length
+                q = "SELECT id FROM hosts " \
+                      "WHERE ? <= id AND id < ? AND id NOT IN (%s);"
+                environment.execute(q % selected.map { "?" }.join(", "), [range.first, range.last] + selected).map { |row| row.first }
+              else
+                []
+              end
             }.tap do |values|
               environment.logger.debug("NOT expr: #{values.length} value(s)")
             end
@@ -201,9 +205,13 @@ module Hotdog
                 range = (((sqlite_limit_compound_select - 2) / 2) * i)...(((sqlite_limit_compound_select - 2) / 2) * (i + 1))
                 left_selected = left_values.select { |n| range === n }
                 right_selected = right_values.select { |n| range === n }
-                q = "SELECT id FROM hosts " \
-                      "WHERE ? <= id AND id < ? AND ( id IN (%s) AND id IN (%s) );"
-                environment.execute(q % [left_selected.map { "?" }.join(", "), right_selected.map { "?" }.join(", ")], [range.first, range.last] + left_selected + right_selected).map { |row| row.first }
+                if 0 < left_selected.length and 0 < right_selected.length
+                  q = "SELECT id FROM hosts " \
+                        "WHERE ? <= id AND id < ? AND ( id IN (%s) AND id IN (%s) );"
+                  environment.execute(q % [left_selected.map { "?" }.join(", "), right_selected.map { "?" }.join(", ")], [range.first, range.last] + left_selected + right_selected).map { |row| row.first }
+                else
+                  []
+                end
               }.tap do |values|
                 environment.logger.debug("lhs(#{left_values.length}) AND rhs(#{right_values.length}) => #{values.length}")
               end

data/lib/hotdog/expression/syntax.rb

@@ -106,9 +106,9 @@ module Hotdog
         )
       }
       rule(:tag) {
-        ( regexp.as(:tagname_regexp) >> separator.as(:separator) >> regexp.as(:tagvalue_regexp) \
-        | regexp.as(:tagname_regexp) >> separator.as(:separator) \
-        | regexp.as(:tagname_regexp) \
+        ( tagname_regexp.as(:tagname_regexp) >> separator.as(:separator) >> tagvalue_regexp.as(:tagvalue_regexp) \
+        | tagname_regexp.as(:tagname_regexp) >> separator.as(:separator) \
+        | tagname_regexp.as(:tagname_regexp) \
         | tagname_glob.as(:tagname_glob) >> separator.as(:separator) >> tagvalue_glob.as(:tagvalue_glob) \
         | tagname_glob.as(:tagname_glob) >> separator.as(:separator) >> tagvalue.as(:tagvalue) \
         | tagname_glob.as(:tagname_glob) >> separator.as(:separator) \
@@ -117,6 +117,10 @@ module Hotdog
         | tagname.as(:tagname) >> separator.as(:separator) >> tagvalue.as(:tagvalue) \
         | tagname.as(:tagname) >> separator.as(:separator) \
         | tagname.as(:tagname) \
+        | (str('@') >> tagname).as(:tagname) >> separator.as(:separator) >> tagvalue_glob.as(:tagvalue_glob) \
+        | (str('@') >> tagname).as(:tagname) >> separator.as(:separator) >> tagvalue.as(:tagvalue) \
+        | (str('@') >> tagname).as(:tagname) >> separator.as(:separator) \
+        | (str('@') >> tagname).as(:tagname) \
         | separator.as(:separator) >> regexp.as(:tagvalue_regexp) \
         | separator.as(:separator) >> tagvalue_glob.as(:tagvalue_glob) \
         | separator.as(:separator) >> tagvalue.as(:tagvalue) \

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.30.0"
+  VERSION = "0.31.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Yamashita Yuu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-15 00:00:00.000000000 Z
+date: 2017-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler