hotdog 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12b1b97f8c77f181a665ba52db0725c613d638a7
-  data.tar.gz: 73be8bb8526df6c4bb95811e6e56de196fae0a73
+  metadata.gz: fccd372d49246c2c85768c9244a29746fafcfb40
+  data.tar.gz: 9b4d490218a3d93af4806b12d47dfca28f8d90f8
 SHA512:
-  metadata.gz: 602156cf61f52c8f8c14937dcf324b93516ac16b6f0e61c971bcccb124a7827902e313c400fdcb98eb54d83f8ae2cf7a21783d4f1937df18899c20782380224a
-  data.tar.gz: eb9ab65fad8b6b25e59eec751cc02b4a99cc0d69fc5f2fc61a7c6df2c9fbce5055928ed2ab8f2c85b7af2a8580f9db51e5534c277fac89a100ab7e9b7064eb27
+  metadata.gz: 8e21eb61e7ccfc2b533e005eb1f494ead1c16c12cd21e0384d46228e88f3a5d6771a62f9006fca59bc538e680e4a7370f1a1905c3e1aa314ea368e4b97146a92
+  data.tar.gz: 654ccf67781c3c1a7ebc1f59fac07a5dd6319231474e6ffadcd08309d32b062efe7e543c1db83f7d821bb054a6ea31c111b7c717f63f0692b3929a6fc79df971

data/README.md

@@ -100,24 +100,33 @@ $ hotdog ssh availability-zone:us-east-1b and 'name:web-*' -t public_ipv4 -u use
 Acceptable expressions in pseudo BNF.
 
 ```
-expression: binary_expression
-          | term
+expression: expression0
           ;
 
-binary_expression: term "&&" term
-                 | term "||" term
-                 | term "and" term
-                 | term "or" term
-                 ;
-
-unary_expression: '!' expression
-                | '~' expression
-                | "not" expression
-                ;
-
-term: unary_expression
-    | atom
-    ;
+expression0: expression1 "and" expression
+           | expression1 "or" expression
+           | expression1
+           ;
+
+expression1: "not" expression
+           | expression2
+           ;
+
+expression2: expression3 expression
+           | expression3
+           ;
+
+expression3: expression4 "&&" expression
+           | expression4 "||" expression
+           | expression4
+           ;
+
+expression4: '!' atom
+           | '~' atom
+           | '!' expression
+           | '~' expression
+           | atom
+           ;
 
 atom: '(' expression ')'
     | IDENTIFIER separator ATTRIBUTE

data/lib/hotdog/commands/search.rb

@@ -79,38 +79,49 @@ module Hotdog
       class ExpressionParser < Parslet::Parser
         root(:expression)
         rule(:expression) {
-          ( binary_expression \
-          | term \
+          ( expression0 \
           )
         }
-        rule(:binary_op) {
-          ( str('&') >> str('&').maybe \
-          | str('|') >> str('|').maybe \
-          | match('[Aa]') >> match('[Nn]') >> match('[Dd]') \
-          | match('[Oo]') >> match('[Rr]') \
+        rule(:expression0) {
+          ( expression1.as(:left) >> spacing.maybe >> binary_op.as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+          | expression1 \
           )
         }
-        rule(:binary_expression) {
-          ( term.as(:left) >> spacing.maybe >> binary_op.as(:binary_op) >> spacing.maybe >> expression.as(:right) \
-          | term.as(:left) >> spacing.maybe.as(:binary_op) >> expression.as(:right) \
+        rule(:expression1) {
+          ( unary_op.as(:unary_op) >> spacing.maybe >> expression.as(:expression) \
+          | expression2 \
           )
         }
-        rule(:unary_op) {
-          ( str('!') \
-          | str('~') \
-          | match('[Nn]') >> match('[Oo]') >> match('[Tt]') \
+        rule(:expression2) {
+          ( expression3.as(:left) >> spacing.maybe.as(:binary_op) >> expression.as(:right) \
+          | expression3 \
           )
         }
-        rule(:unary_expression) {
-          ( spacing.maybe >> unary_op.as(:unary_op) >> term.as(:expression) \
-          | spacing.maybe >> unary_op.as(:unary_op) >> expression.as(:expression) \
+        rule(:expression3) {
+          ( expression4.as(:left) >> spacing.maybe >> str('&&').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+          | expression4.as(:left) >> spacing.maybe >> str('||').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+          | expression4.as(:left) >> spacing.maybe >> str('&').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+          | expression4.as(:left) >> spacing.maybe >> str('|').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+          | expression4 \
           )
         }
-        rule(:term) {
-          ( unary_expression \
+        rule(:expression4) {
+          ( str('!').as(:unary_op) >> spacing.maybe >> atom.as(:expression) \
+          | str('~').as(:unary_op) >> spacing.maybe >> atom.as(:expression) \
+          | str('!').as(:unary_op) >> spacing.maybe >> expression.as(:expression) \
+          | str('~').as(:unary_op) >> spacing.maybe >> expression.as(:expression) \
           | atom \
           )
         }
+        rule(:binary_op) {
+          ( str('and') \
+          | str('or') \
+          )
+        }
+        rule(:unary_op) {
+          ( str('not') \
+          )
+        }
         rule(:atom) {
           ( spacing.maybe >> str('(') >> expression >> str(')') >> spacing.maybe \
           | spacing.maybe >> identifier_regexp.as(:identifier_regexp) >> separator >> attribute_regexp.as(:attribute_regexp) >> spacing.maybe \
@@ -137,11 +148,11 @@ module Hotdog
           )
         }
         rule(:identifier_glob) {
-          ( unary_op.absent? >> binary_op.absent? >> identifier.repeat(0) >> (glob >> identifier.maybe).repeat(1) \
+          ( binary_op.absent? >> unary_op.absent? >> identifier.repeat(0) >> (glob >> identifier.maybe).repeat(1) \
           )
         }
         rule(:identifier) {
-          ( unary_op.absent? >> binary_op.absent? >> match('[A-Za-z]') >> match('[-./0-9A-Z_a-z]').repeat(0) \
+          ( binary_op.absent? >> unary_op.absent? >> match('[A-Za-z]') >> match('[-./0-9A-Z_a-z]').repeat(0) \
           )
         }
         rule(:separator) {
@@ -154,11 +165,11 @@ module Hotdog
           )
         }
         rule(:attribute_glob) {
-          ( unary_op.absent? >> binary_op.absent? >> attribute.repeat(0) >> (glob >> attribute.maybe).repeat(1) \
+          ( binary_op.absent? >> unary_op.absent? >> attribute.repeat(0) >> (glob >> attribute.maybe).repeat(1) \
           )
         }
         rule(:attribute) {
-          ( unary_op.absent? >> binary_op.absent? >> match('[-./0-9:A-Z_a-z]').repeat(1) \
+          ( binary_op.absent? >> unary_op.absent? >> match('[-./0-9:A-Z_a-z]').repeat(1) \
           )
         }
         rule(:glob) {

data/lib/hotdog/commands.rb

@@ -80,36 +80,7 @@ module Hotdog
               tag_name, tag_value = split_tag(tag)
               tag_name
             }
-            fields_without_host = fields.reject { |tag_name| tag_name == "host" }
-            if fields == fields_without_host
-              host_names = {}
-            else
-              host_names = Hash[
-                host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
-                  execute("SELECT id, name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }
-                }
-              ]
-            end
-            q1 = "SELECT tags.name, GROUP_CONCAT(tags.value, ',') FROM hosts_tags " \
-                   "INNER JOIN hosts ON hosts_tags.host_id = hosts.id " \
-                   "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                     "WHERE hosts_tags.host_id = ? AND tags.name IN (%s) " \
-                       "GROUP BY tags.name;"
-            result = host_ids.map { |host_id|
-              tag_values = Hash[
-                fields_without_host.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 1).flat_map { |fields_without_host|
-                  execute(q1 % fields_without_host.map { "?" }.join(", "), [host_id] + fields_without_host).map { |row| row.to_a }
-                }
-              ]
-              fields.map { |tag_name|
-                if tag_name == "host"
-                  host_names.fetch(host_id, "")
-                else
-                  tag_values.fetch(tag_name, "")
-                end
-              }
-            }
-            [result, fields]
+            get_hosts_fields(host_ids, fields)
           else
             if @options[:listing]
               q1 = "SELECT DISTINCT tags.name FROM hosts_tags " \
@@ -124,61 +95,62 @@ module Hotdog
                     tag_name == @options[:primary_tag]
                   }
                 }
+                get_hosts_fields(host_ids, fields)
               else
                 fields = [
                   "host",
                 ] + host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
                   execute(q1 % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.first }
                 }
+                get_hosts_fields(host_ids, fields)
               end
-              host_names = Hash[
-                host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
-                  execute("SELECT id, name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }
-                }
-              ]
-              q2 = "SELECT tags.name, GROUP_CONCAT(tags.value, ',') FROM hosts_tags " \
-                     "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                       "WHERE hosts_tags.host_id = ? AND tags.name IN (%s) " \
-                         "GROUP BY tags.name;"
-              fields_without_host = fields.reject { |tag_name| tag_name == "host" }
-              result = host_ids.map { |host_id|
-                tag_values = Hash[
-                  fields_without_host.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 1).flat_map { |fields_without_host|
-                    execute(q2 % fields_without_host.map { "?" }.join(", "), [host_id] + fields_without_host).map { |row| row.to_a }
-                  }
-                ]
-                fields.map { |tag_name|
-                  if tag_name == "host"
-                    host_names.fetch(host_id, "")
-                  else
-                    tag_values.fetch(tag_name, "")
-                  end
-                }
-              }
-              [result, fields]
             else
               if @options[:primary_tag]
-                fields = [@options[:primary_tag]]
-                q1 = "SELECT tags.value FROM hosts_tags " \
-                       "INNER JOIN hosts ON hosts_tags.host_id = hosts.id " \
-                       "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                         "WHERE hosts_tags.host_id IN (%s) AND tags.name = ?;"
-                result = host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 1).flat_map { |host_ids|
-                  execute(q1 % host_ids.map { "?" }.join(", "), host_ids + [@options[:primary_tag]]).map { |row| row.to_a }
-                }
-                [result, fields]
+                get_hosts_fields(host_ids, [@options[:primary_tag]])
               else
-                fields = ["host"]
-                result = host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
-                  execute("SELECT name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }
-                }
-                [result, fields]
+                get_hosts_fields(host_ids, ["host"])
               end
             end
           end
         end
       end
 
+      def get_hosts_fields(host_ids, fields)
+        if fields.empty?
+          [[], fields]
+        else
+          fields_without_host = fields.reject { |tag_name| tag_name == "host" }
+          if fields == fields_without_host
+            host_names = {}
+          else
+            host_names = Hash[
+              host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
+                execute("SELECT id, name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }
+              }
+            ]
+          end
+          q1 = "SELECT tags.name, GROUP_CONCAT(tags.value, ',') FROM hosts_tags " \
+                 "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
+                   "WHERE hosts_tags.host_id = ? AND tags.name IN (%s) " \
+                     "GROUP BY tags.name;"
+          result = host_ids.map { |host_id|
+            tag_values = Hash[
+              fields_without_host.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 1).flat_map { |fields_without_host|
+                execute(q1 % fields_without_host.map { "?" }.join(", "), [host_id] + fields_without_host).map { |row| row.to_a }
+              }
+            ]
+            fields.map { |tag_name|
+              if tag_name == "host"
+                host_names.fetch(host_id, "")
+              else
+                tag_values.fetch(tag_name, "")
+              end
+            }
+          }
+          [result, fields]
+        end
+      end
+
       def close_db(db, options={})
         @prepared_statements = @prepared_statements.reject { |k, statement|
           (db.hash & MASK_DATABASE == k & MASK_DATABASE).tap do |delete_p|

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/spec/core/commands_spec.rb

@@ -0,0 +1,122 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands"
+
+describe "commands" do
+  let(:cmd) {
+    Hotdog::Commands::Search.new(Hotdog::Application.new)
+  }
+
+  before(:each) do
+    ENV["DATADOG_API_KEY"] = "DATADOG_API_KEY"
+    ENV["DATADOG_APPLICATION_KEY"] = "DATADOG_APPLICATION_KEY"
+  end
+
+  it "get empty hosts" do
+    cmd.options[:listing] = false
+    cmd.options[:primary_tag] = nil
+    allow(cmd).to receive(:update_db)
+    expect(cmd.__send__(:get_hosts, [], [])).to eq([[], []])
+  end
+
+  it "get hosts" do
+    cmd.options[:listing] = false
+    cmd.options[:primary_tag] = nil
+    allow(cmd).to receive(:update_db)
+    allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["host"])
+    expect(cmd.__send__(:get_hosts, [1, 2, 3], []))
+  end
+
+  it "get hosts with primary tag" do
+    cmd.options[:listing] = false
+    cmd.options[:primary_tag] = "foo"
+    allow(cmd).to receive(:update_db)
+    allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["foo"])
+    expect(cmd.__send__(:get_hosts, [1, 2, 3], []))
+  end
+
+  it "get hosts with tags" do
+    cmd.options[:listing] = false
+    cmd.options[:primary_tag] = nil
+    allow(cmd).to receive(:update_db)
+    allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["foo", "bar", "baz"])
+    expect(cmd.__send__(:get_hosts, [1, 2, 3], ["foo", "bar", "baz"]))
+  end
+
+  it "get hosts with all tags" do
+    cmd.options[:listing] = true
+    cmd.options[:primary_tag] = nil
+    allow(cmd).to receive(:update_db)
+    q1 = [
+      "SELECT DISTINCT tags.name FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE hosts_tags.host_id IN (?, ?, ?);",
+    ]
+    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"])
+    expect(cmd.__send__(:get_hosts, [1, 2, 3], []))
+  end
+
+  it "get hosts with all tags with primary tag" do
+    cmd.options[:listing] = true
+    cmd.options[:primary_tag] = "bar"
+    allow(cmd).to receive(:update_db)
+    q1 = [
+      "SELECT DISTINCT tags.name FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE hosts_tags.host_id IN (?, ?, ?);",
+    ]
+    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"])
+    expect(cmd.__send__(:get_hosts, [1, 2, 3], []))
+  end
+
+  it "get empty host fields" do
+    expect(cmd.__send__(:get_hosts_fields, [1, 2, 3], [])).to eq([[], []])
+  end
+
+  it "get host fields without host" do
+    q1 = [
+      "SELECT tags.name, GROUP_CONCAT(tags.value, ',') FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE hosts_tags.host_id = ? AND tags.name IN (?, ?, ?)",
+            "GROUP BY tags.name;",
+    ]
+    allow(cmd).to receive(:execute).with(q1.join(" "), [1, "foo", "bar", "baz"]) {
+      [["foo", "foo1"], ["bar", "bar1"], ["baz", "baz1"]]
+    }
+    allow(cmd).to receive(:execute).with(q1.join(" "), [2, "foo", "bar", "baz"]) {
+      [["foo", "foo2"], ["bar", "bar2"], ["baz", "baz2"]]
+    }
+    allow(cmd).to receive(:execute).with(q1.join(" "), [3, "foo", "bar", "baz"]) {
+      [["foo", "foo3"], ["bar", "bar3"], ["baz", "baz3"]]
+    }
+    expect(cmd.__send__(:get_hosts_fields, [1, 2, 3], ["foo", "bar", "baz"])).to eq([[["foo1", "bar1", "baz1"], ["foo2", "bar2", "baz2"], ["foo3", "bar3", "baz3"]], ["foo", "bar", "baz"]])
+  end
+
+  it "get host fields with host" do
+    allow(cmd).to receive(:execute).with("SELECT id, name FROM hosts WHERE id IN (?, ?, ?)", [1, 2, 3]) {
+      [[1, "host1"], [2, "host2"], [3, "host3"]]
+    }
+    q1 = [
+      "SELECT tags.name, GROUP_CONCAT(tags.value, ',') FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE hosts_tags.host_id = ? AND tags.name IN (?, ?)",
+            "GROUP BY tags.name;",
+    ]
+    allow(cmd).to receive(:execute).with(q1.join(" "), [1, "foo", "bar"]) {
+      [["foo", "foo1"], ["bar", "bar1"]]
+    }
+    allow(cmd).to receive(:execute).with(q1.join(" "), [2, "foo", "bar"]) {
+      [["foo", "foo2"], ["bar", "bar2"]]
+    }
+    allow(cmd).to receive(:execute).with(q1.join(" "), [3, "foo", "bar"]) {
+      [["foo", "foo3"], ["bar", "bar3"]]
+    }
+    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/parser/parser_spec.rb

@@ -235,7 +235,7 @@ describe "parser" do
   end
 
   it "parses 'not foo and bar'" do
-    expect(cmd.parse("not foo and bar")).to eq({left: {unary_op: "not", expression: {identifier: "foo"}}, binary_op: "and", right: {identifier: "bar"}})
+    expect(cmd.parse("not foo and bar")).to eq({unary_op: "not", expression: {left: {identifier: "foo"}, binary_op: "and", right: {identifier: "bar"}}})
   end
 
   it "parses '! foo and bar'" do
@@ -243,7 +243,7 @@ describe "parser" do
   end
 
   it "parses 'not foo && bar'" do
-    expect(cmd.parse("not foo && bar")).to eq({left: {unary_op: "not", expression: {identifier: "foo"}}, binary_op: "&&", right: {identifier: "bar"}})
+    expect(cmd.parse("not foo && bar")).to eq({unary_op: "not", expression: {left: {identifier: "foo"}, binary_op: "&&", right: {identifier: "bar"}}})
   end
 
   it "parses '! foo && bar'" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Yamashita Yuu
@@ -145,6 +145,7 @@ files:
 - lib/hotdog/formatters/yaml.rb
 - lib/hotdog/version.rb
 - spec/core/application_spec.rb
+- spec/core/commands_spec.rb
 - spec/formatter/csv_spec.rb
 - spec/formatter/json_spec.rb
 - spec/formatter/ltsv_spec.rb
@@ -183,6 +184,7 @@ specification_version: 4
 summary: Yet another command-line tool for Datadog
 test_files:
 - spec/core/application_spec.rb
+- spec/core/commands_spec.rb
 - spec/formatter/csv_spec.rb
 - spec/formatter/json_spec.rb
 - spec/formatter/ltsv_spec.rb