hotdog 0.4.1 → 0.5.0

data/lib/hotdog/commands/ssh.rb

@@ -8,38 +8,45 @@ require "shellwords"
 module Hotdog
   module Commands
     class Ssh < Search
-      def run(args=[])
-        ssh_option = {
+      def define_options(optparse)
+        @ssh_options = @options.merge({
           index: nil,
           options: [],
           user: nil,
           port: nil,
           identity_file: nil,
           forward_agent: false,
-        }
+          verbose: false,
+        })
 
         optparse.on("-n", "--index INDEX", "Use this index of host if multiple servers are found", Integer) do |index|
-          ssh_option[:index] = index
+          @ssh_options[:index] = index
         end
         optparse.on("-o SSH_OPTION", "Passes this string to ssh command through shell. This option may be given multiple times") do |option|
-          ssh_option[:options] += [option]
+          @ssh_options[:options] += [option]
         end
         optparse.on("-i SSH_IDENTITY_FILE", "SSH identity file path") do |path|
-          ssh_option[:identity_file] = path
+          @ssh_options[:identity_file] = path
         end
         optparse.on("-A", "Enable agent forwarding", TrueClass) do |b|
-          ssh_option[:forward_agent] = b
+          @ssh_options[:forward_agent] = b
         end
         optparse.on("-p PORT", "Port of the remote host", Integer) do |port|
-          ssh_option[:port] = port
+          @ssh_options[:port] = port
         end
         optparse.on("-u SSH_USER", "SSH login user name") do |user|
-          ssh_option[:user] = user
+          @ssh_options[:user] = user
+        end
+        optparse.on("-v", "--verbose", "Enable verbose ode") do |v|
+          @ssh_options[:verbose] = v
         end
+      end
 
-        search_args = []
-        optparse.order!(args) {|search_arg| search_args.push(search_arg) }
-        expression = search_args.join(" ").strip
+      def parse_options(optparse, args=[])
+      end
+
+      def run(args=[])
+        expression = args.join(" ").strip
         if expression.empty?
           exit(1)
         end
@@ -59,8 +66,8 @@ module Hotdog
           STDERR.puts("no match found: #{search_args.join(" ")}")
           exit(1)
         else
-          if ssh_option[:index] && result.length > ssh_option[:index]
-            host = result[ssh_option[:index]]
+          if @ssh_options[:index] && result.length > @ssh_options[:index]
+            host = result[@ssh_options[:index]]
           else
             result, fields = get_hosts_with_search_tags(result, node)
 
@@ -79,26 +86,29 @@ module Hotdog
 
         # build ssh command
         cmdline = ["ssh"]
-        ssh_option[:options].each do |option|
+        @ssh_options[:options].each do |option|
           cmdline << "-o" << option
         end
-        if path = ssh_option[:identity_file]
+        if path = @ssh_options[:identity_file]
           cmdline << "-i" << Shellwords.escape(path)
         end
-        if port = ssh_option[:port]
+        if port = @ssh_options[:port]
           cmdline << "-p" << port.to_s
         end
-        if ssh_option[:forward_agent]
+        if @ssh_options[:forward_agent]
           cmdline << "-A"
         end
-        if user = ssh_option[:user]
+        if @ssh_options[:verbose]
+          cmdline << "-v"
+        end
+        if user = @ssh_options[:user]
           cmdline << (user + "@" + address)
         else
           cmdline << address
         end
         cmdline.concat(args)
 
-        exec *cmdline
+        exec(*cmdline)
         exit(127)
       end
     end

data/lib/hotdog/commands/tags.rb

@@ -4,7 +4,6 @@ module Hotdog
   module Commands
     class Tags < BaseCommand
       def run(args=[])
-        args = optparse.parse(args)
         if args.empty?
           result = execute("SELECT name, value FROM tags").map { |name, value| [join_tag(name, value)] }
           show_tags(result)

data/lib/hotdog/commands/up.rb

