hotdog 0.31.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9919088eda80ed6ec42ab4448a1e9474a8f6b3cf
-  data.tar.gz: b4659b72b4ee22337f1d74d14dad1d0d686b8bf0
+  metadata.gz: 2b24f0d15a198f0128ee1783589bff4f6d5ea013
+  data.tar.gz: 2793030c132d22df90fb3ff67bb05cc6c1fd6a35
 SHA512:
-  metadata.gz: 6cdebee0eaf5a3c347aa9fb8fae6f589467cf040edcad75d1d220d2b29a7842a7619f1b1149fe58bb1b116e6fc59ae248b48af5291655e03da4866ade02d1005
-  data.tar.gz: 9af471697553ce75493da82aedfa9f79c59f65de5a74407b7fbf626bc04571dcfb5e29be495021eecea48fd3814cecabf6abd87cb9f8abe3a36550a934f01868
+  metadata.gz: 6b563f78db988f5000c455872d1680c6d91d4668c9ad1f033cbfc390501c2f97d421d22afeb236854c6cfbb8425658b5892e7c03af73c2f31deb417d0a3df323
+  data.tar.gz: cb5148c263ae888617fb03b6c86a15c2550cf03241e0e60af1556de7b26bb350b7f89f518a545cdd734ce3dfe1ac3bbbf059c004848adecaf157cc0b09ce28c3

data/lib/hotdog/application.rb

@@ -65,6 +65,9 @@ module Hotdog
         display_search_tags: false,
         verbose: false,
         verbosity: VERBOSITY_NULL,
+      }.reject { |key, val|
+        # reject nil values to declare sensible default later in subcommand
+        val.nil?
       }
 
       define_options

data/lib/hotdog/commands.rb

@@ -61,7 +61,11 @@ module Hotdog
 
       private
       def default_option(options, key, default_value)
-        options[key] = default_value
+        if options.key?(key)
+          options[key]
+        else
+          options[key] = default_value
+        end
       end
 
       def prepare(db, query)
@@ -93,12 +97,12 @@ module Hotdog
               if @options[:primary_tag]
                 fields = [
                   @options[:primary_tag],
-                  "host",
+                  "@host",
                 ] + get_fields(host_ids).reject { |tagname| tagname == @options[:primary_tag] }
                 get_hosts_fields(host_ids, fields)
               else
                 fields = [
-                  "host",
+                  "@host",
                 ] + get_fields(host_ids)
                 get_hosts_fields(host_ids, fields)
               end
@@ -106,7 +110,7 @@ module Hotdog
               if @options[:primary_tag]
                 get_hosts_fields(host_ids, [@options[:primary_tag]])
               else
-                get_hosts_fields(host_ids, ["host"])
+                get_hosts_fields(host_ids, ["@host"])
               end
             end
           end
@@ -378,14 +382,6 @@ module Hotdog
           })
         end
 
-        # 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 `@host` tag
         execute_db(db, "INSERT OR IGNORE INTO tags (name, value) SELECT '@host', hosts.name FROM hosts;")
         execute_db(db,
@@ -457,14 +453,27 @@ module Hotdog
 
       def split_tag(tag)
         tagname, tagvalue = tag.split(":", 2)
-        [tagname, tagvalue || ""]
+        [rewrite_legacy_tagname(tagname), tagvalue || ""]
       end
 
       def join_tag(tagname, tagvalue)
         if tagvalue.to_s.empty?
-          tagname
+          rewrite_legacy_tagname(tagname)
+        else
+          "#{rewrite_legacy_tagname(tagname)}:#{tagvalue}"
+        end
+      end
+
+      def rewrite_legacy_tagname(s)
+        case s
+        when "host"
+          # Starting from v0.31.0, hotdog started using _internal_ tags with leading `@` in name.
+          #
+          # This workaround is to keep legacy `host` tag for backward compatibility by rewriting
+          # it as the reference to the internal tag of `@host` without any user action.
+          "@#{s}"
         else
-          "#{tagname}:#{tagvalue}"
+          s
         end
       end
 

data/lib/hotdog/commands/up.rb

@@ -42,8 +42,19 @@ module Hotdog
           scope.slice("host:".length, scope.length)
         }
         if 0 < hosts.length
