rroonga 1.2.7-x86-mingw32 → 1.3.0-x86-mingw32

data/vendor/local/share/groonga/munin/plugins/groonga_cpu_time

@@ -1,57 +0,0 @@
-#!/usr/bin/env ruby
-
-#%# family=auto
-#%# capabilities=autoconf
-
-label = ENV["label"]
-pid_file = ENV["pid_file"]
-
-command = ARGV.shift
-
-case command
-when "autoconf", "detect"
-  if pid_file.nil?
-    puts "no (PID file isn't specified by env.pid_file)"
-    exit(false)
-  elsif File.exist?(pid_file)
-    puts "yes"
-    exit(true)
-  else
-    puts "no (PID file doesn't exist: #{pid_file})"
-    exit(false)
-  end
-when "config"
-  if label
-    title = "groonga: #{label}: CPU time"
-  else
-    title = "groonga: CPU time"
-  end
-  puts <<EOF
-graph_title #{title}
-graph_vlabel CPU time (days)
-graph_category groonga
-graph_info groonga CPU time
-
-cpu_time.label CPU time
-cpu_time.type GAUGE
-EOF
-  exit(true)
-end
-
-groonga_pid = File.read(pid_file).strip
-time = `ps h -o time -p #{groonga_pid}`.chomp
-if /\A(?:(\d+)-)?(\d+):(\d+):(\d+)\z/ =~ time
-  day, hours, minutes, seconds, = $1, $2, $3, $4
-  day = (day || 0).to_i
-  hours = hours.to_i
-  minutes = minutes.to_i
-  seconds = seconds.to_i
-  time_in_seconds = seconds + minutes * 60 + hours * 60 * 60
-  day_in_seconds = 60 * 60 * 24
-  fraction_in_day = time_in_seconds.to_f / day_in_seconds.to_f
-  cpu_time_in_day = day + fraction_in_day
-  puts "cpu_time.value #{cpu_time_in_day}"
-else
-  puts "invalid time format: <#{time}>"
-  exit(false)
-end

data/vendor/local/share/groonga/munin/plugins/groonga_disk