@@ -6,7 +6,6 @@ module Hotdog
   module Commands
     class Up < BaseCommand
       def run(args=[])
-        args = optparse.parse(args)
         scopes = args.map { |arg|
           if arg.index(":").nil?
             "host:#{arg}"

data/lib/hotdog/commands.rb

@@ -29,14 +29,15 @@ module Hotdog
         raise(NotImplementedError)
       end
 
-      def execute(query, args=[])
+      def execute(q, args=[])
         update_db
-        q = query.strip
-        if 0 < args.length
-          q += " -- VALUES (#{args.map { |arg| Array === arg ? "(#{arg.join(", ")})" : arg.inspect }.join(", ")})"
+        begin
+          logger.debug("execute: #{q} -- #{args.inspect}")
+          prepare(@db, q).execute(args)
+        rescue
+          logger.error("failed: #{q} -- #{args.inspect}")
+          raise
         end
-        logger.debug(q)
-        prepare(@db, query).execute(args)
       end
 
       def fixed_string?()
@@ -51,6 +52,14 @@ module Hotdog
         update_db(options)
       end
 
+      def define_options(optparse)
+        # nop
+      end
+
+      def parse_options(optparse, args=[])
+        optparse.parse(args)
+      end
+
       private
       def prepare(db, query)
         k = (db.hash & MASK_DATABASE) | (query.hash & MASK_QUERY)
@@ -61,10 +70,6 @@ module Hotdog
         @options[:formatter].format(result, @options.merge(options))
       end
 
-      def optparse()
-        @application.optparse
-      end
-
       def glob?(s)
         s.index('*') or s.index('?') or s.index('[') or s.index(']')
       end
@@ -166,7 +171,7 @@ module Hotdog
           FileUtils.mkdir_p(options[:confdir])
           persistent = File.join(options[:confdir], PERSISTENT_DB)
 
-          if not options[:force] and File.exist?(persistent) and Time.new < File.mtime(persistent) + options[:expiry]
+          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")
@@ -175,7 +180,11 @@ module Hotdog
               @db = persistent_db
               return
             rescue SQLite3::SQLException
-              persistent_db.close()
+              if options[:offline]
+                raise(RuntimeError.new("no database available on offline mode"))
+              else
+                persistent_db.close()
+              end
             end
           end
 
@@ -192,21 +201,38 @@ module Hotdog
           memory_db.transaction do
             known_tags = all_tags.keys.map { |tag| split_tag(tag) }.uniq
             known_tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2) do |known_tags|
-              prepare(memory_db, "INSERT OR IGNORE INTO tags (name, value) VALUES %s" % known_tags.map { "(?, ?)" }.join(", ")).execute(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
             end
 
             known_hosts = all_tags.values.reduce(:+).uniq
             known_hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT) do |known_hosts|
-              prepare(memory_db, "INSERT OR IGNORE INTO hosts (name) VALUES %s" % known_hosts.map { "(?)" }.join(", ")).execute(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
             end
 
             all_tags.each do |tag, hosts|
-              q = "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
-                    "SELECT host.id, tag.id FROM " \
-                      "( SELECT id FROM hosts WHERE name IN (%s) ) AS host, " \
-                      "( SELECT id FROM tags WHERE name = ? AND value = ? LIMIT 1 ) AS tag;"
               hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 2) do |hosts|
-                prepare(memory_db, q % hosts.map { "?" }.join(", ")).execute(hosts + split_tag(tag))
+                q = "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
+                      "SELECT host.id, tag.id FROM " \
+                        "( 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
+                end
               end
             end
           end
@@ -269,17 +295,35 @@ module Hotdog
 
           hosts = prepare(src, "SELECT id, name FROM hosts").execute().to_a
           hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2) do |hosts|