-          # refresh all persistent.db to retrieve information about up'd host
-          remove_db(@db)
+          # Try reloading database after error as a workaround for nested transaction.
+          with_retry(error_handler: ->(error) { reload }) do
+            if open_db
+              @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|
+                  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_RUNNING] + hosts)
+                end
+                associate_tag_hosts(@db, "@status:#{application.status_name(STATUS_RUNNING)}", hosts)
+              end
+            end
+          end
         end
       end
 

data/lib/hotdog/expression.rb

@@ -64,77 +64,77 @@ module Hotdog
         UnaryExpressionNode.new(unary_op, expression)
       }
       rule(tagname_regexp: simple(:tagname_regexp), separator: simple(:separator), tagvalue_regexp: simple(:tagvalue_regexp)) {
-        if "/host/" == tagname_regexp
+        if "/@host/" == tagname_regexp or "/host/" == tagname_regexp
           RegexpHostNode.new(tagvalue_regexp, separator)
         else
           RegexpTagNode.new(tagname_regexp, tagvalue_regexp, separator)
         end
       }
       rule(tagname_regexp: simple(:tagname_regexp), separator: simple(:separator)) {
-        if "/host/" == tagname_regexp
+        if "/@host/" == tagname_regexp or "/host/" == tagname_regexp
           EverythingNode.new()
         else
           RegexpTagnameNode.new(tagname_regexp, separator)
         end
       }
       rule(tagname_regexp: simple(:tagname_regexp)) {
-        if "/host/" == tagname_regexp
+        if "/@host/" == tagname_regexp or "/host/" == tagname_regexp
           EverythingNode.new()
         else
           RegexpHostOrTagNode.new(tagname_regexp)
         end
       }
       rule(tagname_glob: simple(:tagname_glob), separator: simple(:separator), tagvalue_glob: simple(:tagvalue_glob)) {
-        if "host" == tagname_glob
+        if "@host" == tagname_glob or "host" == tagname_glob
           GlobHostNode.new(tagvalue_glob, separator)
         else
           GlobTagNode.new(tagname_glob, tagvalue_glob, separator)
         end
       }
       rule(tagname_glob: simple(:tagname_glob), separator: simple(:separator), tagvalue: simple(:tagvalue)) {
-        if "host" == tagname_glob
+        if "@host" == tagname_glob or "host" == tagname_glob
           GlobHostNode.new(tagvalue, separator)
         else
           GlobTagNode.new(tagname_glob, tagvalue, separator)
         end
       }
       rule(tagname_glob: simple(:tagname_glob), separator: simple(:separator)) {
-        if "host" == tagname_glob
+        if "@host" == tagname_glob or "host" == tagname_glob
           EverythingNode.new()
         else
           GlobTagnameNode.new(tagname_glob, separator)
         end
       }
       rule(tagname_glob: simple(:tagname_glob)) {
-        if "host" == tagname_glob
+        if "@host" == tagname_glob or "host" == tagname_glob
           EverythingNode.new()
         else
           GlobHostOrTagNode.new(tagname_glob)
         end
       }
       rule(tagname: simple(:tagname), separator: simple(:separator), tagvalue_glob: simple(:tagvalue_glob)) {
-        if "host" == tagname
+        if "@host" == tagname or "host" == tagname
           GlobHostNode.new(tagvalue_glob, separator)
         else
           GlobTagNode.new(tagname, tagvalue_glob, separator)
         end
       }
       rule(tagname: simple(:tagname), separator: simple(:separator), tagvalue: simple(:tagvalue)) {
-        if "host" == tagname
+        if "@host" == tagname or "host" == tagname
           StringHostNode.new(tagvalue, separator)
         else
           StringTagNode.new(tagname, tagvalue, separator)
         end
       }
       rule(tagname: simple(:tagname), separator: simple(:separator)) {
-        if "host" == tagname
+        if "@host" == tagname or "host" == tagname
           EverythingNode.new()
         else
           StringTagnameNode.new(tagname, separator)
         end
       }
       rule(tagname: simple(:tagname)) {
-        if "host" == tagname
+        if "@host" == tagname or "host" == tagname
           EverythingNode.new()
         else
           StringHostOrTagNode.new(tagname)

data/lib/hotdog/expression/semantics.rb

@@ -746,7 +746,7 @@ module Hotdog
 
     class AnyHostNode < TagExpressionNode
       def initialize(separator=nil, options={})
-        super("host", nil, separator, options)
+        super("@host", nil, separator, options)
       end
 
       def condition(options={})
@@ -767,7 +767,7 @@ module Hotdog
 
     class StringHostNode < StringExpressionNode
       def initialize(tagvalue, separator=nil, options={})
-        super("host", tagvalue.to_s, separator, options)
+        super("@host", tagvalue.to_s, separator, options)
       end
 
       def condition(options={})
@@ -918,7 +918,7 @@ module Hotdog
 
     class GlobHostNode < GlobExpressionNode
       def initialize(tagvalue, separator=nil, options={})
-        super("host", tagvalue.to_s, separator, options)
+        super("@host", tagvalue.to_s, separator, options)
       end
 
       def condition(options={})
@@ -1073,7 +1073,7 @@ module Hotdog
         when /\A\/(.*)\/\z/
           tagvalue = $1
         end
-        super("host", tagvalue, separator, options)
+        super("@host", tagvalue, separator, options)
       end
 
       def condition(options={})

data/lib/hotdog/version.rb

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

data/spec/core/commands_spec.rb

@@ -27,7 +27,7 @@ describe "commands" do
     allow(cmd).to receive(:execute).with("SELECT id FROM hosts WHERE status = ? AND id IN (?, ?, ?);", [Hotdog::STATUS_RUNNING, 1, 2, 3]) {
       [[1], [2], [3]]
     }
-    allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["host"])
+    allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["@host"])
     expect(cmd.__send__(:get_hosts, [1, 2, 3], []))
   end
 