@@ -1,162 +0,0 @@
-#!/usr/bin/env ruby
-
-#%# family=auto
-#%# capabilities=autoconf
-
-require 'shellwords'
-require 'json'
-require 'English'
-
-label = ENV["label"]
-@groonga = ENV["groonga"] || "groonga"
-@du = ENV["du"] || "du"
-@path = ENV["path"]
-
-command = ARGV.shift
-
-def parse(success, result)
-  if success
-    begin
-      status, body = JSON.parse(result)
-      return_code, start_time, elapsed, error_message = status
-      if return_code.zero?
-        [success, body]
-      else
-        [false, error_message]
-      end
-    rescue JSON::ParserError
-      [false, $!.message]
-    end
-  else
-    [success, result]
-  end
-end
-
-def run(command, *args)
-  path = Shellwords.shellescape(@path)
-  result = `#{@groonga} #{path} #{command} #{args.join(' ')} 2>&1`
-  parse($?.success?, result)
-end
-
-def parse_list(header, list)
-  list.collect do |item|
-    parsed_item = {}
-    header.each_with_index do |(name, type), i|
-      parsed_item[name] = item[i]
-    end
-    parsed_item
-  end
-end
-
-def schema
-  tables = []
-  success, table_list_body = run("table_list")
-  unless success
-    puts "error: #{table_list_body}"
-    exit(false)
-  end
-  parse_list(table_list_body[0], table_list_body[1..-1]).each do |table|
-    table_name = table["name"]
-    table["key"] = "table_#{table_name}"
-    success, column_list_body = run("column_list", table_name)
-    unless success
-      puts "error: #{column_list_body}"
-      exit(false)
-    end
-    table["columns"] = parse_list(column_list_body[0], column_list_body[1..-1])
-    table["columns"].each do |column|
-      column["key"] = "column_#{table_name}_#{column['name']}"
-      column["full_name"] = "#{table_name}.#{column['name']}"
-    end
-    tables << table
-  end
-  tables
-end
-
-def parse_du_result(result)
-  usages = {}
-  result.each_line do |line|
-    if /\A(\d+)\s+/ =~ line
-      usage = $1
-      path = $POSTMATCH.strip
-      usages[path] = usage.to_i
-    end
-  end
-  usages
-end
-
-case command
-when "autoconf", "detect"
-  success, body = run("status")
-  if success
-    puts "yes"
-    exit(true)
-  else
-    puts "no (#{body})"
-    exit(false)
-  end
-when "config"
-  if label.nil?
-    title = "groonga: disk usage"
-  else
-    title = "groonga: #{label}: disk usage"
-  end
-  puts <<EOF
-graph_title #{title}
-graph_vlabel Bytes
-graph_category groonga
-graph_info disk usage in groonga tables and columns
-graph_args --base 1024
-graph_total Total
-
-database.label Database
-database.draw AREA
-EOF
-  schema.each do |table|
-    table_key = table["key"]
-    table_name = table["name"]
-    puts <<EOF
-
-#{table_key}.label #{table_name}
-#{table_key}.draw STACK
-EOF
-    table["columns"].each do |column|
-      column_key = column["key"]
-      column_name = column["full_name"]
-      puts <<EOF
-
-#{column_key}.label #{column_name}
-#{column_key}.draw STACK
-EOF
-    end
-  end
-  exit(true)
-end
-
-path = Shellwords.shellescape(@path)
-du_result = `#{@du} -B1 #{path}*`
-unless $?.success?
-  puts("error: #{du_result}")
-  exit(false)
-end
-usages = parse_du_result(du_result)
-usage = usages[@path] || 0
-puts <<EOF
-database.value #{usage}
-EOF
-schema.each do |table|
-  table_key = table["key"]
-  table_name = table["name"]
-  usage = usages[table["path"]] || 0
-  puts <<EOF
-#{table_key}.value #{usage}
-EOF
-  table["columns"].each do |column|
-    column_key = column["key"]
-    usage = usages[column["path"]] || 0
-    usage += usages["#{column['path']}.c"] || 0
-    puts <<EOF
-#{column_key}.value #{usage}
-EOF
-  end
-end

data/vendor/local/share/groonga/munin/plugins/groonga_memory

@@ -1,51 +0,0 @@
-#!/bin/sh
-
-#%# family=auto
-#%# capabilities=autoconf
-
-case "$1" in
-    autoconf|detect)
-	if [ -z "${pid_file}" ]; then
-            echo "no (PID file isn't specified by env.pid_file)"
-	    exit 1
-        elif [ -f "${pid_file}" ]; then
-            echo "yes"
-            exit 0
-        else
-            echo "no (PID file doesn't exist: ${pid_file})"
-            exit 1
-        fi
-        ;;
-    config)
-	if [ -z "${label}" ]; then
-	    title="groonga: memory usage"
-	else
-	    title="groonga: ${label}: memory usage"
-	fi
-        cat <<EOF
-graph_title ${title}
-graph_vlabel memory usage
-graph_category groonga
-graph_info groonga memory usage
-
-rss.label resident set size
-rss.type GAUGE
-vsz.label virtual memory size
-vsz.type GAUGE
-EOF
-        exit 0
-        ;;
-    *)
-esac
-
-if [ -z "${pid_file}" ]; then
-    echo "PID file isn't specified by env.pid_file"
-    exit 1
-fi
-
-groonga_pid=$(cat ${pid_file})
-read rss_in_kb vsz_in_kb <<EOC
-$(ps h -o rss,vsz -p ${groonga_pid})
-EOC
-echo "rss.value ${rss_in_kb}000"
-echo "vsz.value ${vsz_in_kb}000"

data/vendor/local/share/groonga/munin/plugins/groonga_n_records

@@ -1,110 +0,0 @@
-#!/usr/bin/env ruby
-
-#%# family=auto
-#%# capabilities=autoconf
-
-require 'shellwords'
-require 'json'
-
-label = ENV["label"]
-@groonga = ENV["groonga"] || "groonga"
-@host = ENV["host"] || "localhost"
-@port = ENV["port"] || 10041
-@path = ENV["path"]
-
-command = ARGV.shift
-
-def parse(success, result)
-  if success
-    begin
-      status, body = JSON.parse(result)
-      return_code, start_time, elapsed, error_message = status
-      if return_code.zero?
-        [success, body]
-      else
-        [false, error_message]
-      end
-    rescue JSON::ParserError
-      [false, $!.message]
-    end
-  else
-    [success, result]
-  end
-end
-
-def run(command, *args)
-  if @path
-    path = Shellwords.shellescape(@path)
-    result = `#{@groonga} #{path} #{command} #{args.join(' ')} 2>&1`
-  else
-    groonga = "#{@groonga} -p #{@port} -c #{@host}"
-    result = `#{groonga} #{command} #{args.join(' ')} 2>&1`
-  end
-  parse($?.success?, result)
-end
-
-def parse_list(header, list)
-  list.collect do |item|
-    parsed_item = {}
-    header.each_with_index do |(name, type), i|
-      parsed_item[name] = item[i]
-    end
-    parsed_item
-  end
-end
-
-case command
-when "autoconf", "detect"
-  success, body = run("status")
-  if success
-    puts "yes"
-    exit(true)
-  else
-    puts "no (#{body})"
-    exit(false)
-  end
-when "config"
-  if label.nil?
-    title = "groonga: number of records"
-  else
-    title = "groonga: #{label}: number of records"
-  end
-  puts <<EOF
-graph_title #{title}
-graph_vlabel records
-graph_category groonga
-graph_info number of records in groonga table
-EOF
-  success, body = run("table_list")
-  unless success
-    puts "error: #{body}"
-    exit(false)
-  end
-  parse_list(body[0], body[1..-1]).each do |table|
-    name = table["name"]
-    puts <<EOF
-
-#{name}.label #{name}
-#{name}.type GAUGE
-EOF
-  end
-  exit(true)
-end
-
-success, body = run("table_list")
-unless success
-  puts("error: #{body}")
-  exit(false)
-end
-parse_list(body[0], body[1..-1]).each do |table|
-  name = table["name"]
-  success, body = run("select", "#{name} --limit 0")
-  unless success
-    puts("error: #{body}")
-    exit(false)
-  end
-  n_records = body[0][0][0]
-  puts <<EOF
-#{name}.value #{n_records}
-EOF
-end

data/vendor/local/share/groonga/munin/plugins/groonga_query_performance

