hotdog 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 953ecab33a4f48f426c3df8b0dcca49e861e5113
+  data.tar.gz: 81868bd92db6fddf876fd7eae71c54a2dd841bad
+SHA512:
+  metadata.gz: 2763f5fa563fef343b799514436bde84dd886494577b42269118c4e82d999d1c8b3c289e50e3c2a02ba4fb8806c00fbd2a2f8abe4054abc90a9457684daad7d1
+  data.tar.gz: bc471b4a441f275d7fbbf6b2df8d706016de004c80a949fa86499db0d09ad174b708d5864248332d4c540d00731e146e6039f97d61c090422ac7125ea229504e

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.swo
+*.swp
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org/"
+
+# Specify your gem's dependencies in hotdog.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Yamashita Yuu
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# Hotdog
+
+Yet another command-line tools for [Datadog](https://www.datadoghq.com/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hotdog'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install hotdog
+```
+
+## Usage
+
+Setup environment variables of `DATADOG_API_KEY` and `DATADOG_APPLICATION_KEY`.
+Then, create and initialize host information. This may take several minutes.
+
+```sh
+$ hotdog init
+$ hotdot update
+```
+
+List all registered hosts.
+
+```sh
+$ hotdog ls
+i-02605a79
+i-02d78cec
+i-03cb56ed
+i-03dabcef
+i-069e282c
+```
+
+List all registered hosts with associated tags and headers.
+
+```sh
+$ hotdog ls -h -l
+host       security-group name              availability-zone instance-type image        region    kernel      
+---------- -------------- ----------------- ----------------- ------------- ------------ --------- ------------
+i-02605a79 sg-89bfe710    web-staging       us-east-1a        m3.medium     ami-66089cdf us-east-1 aki-89ab75e1
+i-02d78cec sg-89bfe710    web-production    us-east-1a        c3.4xlarge    ami-8bb3fc92 us-east-1 aki-89ab75e1
+i-03cb56ed sg-89bfe710    web-production    us-east-1b        c3.4xlarge    ami-8bb3fc92 us-east-1 aki-89ab75e1
+i-03dabcef sg-89bfe710    worker-production us-east-1a        c3.xlarge     ami-4032c1c8 us-east-1 aki-89ab75e1
+i-069e282c sg-89bfe710    worker-staging    us-east-1a        t2.micro      ami-384c8480 us-east-1 aki-89ab75e1
+```
+
+Display hosts with specific attributes.
+
+```sh
+$ hotdog ls -a host -a name
+host       name             
+---------- -----------------
+i-02605a79 web-staging      
+i-02d78cec web-production   
+i-03cb56ed web-production   
+i-03dabcef worker-production
+i-069e282c worker-staging   
+```
+
+Search hosts matching to specified tags and values.
+
+```sh
+$ hotdog search availability-zone:us-east-1b and 'name:web-*'
+i-03cb56ed
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/yyuu/hotdog/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/hotdog

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __FILE__)
+require "bundler/setup"
+require "hotdog/application"
+dog = Hotdog::Application.new
+dog.main(ARGV.dup)

data/hotdog.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "hotdog/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hotdog"
+  spec.version       = Hotdog::VERSION
+  spec.authors       = ["Yamashita Yuu"]
+  spec.email         = ["peek824545201@gmail.com"]
+  spec.summary       = %q{Yet another command-line tool for Datadog}
+  spec.description   = %q{Yet another command-line tool for Datadog}
+  spec.homepage      = "https://github.com/yyuu/hotdog"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "dogapi", "~> 1.13.0"
+  spec.add_dependency "parslet", "~> 1.6.2"
+  spec.add_dependency "sqlite3", "~> 1.3.10"
+end

data/lib/hotdog/application.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/env ruby
+
+require "logger"
+require "optparse"
+require "shellwords"
+require "sqlite3"
+require "hotdog/commands"
+require "hotdog/formatters"
+
+module Hotdog
+  class Application
+    def initialize()
+      @confdir = File.join(ENV["HOME"], ".hotdog")
+      @optparse = OptionParser.new
+      @options = {
+        environment: "default",
+        minimum_expiry: 28800, # 8 hours
+        random_expiry: 57600, # 16 hours
+        force: false,
+        formatter: get_formatter("plain").new,
+        headers: false,
+        listing: false,
+        logger: Logger.new(STDERR),
+        api_key: ENV["DATADOG_API_KEY"],
+        application_key: ENV["DATADOG_APPLICATION_KEY"],
+        print0: false,
+        print1: true,
+        tags: [],
+      }
+      @options[:logger].level = Logger::INFO
+      define_options
+    end
+    attr_reader :options
+
+    def main(argv=[])
+      config = File.join(@confdir, "config.yml")
+      if File.file?(config)
+        @options = @options.merge(YAML.load(File.read(config)))
+      end
+      args = @optparse.parse(argv)
+
+      unless options[:api_key]
+        raise("DATADOG_API_KEY is not set")
+      end
+
+      unless options[:application_key]
+        raise("DATADOG_APPLICATION_KEY is not set")
+      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" )
+        run_command(command, args)
+      rescue Errno::EPIPE
+        # nop
+      end
+    end
+
+    def run_command(command, args=[])
+      get_command(command).new(@db, options.merge(application: self)).run(args)
+    end
+
+    private
+    def define_options
+      @optparse.on("--api-key API_KEY") do |api_key|
+        options[:api_key] = api_key
+      end
+      @optparse.on("--application-key APP_KEY") do |app_key|
+        options[:application_key] = app_key
+      end
+      @optparse.on("-0", "--null") do
+        options[:print0] = true
+      end
+      @optparse.on("-1") do
+        options[:print1] = true
+      end
+      @optparse.on("-d", "--debug") do
+        options[:logger].level = Logger::DEBUG
+      end
+      @optparse.on("-E ENVIRONMENT", "--environment ENVIRONMENT") do |environment|
+        options[:environment] = environment
+      end
+      @optparse.on("-f", "--force") do
+        options[:force] = true
+      end
+      @optparse.on("-F FORMAT", "--format FORMAT") do |format|
+        options[:formatter] = get_formatter(format).new
+      end
+      @optparse.on("-h", "--headers") do |headers|
+        options[:headers] = headers
+      end
+      @optparse.on("-l") do
+        options[:listing] = true
+      end
+      @optparse.on("-a TAG", "-t TAG", "--tag TAG") do |tag|
+        options[:tags] += [tag]
+      end
+      @optparse.on("-V", "--verbose") do |tag|
+        options[:logger].level = Logger::DEBUG
+      end
+    end
+
+    def const_name(name)
+      name.to_s.split(/[^\w]+/).map { |s| s.capitalize }.join
+    end
+
+    def get_formatter(name)
+      begin
+        Hotdog::Formatters.const_get(const_name(name))
+      rescue NameError
+        if library = find_library("hotdog/formatters", name)
+          load library
+          Hotdog::Formatters.const_get(const_name(File.basename(library, ".rb")))
+        else
+          raise(NameError.new("unknown format: #{name}"))
+        end
+      end
+    end
+
+    def get_command(name)
+      begin
+        Hotdog::Commands.const_get(const_name(name))
+      rescue NameError
+        if library = find_library("hotdog/commands", name)
+          load library
+          Hotdog::Commands.const_get(const_name(File.basename(library, ".rb")))
+        else
+          raise(NameError.new("unknown command: #{name}"))
+        end
+      end
+    end
+
+    def find_library(dirname, name)
+      load_path = $LOAD_PATH.map { |path| File.join(path, dirname) }.select { |path| File.directory?(path) }
+      libraries = load_path.map { |path| Dir.glob(File.join(path, "*.rb")) }.reduce(:+).select { |file| File.file?(file) }
+      rbname = "#{name}.rb"
+      if library = libraries.find { |file| File.basename(file) == rbname }
+        library
+      else
+        candidates = libraries.map { |file| [file, File.basename(file).slice(0, name.length)] }.select { |file, s| s == name }
+        if candidates.length == 1
+          candidates.first.first
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/commands/destroy.rb

@@ -0,0 +1,21 @@
+#!/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

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+module Hotdog
+  module Commands
+    class Gc < BaseCommand
+      def run(args=[])
+        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/help.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "rbconfig"
+
+module Hotdog
+  module Commands
+    class Help < BaseCommand
+      def run(args=[])
+        ruby = File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
+        exit(system(ruby, $0, "--help") ? 0 : 1)
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/commands/hosts.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+module Hotdog
+  module Commands
+    class Hosts < BaseCommand
+      def run(args=[])
+        update_hosts(@options.dup)
+
+        if args.empty?
+          result = execute(<<-EOS).map { |row| row.first }
+            SELECT DISTINCT host_id FROM hosts_tags;
+          EOS
+        else
+          result = args.map { |host_name|
+            if host_name.index("*")
+              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
+            else
+              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
+            end
+          }.reduce(:+)
+        end
+        if 0 < result.length
+          result, fields = get_hosts(result)
+          STDOUT.puts(format(result, fields: fields))
+        else
+          STDERR.puts("no match found: #{args.join(" ")}")
+          exit(1)
+        end
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/commands/init.rb

@@ -0,0 +1,44 @@
+#!/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
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/commands/ls.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require "hotdog/commands/hosts"
+
+module Hotdog
+  module Commands
+    class Ls < Hosts
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/commands/rm.rb

@@ -0,0 +1,19 @@
+#!/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/search.rb

@@ -0,0 +1,278 @@
+#!/usr/bin/env ruby
+
+require "json"
+require "parslet"
+
+module Hotdog
+  module Commands
+    class Search < BaseCommand
+      def run(args=[])
+        expression = args.join(" ").strip
+        if expression.empty?
+          exit(1)
+        end
+
+        update_hosts(@options.dup)
+#       update_tags(@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)
+          STDOUT.puts(format(result, fields: fields))
+        else
+          STDERR.puts("no match found: #{args.join(" ")}")
+          exit(1)
+        end
+      end
+
+      def parse(expression)
+        parser = ExpressionParser.new
+        parser.parse(expression).tap do |parsed|
+          logger.debug(JSON.pretty_generate(JSON.load(parsed.to_json)))
+        end
+      end
+
+      def evaluate(node, environment)
+        node = ExpressionTransformer.new.apply(node)
+        node.evaluate(environment)
+      end
+
+      class ExpressionParser < Parslet::Parser
+        root(:expression)
+        rule(:expression) {
+          ( binary_expression \
+          | term \
+          )
+        }
+        rule(:binary_expression) {
+          ( term.as(:left) >> spacing.maybe >> (str('&') >> str('&').maybe).as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+          | term.as(:left) >> spacing.maybe >> (str('|') >> str('|').maybe).as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+          | term.as(:left) >> spacing.maybe >> (match('[Aa]') >> match('[Nn]') >> match('[Dd]')).as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+          | term.as(:left) >> spacing.maybe >> (match('[Oo]') >> match('[Rr]')).as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+          )
+        }
+        rule(:unary_expression) {
+          ( spacing.maybe >> str('!').as(:unary_op) >> atom.as(:expression) \
+          | spacing.maybe >> str('~').as(:unary_op) >> atom.as(:expression) \
+          | spacing.maybe >> str('not').as(:unary_op) >> atom.as(:expression) \
+          )
+        }
+        rule(:term) {
+          ( unary_expression \
+          | atom \
+          )
+        }
+        rule(:atom) {
+          ( spacing.maybe >> str('(') >> expression >> str(')') >> spacing.maybe \
+          | spacing.maybe >> identifier_regexp.as(:identifier_regexp) >> str(':') >> attribute_regexp.as(:attribute_regexp) >> spacing.maybe \
+          | spacing.maybe >> identifier_regexp.as(:identifier_regexp) >> spacing.maybe \
+          | spacing.maybe >> identifier_glob.as(:identifier_glob) >> str(':') >> attribute_glob.as(:attribute_glob) >> spacing.maybe \
+          | spacing.maybe >> identifier_glob.as(:identifier_glob) >> str(':') >> attribute.as(:attribute) >> spacing.maybe \
+          | spacing.maybe >> identifier_glob.as(:identifier_glob) >> spacing.maybe \
+          | spacing.maybe >> identifier.as(:identifier)>> str(':') >> attribute_glob.as(:attribute_glob) >> spacing.maybe \
+          | spacing.maybe >> identifier.as(:identifier)>> str(':') >> attribute.as(:attribute) >> spacing.maybe \
+          | spacing.maybe >> identifier.as(:identifier) >> spacing.maybe \
+          )
+        }
+        rule(:identifier_regexp) {
+          ( str('/') >> (str('/').absent? >> any).repeat(0) >> str('/') \
+          )
+        }
+        rule(:identifier_glob) {
+          ( identifier.repeat(0) >> (glob >> identifier.maybe).repeat(1) \
+          )
+        }
+        rule(:identifier) {
+          ( match('[A-Za-z]') >> match('[-./0-9A-Z_a-z]').repeat(0) \
+          )
+        }
+        rule(:attribute_regexp) {
+          ( str('/') >> (str('/').absent? >> any).repeat(0) >> str('/') \
+          )
+        }
+        rule(:attribute_glob) {
+          ( attribute.repeat(0) >> (glob >> attribute.maybe).repeat(1) \
+          )
+        }
+        rule(:attribute) {
+          ( match('[-./0-9:A-Z_a-z]').repeat(1) \
+          )
+        }
+        rule(:glob) {
+          ( str('*') | str('?') | str('[') | str(']') )
+        }
+        rule(:spacing) {
+          ( match('[\t\n\r ]').repeat(1) \
+          )
+        }
+      end
+
+      class ExpressionTransformer < Parslet::Transform
+        rule(:binary_op => simple(:binary_op), :left => simple(:left), :right => simple(:right)) {
+          BinaryExpressionNode.new(binary_op, left, right)
+        }
+        rule(:unary_op => simple(:unary_op), :expression => simple(:expression)) {
+          UnaryExpressionNode.new(unary_op, expression)
+        }
+        rule(:identifier_regexp => simple(:identifier_regexp), :attribute_regexp => simple(:attribute_regexp)) {
+          TagRegexpExpressionNode.new(identifier_regexp.to_s, attribute_regexp.to_s)
+        }
+        rule(:identifier_regexp => simple(:identifier_regexp)) {
+          TagRegexpExpressionNode.new(identifier_regexp.to_s, nil)
+        }
+        rule(:identifier_glob => simple(:identifier_glob), :attribute_glob => simple(:attribute_glob)) {
+          TagGlobExpressionNode.new(identifier_glob.to_s, attribute_glob.to_s)
+        }
+        rule(:identifier_glob => simple(:identifier_glob), :attribute => simple(:attribute)) {
+          TagGlobExpressionNode.new(identifier_glob.to_s, attribute.to_s)
+        }
+        rule(:identifier_glob => simple(:identifier_glob)) {
+          TagGlobExpressionNode.new(identifier_glob.to_s, nil)
+        }
+        rule(:identifier => simple(:identifier), :attribute_glob => simple(:attribute_glob)) {
+          TagGlobExpressionNode.new(identifier.to_s, attribute_glob.to_s)
+        }
+        rule(:identifier => simple(:identifier), :attribute => simple(:attribute)) {
+          TagExpressionNode.new(identifier.to_s, attribute.to_s)
+        }
+        rule(:identifier => simple(:identifier)) {
+          TagExpressionNode.new(identifier.to_s, nil)
+        }
+      end
+
+      class ExpressionNode
+        def evaluate(environment)
+          raise(NotImplementedError)
+        end
+      end
+
+      class BinaryExpressionNode < ExpressionNode
+        def initialize(op, left, right)
+          @op = op
+          @left = left
+          @right = right
+        end
+        def evaluate(environment)
+          case @op
+          when "&&", "&", /\Aand\z/i
+            left_values = @left.evaluate(environment)
+            if left_values.empty?
+              []
+            else
+              (left_values & @right.evaluate(environment)).uniq
+            end
+          when "||", "|", /\Aor\z/i
+            left_values = @left.evaluate(environment)
+            (left_values | @right.evaluate(environment)).uniq
+          else
+            raise(SyntaxError.new("unknown binary operator: #{@op}"))
+          end
+        end
+      end
+
+      class UnaryExpressionNode < ExpressionNode
+        def initialize(op, expression)
+          @op = op
+          @expression = expression
+        end
+        def evaluate(environment)
+          case @op
+          when "!", "~", /\Anot\z/i
+            values = @expression.evaluate(environment)
+            if values.empty?
+              environment.execute(<<-EOS).map { |row| row.first }
+                SELECT DISTINCT host_id FROM hosts_tags;
+              EOS
+            else
+              environment.execute(<<-EOS % values.map { "?" }.join(", "), values).map { |row| row.first }
+                SELECT DISTINCT host_id FROM hosts_tags WHERE host_id NOT IN (%s);
+              EOS
+            end
+          else
+            raise(SyntaxError.new("unknown unary operator: #{@op}"))
+          end
+        end
+      end
+
+      class TagExpressionNode < ExpressionNode
+        def initialize(identifier, attribute)
+          @identifier = identifier
+          @attribute = attribute
+        end
+        attr_reader :identifier
+        attr_reader :attribute
+        def attribute?
+          !attribute.nil?
+        end
+        def evaluate(environment)
+          if attribute?
+            environment.execute(<<-EOS, identifier, attribute).map { |row| row.first }
+              SELECT DISTINCT hosts_tags.host_id FROM hosts_tags
+                INNER JOIN tags ON hosts_tags.tag_id = tags.id
+                  WHERE LOWER(tags.name) = LOWER(?) AND LOWER(tags.value) = LOWER(?);
+            EOS
+          else
+            environment.execute(<<-EOS, identifier, identifier, identifier).map { |row| row.first }
+              SELECT DISTINCT hosts_tags.host_id FROM hosts_tags
+                INNER JOIN hosts ON hosts_tags.host_id = hosts.id
+                INNER JOIN tags ON hosts_tags.tag_id = tags.id
+                  WHERE LOWER(hosts.name) = LOWER(?) OR LOWER(tags.name) = LOWER(?) OR LOWER(tags.value) = LOWER(?);
+            EOS
+          end
+        end
+      end
+
+      class TagGlobExpressionNode < TagExpressionNode
+        def evaluate(environment)
+          if attribute?
+            environment.execute(<<-EOS, identifier, attribute).map { |row| row.first }
+              SELECT DISTINCT hosts_tags.host_id FROM hosts_tags
+                INNER JOIN tags ON hosts_tags.tag_id = tags.id
+                  WHERE LOWER(tags.name) GLOB LOWER(?) AND LOWER(tags.value) GLOB LOWER(?);
+            EOS
+          else
+            environment.execute(<<-EOS, identifier, identifier, identifier).map { |row| row.first }
+              SELECT DISTINCT hosts_tags.host_id FROM hosts_tags
+                INNER JOIN hosts ON hosts_tags.host_id = hosts.id
+                INNER JOIN tags ON hosts_tags.tag_id = tags.id
+                  WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);
+
+            EOS
+          end
+        end
+      end
+
+      class TagRegexpExpressionNode < TagExpressionNode
+        def initialize(identifier, attribute)
+          identifier = identifier.sub(%r{\A/(.*)/\z}) { $1 } if identifier
+          attribute = attribute.sub(%r{\A/(.*)/\z}) { $1 } if attribute
+          super(identifier, attribute)
+        end
+        def evaluate(environment)
+          if attribute?
+            environment.execute(<<-EOS, identifier, attribute).map { |row| row.first }
+              SELECT DISTINCT hosts_tags.host_id FROM hosts_tags
+                INNER JOIN tags ON hosts_tags.tag_id = tags.id
+                  WHERE LOWER(tags.name) REGEXP LOWER(?) AND LOWER(tags.value) REGEXP LOWER(?);
+            EOS
+          else
+            environment.execute(<<-EOS, identifier, identifier, identifier).map { |row| row.first }
+              SELECT DISTINCT hosts_tags.host_id FROM hosts_tags
+                INNER JOIN hosts ON hosts_tags.host_id = hosts.id
+                INNER JOIN tags ON hosts_tags.tag_id = tags.id
+                  WHERE LOWER(hosts.name) REGEXP LOWER(?) OR LOWER(tags.name) REGEXP LOWER(?) OR LOWER(tags.value) REGEXP LOWER(?);
+            EOS
+          end
+        end
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/commands/tags.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+module Hotdog
+  module Commands
+    class Tags < BaseCommand
+      def run(args=[])
+        update_tags(@options.dup)
+        if 0 < tags.length
+          fields = tags.map { |tag|
+            tag_name, tag_value = tag.split(":", 2)
+            tag_name
+          }
+          result1 = fields.map { |tag_name|
+            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
+          }
+          result = (0..result1.reduce(0) { |max, values| [max, values.length].max }).map { |field_index|
+            result1.map { |values| values[field_index] }
+          }
+        else
+          fields = ["tag"]
+          result = execute(<<-EOS).map { |name, value| [0 < value.length ? "#{name}:#{value}" : name] }
+            SELECT tags.name, tags.value FROM hosts_tags
+              INNER JOIN tags ON hosts_tags.tag_id = tags.id;
+          EOS
+        end
+        if 0 < result.length
+          STDOUT.puts(format(result, fields: fields))
+        end
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/commands/update.rb

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

data/lib/hotdog/commands.rb

@@ -0,0 +1,228 @@
+#!/usr/bin/env ruby
+
+require "dogapi"
+require "logger"
+
+module Hotdog
+  module Commands
+    class BaseCommand
+      def initialize(db, options={})
+        @db = db
+        @formatter = options[:formatter]
+        @logger = options[:logger]
+        @tags = options[:tags]
+        @application = options[:application]
+        @options = options
+        @dog = Dogapi::Client.new(options[:api_key], options[:application_key])
+      end
+      attr_reader :application
+      attr_reader :formatter
+      attr_reader :logger
+      attr_reader :tags
+      attr_reader :options
+
+      def run(args=[])
+        raise(NotImplementedError)
+      end
+
+      def execute(query, *args)
+        q = query.strip
+        if 0 < args.length
+          q += " -- VALUES (#{args.map { |arg| Array === arg ? "(#{arg.join(", ")})" : arg.inspect }.join(", ")})"
+        end
+        logger.debug(q)
+        @db.execute(query, args)
+      end
+
+      private
+      def format(result, options={})
+        @formatter.format(result, @options.merge(options))
+      end
+
+      def get_hosts(hosts=[])
+        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)
+              if tag_name == "host"
+                logger.debug("get_hosts_q1()")
+                @get_hosts_q1 ||= @db.prepare(<<-EOS)
+                  SELECT name FROM hosts WHERE id = ? LIMIT 1;
+                EOS
+                @get_hosts_q1.execute(host_id).map { |row| row.first }.join(",")
+              else
+                logger.debug("get_hosts_q2()")
+                @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
+                @get_hosts_q2.execute(host_id, tag_name).map { |row| row.first }.join(",")
+              end
+            }
+          }
+          fields = tags
+        else
+          if options[:listing]
+
+            fields = []
+            hosts = execute(<<-EOS % hosts.map { "?" }.join(", "), hosts)
+              SELECT id, name FROM hosts WHERE id IN (%s) ORDER BY name;
+            EOS
+            result = hosts.map { |host_id, host_name|
+              update_host_tags(host_name, @options.dup)
+              logger.debug("get_hosts_q3()")
+              @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
+              tag_names = @get_hosts_q3.execute(host_id).map { |row| row.first }
+              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(",")
+              }
+            }
+            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
+          end
+        end
+        [result, fields]
+      end
+
+      def update_hosts(options={})
+        @db.transaction do
+          if not options[:force]
+            @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
+                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.")
+            end
+          end
+
+          code, result = @dog.search("hosts:")
+          if code.to_i / 100 != 2
+            raise("HTTP #{code}: #{result.inspect}")
+          end
+
+          result["results"]["hosts"].each do |host_name|
+            @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("INSERT OR IGNORE INTO hosts (name) VALUES (?);", host_name)
+            update_host_tags(host_name, options)
+          end
+
+          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 name IN ( %s ) );
+          EOS
+        end
+      end
+
+      def update_tags(options={})
+        @db.transaction do
+          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
+            logger.debug("update_tags_q2()")
+            @update_tags_q2 ||= @db.prepare(<<-EOS)
+              SELECT DISTINCT hosts_tags.host_id FROM hosts_tags
+                WHERE hosts_tags.expires_at < ?;
+            EOS
+            hosts = @update_tags_q2.execute(Time.new.to_i)
+          end
+          hosts.each do |host_name|
+            update_host_tags(host_name, options)
+          end
+        end
+      end
+
+      def update_host_tags(host_name, options={})
+        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 FROM hosts WHERE LOWER(name) = LOWER(?) LIMIT 1;")
+          logger.debug("update_host_tags_q2(%s)" % [host_name.inspect])
+          host_id = @update_host_tags_q2.execute(host_name).map { |row| row.first }.first
+        end
+
+        if not options[:force]
+          @update_host_tags_q3 ||= @db.prepare("SELECT MIN(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
+              return
+            else
+              logger.debug("%s: minimum 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
+
+        code, result = @dog.host_tags(host_name)
+        if code.to_i / 100 != 2
+          raise("HTTP #{code}: #{result.inspect}")
+        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)])
+
+        result["tags"].each do |tag|
+          tag_name, tag_value = tag.split(":", 2)
+          tag_value ||= ""
+
+          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
+
+        @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
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/formatters/json.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "json"
+
+module Hotdog
+  module Formatters
+    class Json < BaseFormatter
+      def format(result, options={})
+        JSON.pretty_generate(result)
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/formatters/plain.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+module Hotdog
+  module Formatters
+    class Plain < BaseFormatter
+      def format(result, options={})
+        if options[:print0]
+          sep = "\0"
+        elsif options[:print1]
+          sep = "\n"
+        else
+          sep = " "
+        end
+        if options[:print1] and options[:headers] and options[:fields]
+          field_length = (0...result.last.length).map { |field_index|
+            result.reduce(0) { |length, row|
+              [length, row[field_index].to_s.length, options[:fields][field_index].to_s.length].max
+            }
+          }
+          header_fields = options[:fields].zip(field_length).map { |field, length|
+            field.to_s + (" " * (length - field.length))
+          }
+          result = [
+            header_fields,
+            header_fields.map { |field|
+              "-" * field.length
+            },
+          ] + result.map { |row|
+            row.zip(field_length).map { |field, length|
+              field.to_s + (" " * (length - field.length))
+            }
+          }
+        end
+        _format(result, sep, options)
+      end
+
+      def _format(result, sep, options={})
+        result.map { |row|
+          row.join(" ")
+        }.join(sep)
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/formatters/yaml.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "yaml"
+
+module Hotdog
+  module Formatters
+    class Yaml < BaseFormatter
+      def format(result, options={})
+        result.to_yaml
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/formatters.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+module Hotdog
+  module Formatters
+    class BaseFormatter
+      def format(result, options={})
+        raise(NotImplementedError)
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/version.rb

@@ -0,0 +1,3 @@
+module Hotdog
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: hotdog
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yamashita Yuu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: dogapi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+description: Yet another command-line tool for Datadog
+email:
+- peek824545201@gmail.com
+executables:
+- hotdog
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/hotdog
+- 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
+- lib/hotdog/formatters/yaml.rb
+- lib/hotdog/version.rb
+homepage: https://github.com/yyuu/hotdog
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.4
+signing_key: 
+specification_version: 4
+summary: Yet another command-line tool for Datadog
+test_files: []