@@ -68,7 +68,7 @@ describe "commands" do
     allow(cmd).to receive(:execute).with(q1.join(" "), [1, 2, 3]) {
       [["foo"], ["bar"], ["baz"]]
     }
-    allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["host", "foo", "bar", "baz"])
+    allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["@host", "foo", "bar", "baz"])
     expect(cmd.__send__(:get_hosts, [1, 2, 3], []))
   end
 
@@ -87,7 +87,7 @@ describe "commands" do
     allow(cmd).to receive(:execute).with(q1.join(" "), [1, 2, 3]) {
       [["foo"], ["bar"], ["baz"]]
     }
-    allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["bar", "host", "foo", "baz"])
+    allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["bar", "@host", "foo", "baz"])
     expect(cmd.__send__(:get_hosts, [1, 2, 3], []))
   end
 
@@ -127,15 +127,15 @@ describe "commands" do
           "WHERE hosts_tags.host_id = ? AND tags.name IN (?, ?, ?)",
             "GROUP BY tags.name;",
     ]
-    allow(cmd).to receive(:execute).with(q1.join(" "), [1, "foo", "bar", "host"]) {
-      [["foo", "foo1"], ["bar", "bar1"], ["host", "host1"]]
+    allow(cmd).to receive(:execute).with(q1.join(" "), [1, "foo", "bar", "@host"]) {
+      [["foo", "foo1"], ["bar", "bar1"], ["@host", "host1"]]
     }
-    allow(cmd).to receive(:execute).with(q1.join(" "), [2, "foo", "bar", "host"]) {
-      [["foo", "foo2"], ["bar", "bar2"], ["host", "host2"]]
+    allow(cmd).to receive(:execute).with(q1.join(" "), [2, "foo", "bar", "@host"]) {
+      [["foo", "foo2"], ["bar", "bar2"], ["@host", "host2"]]
     }
-    allow(cmd).to receive(:execute).with(q1.join(" "), [3, "foo", "bar", "host"]) {
-      [["foo", "foo3"], ["bar", "bar3"], ["host", "host3"]]
+    allow(cmd).to receive(:execute).with(q1.join(" "), [3, "foo", "bar", "@host"]) {
+      [["foo", "foo3"], ["bar", "bar3"], ["@host", "host3"]]
     }
-    expect(cmd.__send__(:get_hosts_fields, [1, 2, 3], ["foo", "bar", "host"])).to eq([[["foo1", "bar1", "host1"], ["foo2", "bar2", "host2"], ["foo3", "bar3", "host3"]], ["foo", "bar", "host"]])
+    expect(cmd.__send__(:get_hosts_fields, [1, 2, 3], ["foo", "bar", "@host"])).to eq([[["foo1", "bar1", "host1"], ["foo2", "bar2", "host2"], ["foo3", "bar3", "host3"]], ["foo", "bar", "@host"]])
   end
 end

data/spec/evaluator/glob_expression_spec.rb

@@ -24,7 +24,7 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tagname_glob: "host", separator: ":", tagvalue_glob: "foo*"})
+    expect(expr.dump).to eq({tagname_glob: "@host", separator: ":", tagvalue_glob: "foo*"})
   end
 
   it "interprets tag glob with tagname and tagvalue" do

data/spec/evaluator/regexp_expression_spec.rb

@@ -24,7 +24,7 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tagname_regexp: "host", separator: ":", tagvalue_regexp: "foo"})
+    expect(expr.dump).to eq({tagname_regexp: "@host", separator: ":", tagvalue_regexp: "foo"})
   end
 
   it "interprets tag regexp with tagname and tagvalue" do

data/spec/evaluator/string_expression_spec.rb

@@ -24,7 +24,7 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tagname: "host", separator: ":", tagvalue: "foo"})
+    expect(expr.dump).to eq({tagname: "@host", separator: ":", tagvalue: "foo"})
   end
 
   it "interprets tag with tagname and tagvalue" do

data/spec/optimizer/glob_expression_spec.rb

@@ -9,7 +9,7 @@ describe "tag glob expression" do
     it "interprets tag glob with host (#{o})" do
       expr = Hotdog::Expression::GlobHostNode.new("foo*", ":")
       expect(optimize_n(o+1, expr).dump).to eq({
-        tagname_glob: "host",
+        tagname_glob: "@host",
         separator: ":",
         tagvalue_glob: "foo*",
         fallback: {

data/spec/optimizer/regexp_expression_spec.rb

@@ -9,7 +9,7 @@ describe "tag regexp expression" do
     it "interprets tag regexp with host (#{o})" do
       expr = Hotdog::Expression::RegexpHostNode.new("foo", ":")
       expect(optimize_n(o+1, expr).dump).to eq({
-        tagname_regexp: "host",
+        tagname_regexp: "@host",
          separator: ":",
          tagvalue_regexp: "foo",
       })

data/spec/optimizer/string_expression_spec.rb

@@ -9,7 +9,7 @@ describe "tag expression" do
     it "interprets tag with host (#{o})" do
       expr = Hotdog::Expression::StringHostNode.new("foo", ":")
       expect(optimize_n(o+1, expr).dump).to eq({
-        tagname: "host",
+        tagname: "@host",
         separator: ":",
         tagvalue: "foo",
         fallback: {

data/spec/optimizer/unary_expression_spec.rb

@@ -104,7 +104,7 @@ describe "unary expression" do
         ),
       )
       expect(optimize_n(o+1, expr).dump).to eq({
-        tagname: "host",
+        tagname: "@host",
         separator: ":",
         tagvalue: "foo",
         fallback: {
@@ -140,7 +140,7 @@ describe "unary expression" do
         Hotdog::Expression::StringHostNode.new("foo", ":"),
       )
       expect(optimize_n(o+1, expr).dump).to eq({
-        tagname: "host",
+        tagname: "@host",
         separator: ":",
         tagvalue: "foo",
         fallback: {
@@ -162,7 +162,7 @@ describe "unary expression" do
         ),
       )
       expect(optimize_n(o+1, expr).dump).to eq({
-        tagname: "host",
+        tagname: "@host",
         separator: ":",
         tagvalue: "foo",
         fallback: {
@@ -187,7 +187,7 @@ describe "unary expression" do
         ),
       )
       expect(optimize_n(o+1, expr).dump).to eq({
-        tagname: "host",
+        tagname: "@host",
         separator: ":",
         tagvalue: "foo",
         fallback: {
@@ -263,7 +263,7 @@ describe "unary expression" do
         ),
       )
       expect(optimize_n(o+1, expr).dump).to eq({
-        tagname: "host",
+        tagname: "@host",
         separator: ":",
         tagvalue: "foo",
         fallback: {
@@ -288,7 +288,7 @@ describe "unary expression" do
         ),
       )
       expect(optimize_n(o+1, expr).dump).to eq({
-        tagname: "host",
+        tagname: "@host",
         separator: ":",
         tagvalue: "foo",
         fallback: {
@@ -313,7 +313,7 @@ describe "unary expression" do
         ),
       )
       expect(optimize_n(o+1, expr).dump).to eq({
-        tagname: "host",
+        tagname: "@host",
         separator: ":",
         tagvalue: "foo",
         fallback: {

metadata

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