@@ -1,133 +0,0 @@
-#!/usr/bin/env ruby
-
-#%# family=auto
-#%# capabilities=autoconf
-
-require 'English'
-require 'strscan'
-
-label = ENV["label"]
-
-@log_path = ENV["log_path"]
-
-command = ARGV.shift
-
-case command
-when "autoconf", "detect"
-  if @log_path.nil?
-    puts "no (query log file path isn't specified by env.log_path)"
-    exit(false)
-  end
-  unless File.readable?(@log_path)
-    puts "no (query log file isn't readable: <#{@log_path}>)"
-    exit(false)
-  end
-  puts "yes"
-  exit(true)
-when "config"
-  if label.nil?
-    title = "groonga: query performance"
-  else
-    title = "groonga: #{label}: query performance"
-  end
-  puts <<EOF
-graph_title #{title}
-graph_vlabel seconds
-graph_category groonga
-graph_info groonga query performance
-
-longest.label Longest
-average.label Average
-median.label Median
-EOF
-  exit(true)
-end
-
-class ReverseLineReader
-  def initialize(io)
-    @io = io
-    @io.seek(0, IO::SEEK_END)
-    @buffer = ""
-    @data = ""
-  end
-
-  def each
-    separator = $/
-    separator_length = separator.length
-    while read_to_buffer
-      loop do
-        index = @buffer.rindex(separator, @buffer.length - 1 - separator_length)
-        break if index.nil? or index.zero?
-        last_line = @buffer.slice!((index + separator_length)..-1)
-        yield(last_line)
-      end
-    end
-    yield(@buffer) unless @buffer.empty?
-  end
-
-  private
-  BYTES_PER_READ = 4096
-  def read
-    position = @io.pos
-    if position < BYTES_PER_READ
-      bytes_per_read = position
-    else
-      bytes_per_read = BYTES_PER_READ
-    end
-
-    if bytes_per_read.zero?
-      @data.replace("")
-    else
-      @io.seek(-bytes_per_read, IO::SEEK_CUR)
-      @io.read(bytes_per_read, @data)
-      @io.seek(-bytes_per_read, IO::SEEK_CUR)
-    end
-
-    @data
-  end
-
-  def read_to_buffer
-    data = read
-    if data.empty?
-      false
-    else
-      @buffer.insert(0, data)
-      true
-    end
-  end
-end
-
-span = 60 * 5 # 5min
-mega = 1_000_000.0
-now = Time.now
-elapsed_times = []
-File.open(@log_path) do |log_file|
-  ReverseLineReader.new(log_file).each do |line|
-    case line
-    when /\A(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)\.(\d+)\|([\da-f])+\|<(\d+) rc=0$/
-      _, year, month, day, hour, minutes, seconds, milliseconds,
-        context, elapsed = $LAST_MATCH_INFO.to_a
-      time_stamp = Time.local(year, month, day,
-                              hour, minutes, seconds, milliseconds)
-      difference = now - time_stamp
-      break if difference > span
-      elapsed_in_micro_seconds = elapsed.to_i / mega
-      elapsed_times << elapsed_in_micro_seconds
-    end
-  end
-end
-
-sorted_elapsed_times = elapsed_times.sort
-if sorted_elapsed_times.empty?
-  longest = 0
-  average = 0
-  median = 0
-else
-  longest = sorted_elapsed_times.last
-  average = sorted_elapsed_times.inject(&:+) / sorted_elapsed_times.size.to_f
-  median = sorted_elapsed_times[sorted_elapsed_times.size / 2]
-end
-
-puts "longest.value #{longest}"
-puts "average.value #{average}"
-puts "median.value #{median}"

data/vendor/local/share/groonga/munin/plugins/groonga_status

@@ -1,84 +0,0 @@
-#!/usr/bin/env ruby
-
-#%# family=auto
-#%# capabilities=autoconf
-
-require 'json'
-
-label = ENV["label"]
-@groonga = ENV["groonga"] || "groonga"
-@host = ENV["host"] || "localhost"
-@port = ENV["port"] || 10041
-
-command = ARGV.shift
-
-def parse(success, result)
-  if success
-    begin
-      status, body = JSON.parse(result)
-      return_code, start_time, elapsed, error_message = status
-      if return_code.zero?
-        [success, body]
-      else
-        [false, error_message]
-      end
-    rescue JSON::ParserError
-      [false, $!.message]
-    end
-  else
-    [success, result]
-  end
-end
-
-def run(command, *args)
-  groonga = "#{@groonga} -p #{@port} -c #{@host}"
-  result = `#{groonga} #{command} #{args.join(' ')} 2>&1`
-  parse($?.success?, result)
-end
-
-def parse_list(header, list)
-  list.collect do |item|
-    parsed_item = {}
-    header.each_with_index do |(name, type), i|
-      parsed_item[name] = item[i]
-    end
-    parsed_item
-  end
-end
-
-case command
-when "autoconf", "detect"
-  success, body = run("status")
-  if success
-    puts "yes"
-    exit(true)
-  else
-    puts "no (#{body})"
-    exit(false)
-  end
-when "config"
-  if label.nil?
-    title = "groonga: status"
-  else
-    title = "groonga: #{label}: status"
-  end
-  puts <<EOF
-graph_title #{title}
-graph_vlabel status
-graph_category groonga
-graph_info groonga status
-
-alloc_count.label alloc count
-alloc_count.type GAUGE
-EOF
-  exit(true)
-end
-
-success, body = run("status")
-unless success
-  puts("error: #{body}")
-  exit(false)
-end
-puts <<EOF
-alloc_count.value #{body["alloc_count"]}
-EOF