hotdog 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d1a630c98690e6d1df7a32b7baf48e24776da49a
-  data.tar.gz: ab4daa9a831412d598eb235e3e4ed8a4516b2dcf
+  metadata.gz: c02920ad489cbbbf48668151aa47add9a237cc07
+  data.tar.gz: 135a3312a19650537706eac8d00e7ec27fe503bc
 SHA512:
-  metadata.gz: cb2c5b244339014184b56d4c1ab68bce58bc8fa2f71e84eef15319a8157be1532304647760fcd0b41d200cd8e1fdb895e6ca6a8309c7cd79d3ce9f6e67379c6f
-  data.tar.gz: 00ea3e8ddc439588571c788a0ec4f2546fb084d81ef18749b92cb83ab239ce2ea6df3f7c1ad21f17ca9f487794c805a1c5eb1fd007857d81dc58b3f9be9e3746
+  metadata.gz: ad15864f8d0cb38904e9e377c8c416aa28432ab032d8c109161bffa578e165bb572165658f260a10f6eb50dee59ed950f5b647aec165767eace829c03f80d0f9
+  data.tar.gz: 0b452f257046f22a261deada1cba9e53e6e7aec8ef60dcbdc43991c4dabcf567a38888a72215d7d50a5cd1d7dd838f45723f017a978991b75f8e7add94f99668

data/README.md

@@ -42,12 +42,6 @@ EOF
 
 ## Usage
 
-Initialize host information. This may take several minutes.
-
-```sh
-$ hotdog update
-```
-
 List all registered hosts.
 
 ```sh

data/lib/hotdog/application.rb

@@ -2,8 +2,6 @@
 
 require "logger"
 require "optparse"
-require "shellwords"
-require "sqlite3"
 require "yaml"
 require "hotdog/commands"
 require "hotdog/formatters"
@@ -11,34 +9,34 @@ require "hotdog/formatters"
 module Hotdog
   class Application
     def initialize()
-      @confdir = find_confdir(File.expand_path("."))
       @optparse = OptionParser.new
       @options = {
+        api_key: ENV["DATADOG_API_KEY"],
+        application_key: ENV["DATADOG_APPLICATION_KEY"],
+        application: self,
+        confdir: find_confdir(File.expand_path(".")),
         debug: false,
-        environment: "default",
-        minimum_expiry: 3600, # 1 hour
-        random_expiry: 5940, # 99 hours
+        expiry: 180,
         fixed_string: false,
         force: false,
         format: "plain",
         headers: false,
         listing: false,
-        logger: Logger.new(STDERR),
+        logger: Logger.new(STDERR).tap { |logger|
+          logger.level = Logger::INFO
+        },
         max_time: 5,
-        api_key: ENV["DATADOG_API_KEY"],
-        application_key: ENV["DATADOG_APPLICATION_KEY"],
         print0: false,
         print1: true,
         tags: [],
         verbose: false,
       }
-      @options[:logger].level = Logger::INFO
       define_options
     end
     attr_reader :options
 
     def main(argv=[])
-      config = File.join(@confdir, "config.yml")
+      config = File.join(options[:confdir], "config.yml")
       if File.file?(config)
         loaded = YAML.load(File.read(config))
         if Hash === loaded
@@ -63,28 +61,16 @@ module Hotdog
         options[:logger].level = Logger::INFO
       end
 
-      sqlite = File.expand_path(File.join(@confdir, "#{options[:environment]}.db"))
-      FileUtils.mkdir_p(File.dirname(sqlite))
-      @db = SQLite3::Database.new(sqlite)
-      @db.synchronous = "off"
-
       begin
         command = ( args.shift || "help" )
-        c = run_command(command, args)
-        if c.suspended?
-          exit(2)
+        get_command(command).new(@options.dup).tap do |cmd|
+          cmd.run(args)
         end
       rescue Errno::EPIPE
         # nop
       end
     end
 
-    def run_command(command, args=[])
-      get_command(command).new(@db, options.merge(application: self)).tap do |c|
-        c.run(args)
-      end
-    end
-
     private
     def define_options
       @optparse.on("--api-key API_KEY", "Datadog API key") do |api_key|
@@ -99,15 +85,9 @@ module Hotdog
       @optparse.on("-1", "Use newline as separator") do |v|
         options[:print1] = v
       end
-      @optparse.on("-B", "--blocking", "Enable blocking mode") do
-        options[:max_time] = -1
-      end
       @optparse.on("-d", "--[no-]debug", "Enable debug mode") do |v|
         options[:debug] = v
       end
-      @optparse.on("-E ENVIRONMENT", "--environment ENVIRONMENT", "Specify environment") do |environment|
-        options[:environment] = environment
-      end
       @optparse.on("--fixed-string", "Interpret pattern as fixed string") do |v|
         options[:fixed_string] = v
       end
@@ -126,9 +106,6 @@ module Hotdog
       @optparse.on("-a TAG", "-t TAG", "--tag TAG", "Use specified tag name/value") do |tag|
         options[:tags] += [tag]
       end
-      @optparse.on("-m SECONDS", "--max-time SECONDS", Integer, "Maximum time in seconds") do |seconds|
-        options[:max_time] = seconds
-      end
       @optparse.on("-V", "--[no-]verbose", "Enable verbose mode") do |v|
         options[:verbose] = v
       end

data/lib/hotdog/commands.rb

@@ -1,25 +1,32 @@
 #!/usr/bin/env ruby
 
+require "fileutils"
 require "dogapi"
-require "logger"
+require "json"
+require "sqlite3"
 
 module Hotdog
   module Commands
     class BaseCommand
-      def initialize(db, options={})
-        @db = db
+      def initialize(options={})
+        @application = options[:application]
+        @confdir = options[:confdir]
+        @expiry = options[:expiry]
         @fixed_string = options[:fixed_string]
+        @force = options[:force]
         @formatter = options[:formatter]
+        @listing = options[:listing]
         @logger = options[:logger]
         @tags = options[:tags]
-        @application = options[:application]
         @options = options
         @dog = Dogapi::Client.new(options[:api_key], options[:application_key])
-        @started_at = Time.new
-        @suspended = false
       end
       attr_reader :application
+      attr_reader :confdir
+      attr_reader :expiry
+      attr_reader :force
       attr_reader :formatter
+      attr_reader :listing
       attr_reader :logger
       attr_reader :tags
       attr_reader :options
@@ -29,6 +36,7 @@ module Hotdog
       end
 
       def execute(query, *args)
+        update_db
         q = query.strip
         if 0 < args.length
           q += " -- VALUES (#{args.map { |arg| Array === arg ? "(#{arg.join(", ")})" : arg.inspect }.join(", ")})"
@@ -41,10 +49,6 @@ module Hotdog
         @fixed_string
       end
 
-      def suspended?()
-        @suspended
-      end
-
       private
       def format(result, options={})
         @formatter.format(result, @options.merge(options))
@@ -55,285 +59,248 @@ module Hotdog
       end
 
       def get_hosts(hosts=[])
+        update_db
         if 0 < tags.length
           result = hosts.map { |host_id|
-            update_host_tags(host_id, @options.merge(tags: tags))
             tags.map { |tag|
               tag_name, tag_value = tag.split(":", 2)
               case tag_name
-              when "expires_at"
-                @get_hosts_q6 ||= @db.prepare(<<-EOS)
-                  SELECT expires_at FROM hosts_tags WHERE host_id = ? LIMIT 1;
-                EOS
-                logger.debug("get_hosts_q6(%s)" % [host_id.inspect])
-                @get_hosts_q6.execute(host_id).map { |row| Time.at(row.first).strftime("%Y-%m-%dT%H:%M:%S") }.first
               when "host"
-                @get_hosts_q1 ||= @db.prepare(<<-EOS)
-                  SELECT name FROM hosts WHERE id = ? LIMIT 1;
-                EOS
-                logger.debug("get_hosts_q1(%s)" % [host_id.inspect])
-                @get_hosts_q1.execute(host_id).map { |row| row.first }.first
+                select_name_from_hosts_by_id(@db, host_id)
               else
-                if not glob?(tag_name)
-                  @get_hosts_q2 ||= @db.prepare(<<-EOS)
-                    SELECT tags.value FROM hosts_tags
-                      INNER JOIN tags ON hosts_tags.tag_id = tags.id
-                        WHERE hosts_tags.host_id = ? AND tags.name = ?;
-                  EOS
-                  logger.debug("get_hosts_q2(%s, %s)" % [host_id.inspect, tag_name.inspect])
-                  @get_hosts_q2.execute(host_id, tag_name).map { |row| row.first }.join(",")
+                if glob?(tag_name)
+                  select_tag_values_from_hosts_tags_by_host_id_and_tag_name_glob(@db, host_id, tag_name)
                 else
-                  @get_hosts_q5 ||= @db.prepare(<<-EOS)
-                    SELECT tags.value FROM hosts_tags
-                      INNER JOIN tags ON hosts_tags.tag_id = tags.id
-                        WHERE hosts_tags.host_id = ? AND tags.name GLOB ?;
-                  EOS
-                  logger.debug("get_hosts_q5(%s, %s)", host_id.inspect, tag_name.inspect)
-                  @get_hosts_q5.execute(host_id, tag_name).map { |row| row.first }.join(",")
+                  select_tag_values_from_hosts_tags_by_host_id_and_tag_name(@db, host_id, tag_name)
                 end
               end
             }
           }
           fields = tags
         else
-          if options[:listing]
-
+          if @listing
             fields = []
-            hosts = execute(<<-EOS % hosts.map { "?" }.join(", "), hosts)
-              SELECT id, name FROM hosts WHERE id IN (%s) ORDER BY name;
-            EOS
+            hosts = execute("SELECT id, name FROM hosts WHERE id IN (%s)" % hosts.map { "?" }.join(", "), hosts)
             result = hosts.map { |host_id, host_name|
-              update_host_tags(host_name, @options.dup)
-              @get_hosts_q3 ||= @db.prepare(<<-EOS)
-                SELECT DISTINCT tags.name FROM hosts_tags
-                  INNER JOIN tags ON hosts_tags.tag_id = tags.id
-                    WHERE hosts_tags.host_id = ?;
-              EOS
-              logger.debug("get_hosts_q3(%s)" % [host_id.inspect])
-              tag_names = @get_hosts_q3.execute(host_id).map { |row| row.first }
+              tag_names = select_tag_names_from_hosts_tags_by_host_id(@db, host_id)
               tag_names.each do |tag_name|
                 fields << tag_name unless fields.index(tag_name)
               end
               [host_name] + fields.map { |tag_name|
-                @get_hosts_q4 ||= @db.prepare(<<-EOS)
-                  SELECT tags.value FROM hosts_tags
-                    INNER JOIN tags ON hosts_tags.tag_id = tags.id
-                      WHERE hosts_tags.host_id = ? AND tags.name = ?;
-                EOS
-                logger.debug("get_hosts_q4(%s, %s)" % [host_id.inspect, tag_name.inspect])
-                @get_hosts_q4.execute(host_id, tag_name).map { |row| row.first }.join(",")
+                select_tag_values_from_hosts_tags_by_host_id_and_tag_name(@db, host_id, tag_name)
               }
             }
             fields = ["host"] + fields
           else
             fields = ["host"]
-            result = execute(<<-EOS % hosts.map { "?" }.join(", "), hosts)
-              SELECT name FROM hosts WHERE id IN (%s) ORDER BY name; 
-            EOS
+            result = execute("SELECT name FROM hosts WHERE id IN (%s)" % hosts.map { "?" }.join(", "), hosts)
           end
         end
         [result, fields]
       end
 
-      def update_hosts(options={})
-        if suspended?
-          return
-        else
-          if not options[:force]
-            # Update host list on every expirations to update frequently.
-            @update_hosts_q1 ||= @db.prepare("SELECT MIN(expires_at) FROM hosts_tags;")
-            logger.debug("update_hosts_q1()")
-            if expires_at = @update_hosts_q1.execute().map { |row| row.first }.first
-              if Time.new.to_i < expires_at
-                logger.debug("next update will run after %s." % [Time.at(expires_at)])
-                return
-              else
-                logger.debug("minimum expires_at was %s. start updateing." % [Time.at(expires_at)])
-              end
-            else
-              logger.debug("expires_at not found. start updateing.")
+      def update_db(options={})
+        if @db.nil?
+          FileUtils.mkdir_p(confdir)
+          persistent = File.join(confdir, "persistent.db")
+
+          if not @force and File.exist?(persistent) and Time.new < File.mtime(persistent) + expiry
+            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")
+              @db = persistent_db
+              return
+            rescue SQLite3::SQLException
+              persistent_db.close()
             end
           end
 
-          code, result = @dog.search("hosts:")
-          logger.debug("dog.serarch(%s) #==> [%s, %s]" % ["hosts:".inspect, code.inspect, result.inspect])
+          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)
+
+          code, result = @dog.all_tags()
+          logger.debug("dog.all_tags() #==> [%s, ...]" % [code.inspect])
           if code.to_i / 100 != 2
-            raise("dog.search(%s) returns (%s: %s)" % ["hosts:".inspect, code.inspect, result.inspect])
+            raise("dog.all_tags() returns (%s: ...)" % [code.inspect])
           end
 
-          resume_host_tags
-          execute(<<-EOS % result["results"]["hosts"].map { "LOWER(?)" }.join(", "), result["results"]["hosts"])
-            DELETE FROM hosts_tags WHERE host_id NOT IN
-              ( SELECT id FROM hosts WHERE LOWER(name) IN ( %s ) );
-          EOS
-
-          result["results"]["hosts"].each_with_index do |host_name, i|
-            @update_hosts_q2 ||= @db.prepare("INSERT OR IGNORE INTO hosts (name) VALUES (?);")
-            logger.debug("update_hosts_q2(%s)" % [host_name.inspect])
-            @update_hosts_q2.execute(host_name)
-            update_host_tags(host_name, options)
-
-            elapsed_time = Time.new - @started_at
-            if 0 < options[:max_time] and options[:max_time] < elapsed_time
-              length = result["results"]["hosts"].length
-              logger.info("update_host_tags: exceeded maximum time (#{options[:max_time]} < #{elapsed_time}) after #{i+1}/#{length}. will resume on next run.")
-              suspend_host_tags
-              break
+          result["tags"].each do |tag, hosts|
+            tag_name, tag_value = tag.split(":", 2)
+            tag_value ||= ""
+            insert_or_ignore_into_tags(memory_db, tag_name, tag_value)
+            hosts.each do |host_name|
+              insert_or_ignore_into_hosts(memory_db, host_name)
+              insert_or_replace_into_hosts_tags(memory_db, host_name, tag_name, tag_value)
             end
           end
+
+          # backup in-memory db to file
+          FileUtils.rm_f(persistent)
+          persistent_db = SQLite3::Database.new(persistent)
+          copy_db(memory_db, persistent_db)
+          persistent_db.close
+          @db = memory_db
+        else
+          @db
         end
       end
 
-      def update_tags(options={})
-        if suspended?
-          return
-        else
-          resume_host_tags
-
-          if options[:force]
-            @update_tags_q1 ||= @db.prepare(<<-EOS)
-              SELECT DISTINCT hosts_tags.host_id FROM hosts_tags;
-            EOS
-            logger.debug("update_tags_q1()")
-            hosts = @update_tags_q1.execute().map { |row| row.first }
-          else
-            @update_tags_q2 ||= @db.prepare(<<-EOS)
-              SELECT DISTINCT hosts_tags.host_id FROM hosts_tags
-                WHERE hosts_tags.expires_at < ?;
-            EOS
-            logger.debug("update_tags_q2(%s)" % [Time.new.to_i])
-            hosts = @update_tags_q2.execute(Time.new.to_i).map { |row| row.first }
+      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)
+
+          select_from_hosts(src).each do |host_id, host_name|
+            insert_into_hosts(dst, host_id, host_name)
           end
-          hosts.each_with_index do |host_id, i|
-            @update_tags_q3 ||= @db.prepare("DELETE FROM hosts_tags WHERE host_id = ? AND hosts_tags.expires_at < ?;")
-            logger.debug("update_tags_q3(%s, %s)" % [host_id.inspect, Time.new.to_i])
-            @update_tags_q3.execute(host_id, Time.new.to_i)
-
-            update_host_tags(host_id, options)
-
-            elapsed_time = Time.new - @started_at
-            if 0 < options[:max_time] and options[:max_time] < elapsed_time
-              length = hosts.length
-              logger.info("update_host_tags: exceeded maximum time (#{options[:max_time]} < #{elapsed_time}) after #{i+1}/#{length}. will resume on next run.")
-              suspend_host_tags
-              break
-            end
+          select_from_tags(src).each do |tag_id, tag_name, tag_value|
+            insert_into_tags(dst, tag_id, tag_name, tag_value)
+          end
+          select_from_hosts_tags(src).each do |host_id, tag_id|
+            insert_into_hosts_tags(dst, host_id, tag_id)
           end
+
+          create_index_hosts(dst)
+          create_index_tags(dst)
+          create_index_hosts_tags(dst)
         end
       end
 
-      # it'd be better to filter out this host/tag entry on displaying...
-      EMPTY_HOST_NAME = ""
-      EMPTY_TAG_NAME = ""
-      EMPTY_TAG_VALUE = ""
-      EMPTY_EXPIRES_AT = Time.at(0).to_i
-
-      def suspend_host_tags()
-        @db.transaction do
-          @suspended = true
-          @suspend_host_tags_q1 ||= @db.prepare("INSERT OR IGNORE INTO hosts (name) VALUES (?);")
-          logger.debug("suspend_host_tags_q1(%s)" % [EMPTY_HOST_NAME.inspect])
-          @suspend_host_tags_q1.execute(EMPTY_HOST_NAME)
-          @suspend_host_tags_q2 ||= @db.prepare("INSERT OR IGNORE INTO tags (name, value) VALUES (?, ?);")
-          logger.debug("suspend_host_tags_q2(%s, %s)" % [EMPTY_TAG_NAME.inspect, EMPTY_TAG_VALUE.inspect])
-          @suspend_host_tags_q2.execute(EMPTY_TAG_NAME, EMPTY_TAG_VALUE)
-          @suspend_host_tags_q3 ||= @db.prepare(<<-EOS)
-            INSERT OR REPLACE INTO hosts_tags (host_id, tag_id, expires_at)
-              SELECT host.id, tag.id, ? FROM
-                ( SELECT id FROM hosts WHERE name = ?) AS host,
-                ( SELECT id FROM tags WHERE name = ? AND value = ? ) AS tag;
-          EOS
-          logger.debug("suspend_host_tags_q3(%s, %s, %s, %s)" % [EMPTY_EXPIRES_AT.inspect, EMPTY_HOST_NAME.inspect, EMPTY_TAG_NAME.inspect, EMPTY_TAG_VALUE.inspect])
-          @suspend_host_tags_q3.execute(EMPTY_EXPIRES_AT, EMPTY_HOST_NAME, EMPTY_TAG_NAME, EMPTY_TAG_VALUE)
-        end
+      def select_from_hosts(db)
+        logger.debug("select_from_hosts()")
+        db.execute("SELECT id, name FROM hosts")
       end
 
-      def resume_host_tags()
-        @resume_host_tags_q1 ||= @db.prepare(<<-EOS)
-          DELETE FROM hosts_tags
-            WHERE host_id IN ( SELECT id FROM hosts WHERE name = ? ) AND tag_id IN ( SELECT id FROM tags WHERE name = ? AND value = ? );
+      def select_from_tags(db)
+        logger.debug("select_from_tags()")
+        db.execute("SELECT id, name, value FROM tags")
+      end
+
+      def select_from_hosts_tags(db)
+        logger.debug("select_from_hosts_tags()")
+        db.execute("SELECT host_id, tag_id FROM hosts_tags")
+      end
+
+      def create_table_hosts(db)
+        logger.debug("create_table_hosts()")
+        db.execute(<<-EOS)
+          CREATE TABLE IF NOT EXISTS hosts (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name VARCHAR(255) NOT NULL
+          );
         EOS
-        logger.debug("resume_host_tags_q1(%s, %s, %s)" % [EMPTY_HOST_NAME.inspect, EMPTY_TAG_NAME.inspect, EMPTY_TAG_VALUE.inspect])
-        @resume_host_tags_q1.execute(EMPTY_HOST_NAME, EMPTY_TAG_NAME, EMPTY_TAG_VALUE)
       end
 
-      def update_host_tags(host_name, options={})
-        if suspended?
-          # stop updating if the `update_host_tags` has already been suspended
-          return
-        else
-          if Integer === host_name
-            host_id = host_name
-            @update_host_tags_q1 ||= @db.prepare("SELECT name FROM hosts WHERE id = ? LIMIT 1;")
-            logger.debug("update_host_tags_q1(%s)" % [host_id.inspect])
-            host_name = @update_host_tags_q1.execute(host_id).map { |row| row.first }.first
-          else
-            @update_host_tags_q2 ||= @db.prepare("SELECT id, name FROM hosts WHERE LOWER(name) = LOWER(?) LIMIT 1;")
-            logger.debug("update_host_tags_q2(%s)" % [host_name.inspect])
-            host_id, host_name = @update_host_tags_q2.execute(host_name).map { |row| row }.first
-          end
+      def create_index_hosts(db)
+        logger.debug("create_index_hosts()")
+        db.execute("CREATE UNIQUE INDEX IF NOT EXISTS hosts_name ON hosts ( name )")
+      end
 
-          if not options[:force]
-            # Update host tags less frequently.
-            # Don't need to run updates on every expiration.
-            @update_host_tags_q3 ||= @db.prepare("SELECT AVG(expires_at) FROM hosts_tags WHERE host_id = ?;")
-            logger.debug("update_host_tags_q3(%s)" % [host_id.inspect])
-            if expires_at = @update_host_tags_q3.execute(host_id).map { |row| row.first }.first
-              if Time.new.to_i < expires_at
-                logger.debug("%s: next update will run after %s." % [host_name, Time.at(expires_at)])
-                return
-              else
-                logger.debug("%s: average expires_at was %s. start updating." % [host_name, Time.at(expires_at)])
-              end
-            else
-              logger.debug("%s: expires_at not found. start updateing." % [host_name])
-            end
-          end
+      def create_table_tags(db)
+        logger.debug("create_table_tags()")
+        db.execute(<<-EOS)
+          CREATE TABLE IF NOT EXISTS tags (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name VARCHAR(200) NOT NULL,
+            value VARCHAR(200) NOT NULL DEFAULT ""
+          );
+        EOS
+      end
 
-          code, result = @dog.host_tags(host_name)
-          logger.debug("dog.host_tags(%s) #==> [%s, %s]" % [host_name.inspect, code.inspect, result.inspect])
-          if code.to_i / 100 != 2
-            case code.to_i
-            when 404 # host not found on datadog
-              @update_host_tags_q7 ||= @db.prepare("DELETE FROM hosts_tags WHERE host_id IN ( SELECT id FROM hosts WHERE LOWER(name) = LOWER(?) );")
-              logger.debug("update_host_tags_q7(%s)" % [host_name.inspect])
-              @update_host_tags_q7.execute(host_name)
-            end
-            raise("dog.host_tags(%s) returns (%s: %s)" % [host_name.inspect, code.inspect, result.inspect])
-          end
+      def create_index_tags(db)
+        logger.debug("create_index_tags()")
+        db.execute("CREATE UNIQUE INDEX IF NOT EXISTS tags_name_value ON tags ( name, value )")
+      end
 
-          expires_at = Time.new.to_i + (options[:minimum_expiry] + rand(options[:random_expiry]))
-          logger.debug("%s: expires_at=%s" % [host_name, Time.at(expires_at)])
+      def create_table_hosts_tags(db)
+        logger.debug("create_table_hosts_tags()")
+        db.execute(<<-EOS)
+          CREATE TABLE IF NOT EXISTS hosts_tags (
+            host_id INTEGER NOT NULL,
+            tag_id INTEGER NOT NULL
+          );
+        EOS
+      end
 
-          @db.transaction do
-            result["tags"].each do |tag|
-              tag_name, tag_value = tag.split(":", 2)
-              tag_value ||= ""
+      def create_index_hosts_tags(db)
+        logger.debug("create_index_hosts_tags()")
+        db.execute("CREATE UNIQUE INDEX IF NOT EXISTS hosts_tags_host_id_tag_id ON hosts_tags ( host_id, tag_id )")
+      end
 
-              if options.has_key?(:tags) and not options[:tags].empty? and not options[:tags].index(tag_name)
-                next
-              else
-                @update_host_tags_q4 ||= @db.prepare("INSERT OR IGNORE INTO tags (name, value) VALUES (?, ?);")
-                logger.debug("update_host_tags_q4(%s, %s)" % [tag_name.inspect, tag_value.inspect])
-                @update_host_tags_q4.execute(tag_name, tag_value)
-                @update_host_tags_q5 ||= @db.prepare(<<-EOS)
-                  INSERT OR REPLACE INTO hosts_tags (host_id, tag_id, expires_at)
-                    SELECT host.id, tag.id, ? FROM
-                      ( SELECT id FROM hosts WHERE name = ? ) AS host,
-                      ( SELECT id FROM tags WHERE name = ? AND value = ? ) AS tag;
-                EOS
-                logger.debug("update_host_tags_q5(%s, %s)" % [expires_at, host_name, tag_name, tag_value])
-                @update_host_tags_q5.execute(expires_at, host_name, tag_name, tag_value)
-              end
-            end
+      def insert_into_tags(db, tag_id, tag_name, tag_value)
+        logger.debug("insert_into_tags(%s, %s, %s)" % [tag_id.inspect, tag_name.inspect, tag_value.inspect])
+        db.execute("INSERT INTO tags (id, name, value) VALUES (?, ?, ?)", tag_id, tag_name, tag_value)
+      end
 
-            @update_host_tags_q6 ||= @db.prepare(<<-EOS)
-              DELETE FROM hosts_tags WHERE host_id = ? and expires_at <= ?;
-            EOS
-            logger.debug("update_host_tags_q6(%s, %s)" % [host_id.inspect, Time.new.to_i.inspect])
-            @update_host_tags_q6.execute(host_id, Time.new.to_i)
-          end
-        end
+      def insert_or_ignore_into_tags(db, tag_name, tag_value)
+        logger.debug("insert_or_ignore_into_tags(%s, %s)" % [tag_name.inspect, tag_value.inspect])
+        db.execute("INSERT OR IGNORE INTO tags (name, value) VALUES (?, ?)", tag_name, tag_value)
+      end
+
+      def insert_into_hosts(db, host_id, host_name)
+        logger.debug("insert_into_hosts(%s, %s)" % [host_id.inspect, host_name.inspect])
+        db.execute("INSERT INTO hosts (id, name) VALUES (?, ?)", host_id, host_name)
+      end
+
+      def insert_or_ignore_into_hosts(db, host_name)
+        logger.debug("insert_or_ignore_into_hosts(%s)" % [host_name.inspect])
+        db.execute("INSERT OR IGNORE INTO hosts (name) VALUES (?)", host_name)
+      end
+
+      def insert_into_hosts_tags(db, host_id, tag_id)
+        logger.debug("insert_into_hosts_tags(%s, %s)" % [host_id.inspect, tag_id.inspect])
+        db.execute("INSERT INTO hosts_tags (host_id, tag_id) VALUES (?, ?)", host_id, tag_id)
+      end
+
+      def insert_or_replace_into_hosts_tags(db, host_name, tag_name, tag_value)
+        logger.debug("insert_or_replace_into_hosts_tags(%s, %s, %s)" % [host_name.inspect, tag_name.inspect, tag_value.inspect])
+        db.execute(<<-EOS, host_name, tag_name, tag_value)
+          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 = ? ) AS tag;
+        EOS
+      end
+
+      def select_name_from_hosts_by_id(db, host_id)
+        logger.debug("select_name_from_hosts_by_id(%s)" % [host_id.inspect])
+        db.execute("SELECT name FROM hosts WHERE id = ? LIMIT 1", host_id).map { |row| row.first }.first
+      end
+
+      def select_tag_values_from_hosts_tags_by_host_id_and_tag_name_glob(db, host_id, tag_name)
+        logger.debug("select_tag_values_from_hosts_tags_by_host_id_and_tag_name_glob(%s, %s)", host_id.inspect, tag_name.inspect)
+        db.execute(<<-EOS, host_id, tag_name).map { |row| row.first }.join(",")
+          SELECT tags.value FROM hosts_tags
+            INNER JOIN tags ON hosts_tags.tag_id = tags.id
+              WHERE hosts_tags.host_id = ? AND tags.name GLOB ?;
+        EOS
+      end
+
+      def select_tag_values_from_hosts_tags_by_host_id_and_tag_name(db, host_id, tag_name)
+        logger.debug("select_tag_values_from_hosts_tags_by_host_id_and_tag_name(%s, %s)" % [host_id.inspect, tag_name.inspect])
+        db.execute(<<-EOS, host_id, tag_name).map { |row| row.first }.join(",")
+          SELECT tags.value FROM hosts_tags
+            INNER JOIN tags ON hosts_tags.tag_id = tags.id
+              WHERE hosts_tags.host_id = ? AND tags.name = ?;
+        EOS
+      end
+
+      def select_tag_names_from_hosts_tags_by_host_id(db, host_id)
+        logger.debug("select_tag_names_from_hosts_tags_by_host_id(%s)" % [host_id.inspect])
+        db.execute(<<-EOS, host_id).map { |row| row.first }
+          SELECT DISTINCT tags.name FROM hosts_tags
+            INNER JOIN tags ON hosts_tags.tag_id = tags.id
+              WHERE hosts_tags.host_id = ?;
+        EOS
       end
     end
   end

data/lib/hotdog/commands/hosts.rb

@@ -4,43 +4,22 @@ module Hotdog
   module Commands
     class Hosts < BaseCommand
       def run(args=[])
-        application.run_command("init")
-
         if args.empty?
-          update_hosts(@options.dup)
-          @hosts_q1 ||= @db.prepare(<<-EOS)
-            SELECT DISTINCT host_id FROM hosts_tags;
-          EOS
-          logger.debug("hosts_q1()")
-          result = @hosts_q1.execute().to_a.reduce(:+)
+          result = execute("SELECT DISTINCT host_id FROM hosts_tags").to_a.reduce(:+)
         else
-          if args.map { |host_name| glob?(host_name) }.any?
-            update_hosts(@options.dup)
-          else
-            args.each do |host_name|
-              @hosts_q4 ||= @db.prepare("INSERT OR IGNORE INTO hosts (name) VALUES (?);")
-              logger.debug("hosts_q4(%s)" % [host_name.inspect])
-              @hosts_q4.execute(host_name)
-              update_host_tags(host_name, @options.dup)
-            end
-          end
           result = args.map { |host_name|
             if glob?(host_name)
-              @hosts_q2 ||= @db.prepare(<<-EOS)
+              execute(<<-EOS, host_name).map { |row| row.first }
                 SELECT DISTINCT hosts_tags.host_id FROM hosts_tags
                   INNER JOIN hosts ON hosts_tags.host_id = hosts.id
                     WHERE LOWER(hosts.name) GLOB LOWER(?);
               EOS
-              logger.debug("hosts_q2(%s)" % [host_name.inspect])
-              @hosts_q2.execute(host_name).map { |row| row.first }
             else
-              @hosts_q3 ||= @db.prepare(<<-EOS)
+              execute(<<-EOS, host_name).map { |row| row.first }
                 SELECT DISTINCT hosts_tags.host_id FROM hosts_tags
                   INNER JOIN hosts ON hosts_tags.host_id = hosts.id
                     WHERE LOWER(hosts.name) = LOWER(?);
               EOS
-              logger.debug("hosts_q3(%s)" % [host_name.inspect])
-              @hosts_q3.execute(host_name).map { |row| row.first }
             end
           }.reduce(:+)
         end

data/lib/hotdog/commands/search.rb

@@ -7,20 +7,18 @@ module Hotdog
   module Commands
     class Search < BaseCommand
       def run(args=[])
-        application.run_command("init")
         expression = args.join(" ").strip
         if expression.empty?
           exit(1)
         end
 
-        update_hosts(@options.dup)
-
         begin
           node = parse(expression)
         rescue Parslet::ParseFailed => error
           STDERR.puts("syntax error: " + error.cause.ascii_tree)
           exit(1)
         end
+
         result = evaluate(node, self).sort
         if 0 < result.length
           result, fields = get_hosts(result)

data/lib/hotdog/commands/tags.rb

@@ -4,8 +4,6 @@ module Hotdog
   module Commands
     class Tags < BaseCommand
       def run(args=[])
-        application.run_command("init")
-        update_tags(@options.dup)
         if 0 < tags.length
           fields = tags.map { |tag|
             tag_name, tag_value = tag.split(":", 2)
@@ -13,21 +11,17 @@ module Hotdog
           }
           result1 = fields.map { |tag_name|
             if not glob?(tag_name)
-              @tags_q1 ||= @db.prepare(<<-EOS)
+              execute(<<-EOS, tag_name).map { |row| row.join(",") }
                 SELECT DISTINCT tags.value FROM hosts_tags
                   INNER JOIN tags ON hosts_tags.tag_id = tags.id
                     WHERE tags.name = LOWER(?);
               EOS
-              logger.debug("tags_q1(%s)" % [tag_name.inspect])
-              @tags_q1.execute(tag_name).map { |row| row.join(",") }
             else
-              @tags_q2 ||= @db.prepare(<<-EOS)
+              execute(<<-EOS, tag_name).map { |row| row.join(",") }
                 SELECT DISTINCT tags.value FROM hosts_tags
                   INNER JOIN tags ON hosts_tags.tag_id = tags.id
                     WHERE tags.name GLOB LOWER(?);
               EOS
-              logger.debug("tags_q2(%s)" % [tag_name.inspect])
-              @tags_q2.execute(tag_name).map { |row| row.join(",") }
             end
           }
           result = (0..result1.reduce(0) { |max, values| [max, values.length].max }).map { |field_index|
@@ -35,12 +29,10 @@ module Hotdog
           }
         else
           fields = ["tag"]
-          @tags_q3 ||= @db.prepare(<<-EOS)
-            SELECT tags.name, tags.value FROM hosts_tags
+          result = execute(<<-EOS).map { |name, value| [0 < value.length ? "#{name}:#{value}" : name] }
+            SELECT DISTINCT tags.name, tags.value FROM hosts_tags
               INNER JOIN tags ON hosts_tags.tag_id = tags.id;
           EOS
-          logger.debug("tags_q3()")
-          result = @tags_q3.execute().map { |name, value| [0 < value.length ? "#{name}:#{value}" : name] }
         end
         if 0 < result.length
           STDOUT.print(format(result, fields: fields))

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.0.7"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - Yamashita Yuu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-11 00:00:00.000000000 Z
+date: 2015-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,16 +97,11 @@ files:
 - hotdog.gemspec
 - lib/hotdog/application.rb
 - lib/hotdog/commands.rb
-- lib/hotdog/commands/destroy.rb
-- lib/hotdog/commands/gc.rb
 - lib/hotdog/commands/help.rb
 - lib/hotdog/commands/hosts.rb
-- lib/hotdog/commands/init.rb
 - lib/hotdog/commands/ls.rb
-- lib/hotdog/commands/rm.rb
 - lib/hotdog/commands/search.rb
 - lib/hotdog/commands/tags.rb
-- lib/hotdog/commands/update.rb
 - lib/hotdog/formatters.rb
 - lib/hotdog/formatters/json.rb
 - lib/hotdog/formatters/plain.rb

data/lib/hotdog/commands/destroy.rb

@@ -1,21 +0,0 @@
-#!/usr/bin/env ruby
-
-module Hotdog
-  module Commands
-    class Destroy < BaseCommand
-      def run(args=[])
-        execute(<<-EOS)
-          DROP TABLE IF EXISTS hosts;
-        EOS
-        execute(<<-EOS)
-          DROP TABLE IF EXISTS tags;
-        EOS
-        execute(<<-EOS)
-          DROP TABLE IF EXISTS hosts_tags;
-        EOS
-      end
-    end
-  end
-end
-
-# vim:set ft=ruby :

data/lib/hotdog/commands/gc.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-
-module Hotdog
-  module Commands
-    class Gc < BaseCommand
-      def run(args=[])
-        application.run_command("init")
-        execute(<<-EOS)
-          DELETE FROM hosts WHERE id NOT IN ( SELECT DISTINCT host_id FROM hosts_tags );
-        EOS
-        execute(<<-EOS)
-          DELETE FROM tags WHERE id NOT IN ( SELECT DISTINCT tag_id FROM hosts_tags );
-        EOS
-      end
-    end
-  end
-end
-
-# vim:set ft=ruby :

data/lib/hotdog/commands/init.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-
-module Hotdog
-  module Commands
-    class Init < BaseCommand
-      def run(args=[])
-        execute(<<-EOS)
-          CREATE TABLE IF NOT EXISTS hosts (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name VARCHAR(255) NOT NULL
-          );
-        EOS
-        execute(<<-EOS)
-          CREATE UNIQUE INDEX IF NOT EXISTS hosts_name ON hosts ( name );
-        EOS
-        execute(<<-EOS)
-          CREATE TABLE IF NOT EXISTS tags (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name VARCHAR(200) NOT NULL,
-            value VARCHAR(200) NOT NULL DEFAULT ""
-          );
-        EOS
-        execute(<<-EOS)
-          CREATE UNIQUE INDEX IF NOT EXISTS tags_name_value ON tags ( name, value );
-        EOS
-        execute(<<-EOS)
-          CREATE TABLE IF NOT EXISTS hosts_tags (
-            host_id INTEGER NOT NULL,
-            tag_id INTEGER NOT NULL,
-            expires_at INTEGER NOT NULL
-          );
-        EOS
-        execute(<<-EOS)
-          CREATE UNIQUE INDEX IF NOT EXISTS hosts_tags_host_id_tag_id ON hosts_tags ( host_id, tag_id );
-        EOS
-        execute(<<-EOS)
-          CREATE INDEX IF NOT EXISTS hosts_tags_expires_at ON hosts_tags ( expires_at );
-        EOS
-        execute(<<-EOS)
-          CREATE INDEX IF NOT EXISTS hosts_tags_host_id_expires_at ON hosts_tags ( host_id, expires_at );
-        EOS
-      end
-    end
-  end
-end
-
-# vim:set ft=ruby :

data/lib/hotdog/commands/rm.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-
-module Hotdog
-  module Commands
-    class Rm < BaseCommand
-      def run(args=[])
-        execute(<<-EOS % args.map { "?" }.join(", "), args).map { |row| row.first }
-          DELETE FROM hosts_tags
-            WHERE host_id IN
-              ( SELECT hosts_tags.host_id FROM hosts_tags
-                  INNER JOIN hosts ON hosts_tags.host_id = hosts.id
-                    WHERE hosts.name NOT IN (%s) );
-        EOS
-      end
-    end
-  end
-end
-
-# vim:set ft=ruby :

data/lib/hotdog/commands/update.rb

@@ -1,21 +0,0 @@
-#!/usr/bin/env ruby
-
-module Hotdog
-  module Commands
-    class Update < BaseCommand
-      def run(args=[])
-        application.run_command("init")
-        options[:max_time] = -1
-        if 0 < args.length
-          args.each do |host_name|
-            update_host_tags(host_name, @options.dup)
-          end
-        else
-          update_hosts(@options.dup)
-        end
-      end
-    end
-  end
-end
-
-# vim:set ft=ruby :