-            prepare(dst, "INSERT INTO hosts (id, name) VALUES %s" % hosts.map { "(?, ?)" }.join(", ")).execute(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|
-            prepare(dst, "INSERT INTO tags (id, name, value) VALUES %s" % tags.map { "(?, ?, ?)" }.join(", ")).execute(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|
-            prepare(dst, "INSERT INTO hosts_tags (host_id, tag_id) VALUES %s" % hosts_tags.map { "(?, ?)" }.join(", ")).execute(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)

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/spec/parser/parser_spec.rb

@@ -23,7 +23,7 @@ describe "parser" do
   end
 
   it "parses ':/foo/'" do
-    expect(cmd.parse(":/foo/")).to eq({separator: ":", attribute_regexp: "/foo/"})
+    expect(cmd.parse(":/foo/")).to eq({separator: ":", attribute_regexp: "foo"})
   end
 
   it "parses 'foo'" do
@@ -63,11 +63,11 @@ describe "parser" do
   end
 
   it "parses '/foo/'" do
-    expect(cmd.parse("/foo/")).to eq({identifier_regexp: "/foo/"})
+    expect(cmd.parse("/foo/")).to eq({identifier_regexp: "foo"})
   end
 
   it "parses '/foo/:/bar/'" do
-    expect(cmd.parse("/foo/:/bar/")).to eq({identifier_regexp: "/foo/", separator: ":", attribute_regexp: "/bar/"})
+    expect(cmd.parse("/foo/:/bar/")).to eq({identifier_regexp: "foo", separator: ":", attribute_regexp: "bar"})
   end
 
   it "parses '(foo)'" do

data/spec/parser/tag_expression_spec.rb

@@ -10,7 +10,7 @@ describe "tag expression" do
   }
 
   it "interprets tag with host" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new("host", "foo", ":")
+    expr = Hotdog::Commands::Search::StringHostNode.new("foo", ":")
     q = [
       "SELECT hosts.id AS host_id FROM hosts",
         "WHERE hosts.name = ?;",
@@ -23,7 +23,7 @@ describe "tag expression" do
   end
 
   it "interprets tag with identifier and attribute" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new("foo", "bar", ":")
+    expr = Hotdog::Commands::Search::StringTagNode.new("foo", "bar", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -37,7 +37,7 @@ describe "tag expression" do
   end
 
   it "interprets tag with identifier with separator" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new("foo", nil, ":")
+    expr = Hotdog::Commands::Search::StringTagNameNode.new("foo", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -51,7 +51,7 @@ describe "tag expression" do
   end
 
   it "interprets tag with identifier without separator" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new("foo", nil, nil)
+    expr = Hotdog::Commands::Search::StringNode.new("foo", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -66,7 +66,7 @@ describe "tag expression" do
   end
 
   it "interprets tag with attribute with separator" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new(nil, "foo", ":")
+    expr = Hotdog::Commands::Search::StringTagValueNode.new("foo", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -80,7 +80,7 @@ describe "tag expression" do
   end
 
   it "interprets tag with attribute without separator" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new(nil, "foo", nil)
+    expr = Hotdog::Commands::Search::StringTagValueNode.new("foo", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -94,8 +94,10 @@ describe "tag expression" do
   end
 
   it "empty tag" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new(nil, nil, nil)
-    expect(expr.evaluate(cmd)).to eq([])
+    expr = Hotdog::Commands::Search::StringExpressionNode.new(nil, nil, nil)
+    expect {
+      expr.evaluate(cmd)
+    }.to raise_error(NotImplementedError)
     expect(expr.dump).to eq({})
   end
 end

data/spec/parser/tag_glob_expression_spec.rb

@@ -10,7 +10,7 @@ describe "tag glob expression" do
   }
 
   it "interprets tag glob with host" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("host", "foo*", ":")
+    expr = Hotdog::Commands::Search::GlobHostNode.new("foo*", ":")
     q = [
       "SELECT hosts.id AS host_id FROM hosts",
         "WHERE LOWER(hosts.name) GLOB LOWER(?);",
@@ -23,7 +23,7 @@ describe "tag glob expression" do
   end
 
   it "interprets tag glob with identifier and attribute" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("foo*", "bar*", ":")
+    expr = Hotdog::Commands::Search::GlobTagNode.new("foo*", "bar*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -37,7 +37,7 @@ describe "tag glob expression" do
   end
 
   it "interprets tag glob with identifier with separator" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("foo*", nil, ":")
+    expr = Hotdog::Commands::Search::GlobTagNameNode.new("foo*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -51,7 +51,7 @@ describe "tag glob expression" do
   end
 
   it "interprets tag glob with identifier without separator" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("foo*", nil, nil)
+    expr = Hotdog::Commands::Search::GlobNode.new("foo*", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -66,7 +66,7 @@ describe "tag glob expression" do
   end
 
   it "interprets tag glob with attribute with separator" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new(nil, "foo*", ":")
+    expr = Hotdog::Commands::Search::GlobTagValueNode.new("foo*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -80,7 +80,7 @@ describe "tag glob expression" do
   end
 
   it "interprets tag glob with attribute without separator" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new(nil, "foo*", nil)
+    expr = Hotdog::Commands::Search::GlobTagValueNode.new("foo*", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -94,8 +94,10 @@ describe "tag glob expression" do
   end
 
   it "empty tag glob" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new(nil, nil, nil)
-    expect(expr.evaluate(cmd)).to eq([])
+    expr = Hotdog::Commands::Search::GlobExpressionNode.new(nil, nil, nil)
+    expect {
+      expr.evaluate(cmd)
+    }.to raise_error(NotImplementedError)
     expect(expr.dump).to eq({})
   end
 end

data/spec/parser/tag_regexp_expression_spec.rb

@@ -10,7 +10,7 @@ describe "tag regexp expression" do
   }
 
   it "interprets tag regexp with host" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("host", "/foo/", ":")
+    expr = Hotdog::Commands::Search::RegexpHostNode.new("foo", ":")
     q = [
       "SELECT hosts.id AS host_id FROM hosts",
         "WHERE hosts.name REGEXP ?;",
@@ -23,7 +23,7 @@ describe "tag regexp expression" do
   end
 
   it "interprets tag regexp with identifier and attribute" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("/foo/", "/bar/", ":")
+    expr = Hotdog::Commands::Search::RegexpTagNode.new("foo", "bar", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -37,7 +37,7 @@ describe "tag regexp expression" do
   end
 
   it "interprets tag regexp with identifier with separator" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("/foo/", nil, ":")
+    expr = Hotdog::Commands::Search::RegexpTagNameNode.new("foo", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -51,7 +51,7 @@ describe "tag regexp expression" do
   end
 
   it "interprets tag regexp with identifier without separator" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("/foo/", nil, nil)
+    expr = Hotdog::Commands::Search::RegexpNode.new("foo", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -66,7 +66,7 @@ describe "tag regexp expression" do
   end
 
   it "interprets tag regexp with attribute with separator" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new(nil, "/foo/", ":")
+    expr = Hotdog::Commands::Search::RegexpTagValueNode.new("foo", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -80,7 +80,7 @@ describe "tag regexp expression" do
   end
 
   it "interprets tag regexp with attribute without separator" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new(nil, "/foo/", nil)
+    expr = Hotdog::Commands::Search::RegexpTagValueNode.new("foo", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -94,8 +94,10 @@ describe "tag regexp expression" do
   end
 
   it "empty tag regexp" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new(nil, nil, nil)
-    expect(expr.evaluate(cmd)).to eq([])
+    expr = Hotdog::Commands::Search::RegexpExpressionNode.new(nil, nil, nil)
+    expect {
+      expr.evaluate(cmd)
+    }.to raise_error(NotImplementedError)
     expect(expr.dump).to eq({})
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Yamashita Yuu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-18 00:00:00.000000000 Z
+date: 2015-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -197,3 +197,4 @@ test_files:
 - spec/parser/tag_glob_expression_spec.rb
 - spec/parser/tag_regexp_expression_spec.rb
 - spec/spec_helper.rb
+has_rdoc: