flare-tools 0.4.5.1 → 0.5.0

data/lib/flare/tools/cli/slave.rb

@@ -11,6 +11,7 @@ require 'flare/tools/common'
 require 'flare/util/conversion'
 require 'flare/util/constant'
 require 'flare/tools/cli/sub_command'
+require 'flare/tools/cli/index_server_config'
 
 module Flare
   module Tools
@@ -19,17 +20,21 @@ module Flare
         include Flare::Util::Conversion
         include Flare::Util::Constant
         include Flare::Tools::Common
+        include Flare::Tools::Cli::IndexServerConfig
 
         DefaultRetry = 10
-        
+
         myname :slave
         desc   "construct slaves from proxy nodes."
         usage  "slave [hostname:port:balance:partition] ..."
 
-        def setup(opt)
-          opt.on('--force',          "commit changes without confirmation") {@force = true}
-          opt.on('--retry=COUNT',    "specify retry count(default:#{@retry})") {|v| @retry = v.to_i}
-          opt.on('--clean',          "clear datastore before construction") {@clean = true}
+        def setup
+          super
+          set_option_index_server
+          set_option_dry_run
+          set_option_force
+          @optp.on('--retry=COUNT',    "specify retry count(default:#{@retry})") {|v| @retry = v.to_i}
+          @optp.on('--clean',          "clear datastore before construction") {@clean = true}
         end
 
         def initialize
@@ -39,7 +44,8 @@ module Flare
           @clean = false
         end
 
-        def execute(config, *args)
+        def execute(config, args)
+          parse_index_server(config, args)
           return S_NG if args.empty?
 
           hosts = args.map do |arg|
@@ -50,10 +56,10 @@ module Flare
             end
             [hostname, port, balance.to_i, partition.to_i]
           end
-          
-          Flare::Tools::IndexServer.open(config[:index_server_hostname], config[:index_server_port], config[:timeout]) do |s|
+
+          Flare::Tools::IndexServer.open(config[:index_server_hostname], config[:index_server_port], @timeout) do |s|
             cluster = fetch_cluster(s)
-          
+
             hosts.each do |hostname,port,balance,partition|
               nodekey = nodekey_of hostname, port
 
@@ -68,7 +74,7 @@ module Flare
                 puts "#{nodekey} is not a proxy."
                 next
               end
-              
+
               exec = @force
               unless exec
                 STDERR.print "making node slave (node=#{nodekey}, role=#{node['role']} -> slave) (y/n): "
@@ -76,9 +82,9 @@ module Flare
                   exec = true if gets.chomp.upcase == "Y"
                 end
               end
-              if exec && !config[:dry_run]
+              if exec && !@dry_run
                 if @clean
-                  Flare::Tools::Node.open(hostname, port, config[:timeout]) do |n|
+                  Flare::Tools::Node.open(hostname, port, @timeout) do |n|
                     n.flush_all
                   end
                 end
@@ -97,7 +103,7 @@ module Flare
                   end
                 end
                 if resp
-                  wait_for_slave_construction(s, nodekey, config[:timeout])
+                  wait_for_slave_construction(s, nodekey, @timeout)
                   if balance > 0
                     unless @force
                       STDERR.print "changing node's balance (node=#{nodekey}, balance=0 -> #{balance}) (y/n): "
@@ -115,7 +121,7 @@ module Flare
             end
             STDOUT.puts string_of_nodelist(s.stats_nodes, hosts.map {|x| x[0..1].join(':')})
           end
-          
+
           return S_OK
         end # execute()
 

data/lib/flare/tools/cli/stats.rb

@@ -8,8 +8,9 @@ require 'flare/tools/index_server'
 require 'flare/tools/cli/sub_command'
 require 'flare/tools/common'
 require 'flare/util/conversion'
+require 'flare/util/pretty_table'
+require 'flare/tools/cli/index_server_config'
 
-# 
 module Flare
   module Tools
     module Cli
@@ -20,29 +21,40 @@ module Flare
         include Flare::Util::Conversion
         include Flare::Util::Logging
         include Flare::Tools::Common
-        
+        include Flare::Util::PrettyTable
+        include Flare::Tools::Cli::IndexServerConfig
+
         myname :stats
         desc   "show the statistics of a flare cluster."
         usage  "stats [hostname:port] ..."
 
-        HeaderConfig = [ ['%-25.25s', 'hostname:port'],
-                         ['%7s',      'state'],
-                         ['%6s',      'role'],
-                         ['%9s',      'partition'],
-                         ['%7s',      'balance'],
-                         ['%8.8s',    'items'],
-                         ['%4s',      'conn'],
-                         ['%6.6s',    'behind'],
-                         ['%3.3s',    'hit'],
-                         ['%4.4s',    'size'],
-                         ['%6.6s',    'uptime'],
-                         ['%7s',      'version'] ]
-
-        def setup(opt)
-          opt.on("-q", '--qps',              "show qps")                             {|v| @qps = v}
-          opt.on("-w", '--wait=SECOND',      "specify wait time for repeat(second)") {|v| @wait = v.to_i}
-          opt.on("-c", '--count=REPEATTIME', "specify repeat count")                 {|v| @count = v.to_i}
-          opt.on("-d", '--delimiter=CHAR',   "spedify delimiter")                    {|v| @delimiter = v}
+        HeaderConfigs = [
+          ['hostname:port', {}],
+          ['state', {}],
+          ['role', {}],
+          ['partition', {:align => :right}],
+          ['balance', {:align => :right}],
+          ['items', {:align => :right}],
+          ['conn', {:align => :right}],
+          ['behind', {:align => :right}],
+          ['hit', {:align => :right}],
+          ['size', {:align => :right}],
+          ['uptime', {:align => :right}],
+          ['version', {:align => :right}],
+        ]
+        HeaderConfigQpss = [
+          ['qps', {:align => :right}],
+          ['qps-r', {:align => :right}],
+          ['qps-w', {:align => :right}],
+        ]
+
+        def setup
+          super
+          set_option_index_server
+          @optp.on("-q", '--qps',              "show qps")                             {|v| @qps = v}
+          @optp.on("-w", '--wait=SECOND',      "specify wait time for repeat(second)") {|v| @wait = v.to_i}
+          @optp.on("-c", '--count=REPEATTIME', "specify repeat count")                 {|v| @count = v.to_i}
+          @optp.on("-d", '--delimiter=CHAR',   "specify delimiter")                    {|v| @delimiter = v}
         end
 
         def initialize
@@ -53,19 +65,18 @@ module Flare
           @cont = true
           @delimiter = ' '
         end
-  
+
         def interrupt
           puts "INTERRUPTED"
           @cont = false
         end
 
-        def execute(config, *args)
+        def execute(config, args)
+          parse_index_server(config, args)
           nodes = {}
           threads = {}
-          header = Marshal.load(Marshal.dump(HeaderConfig))
-          header << ['%5.5s', 'qps'] << ['%5.5s', 'qps-r'] << ['%5.5s', 'qps-w'] if @qps
 
-          Flare::Tools::IndexServer.open(config[:index_server_hostname], config[:index_server_port], config[:timeout]) do |s|
+          Flare::Tools::IndexServer.open(config[:index_server_hostname], config[:index_server_port], @timeout) do |s|
             nodes = s.stats_nodes
             unless nodes
               error "Invalid index server."
@@ -79,64 +90,11 @@ module Flare
           queue = {}
 
           nodes.each do |hostname_port,data|
-            hostname, port = hostname_port.split(":", 2)
             queue[hostname_port] = SizedQueue.new(1)
             worker_threads << Thread.new(queue[hostname_port]) do |q|
-              s = nil
-              while @cont
-                stats_data = nil
-                begin
-                  s = Flare::Tools::Stats.open(hostname, data['port'], config[:timeout])
-                  stats = s.stats
-                  time = Time.now
-                  behind = threads[hostname_port].has_key?('behind') ? threads[hostname_port]['behind'] : "-"
-                  uptime_short = short_desc_of_second(stats['uptime'])
-                  hit_rate = if stats.has_key?('cmd_get') && stats['cmd_get'] != "0"
-                               cmd_get = stats['cmd_get'].to_f
-                               get_hits = stats['get_hits'].to_f
-                               (get_hits / cmd_get * 100.0).round
-                             else
-                               "-"
-                             end
-                  size =  stats['bytes'] == "0" ? "-" : (stats['bytes'].to_i / 1024 / 1024 / 1024) # gigabyte
-                  stats_data = {
-                    :hostname   => hostname,
-                    :port       => port,
-                    :hostname_port => "#{hostname}:#{port}",
-                    :state      => data['state'],
-                    :role       => data['role'],
-                    :partition  => data['partition'] == "-1" ? "-" : data['partition'],
-                    :balance    => data['balance'],
-                    :items      => stats['curr_items'],
-                    :conn       => stats['curr_connections'],
-                    :behind     => behind,
-                    :hit_rate   => hit_rate,
-                    :size       => size,
-                    :uptime     => stats['uptime'],
-                    :uptime_short => uptime_short,
-                    :version    => stats['version'],
-                    :cmd_get    => stats['cmd_get'],
-                    :cmd_set    => stats['cmd_set'],
-                    :time       => time,
-                  }
-                rescue Errno::ECONNREFUSED => e
-                rescue => e
-                  begin
-                    s.close unless s.nil?
-                  rescue => close_error
-                  end
-                  s = nil
-                end
-                if stats_data.nil?
-                  stats_data = {
-                    :hostname_port => "#{hostname}:#{port}",
-                  }
-                end
-                q.push stats_data
-              end
-              s.close unless s.nil?
-            end # Thread.new
-          end # nodes.each
+              enqueueing_node_stats(q, threads, config, hostname_port, data)
+            end
+          end
 
           query_prev = {} if @qps
 
@@ -144,7 +102,11 @@ module Flare
             interruptible {sleep 1}
           end
 
-          s = Flare::Tools::IndexServer.open(config[:index_server_hostname], config[:index_server_port], config[:timeout])
+          s = Flare::Tools::IndexServer.open(
+            @index_server_entity.host,
+            @index_server_entity.port,
+            @timeout
+          )
           unless s
             error "Couldn't connect to the index server."
             return S_NG
@@ -164,62 +126,39 @@ module Flare
             nodes.each do |k, n|
               max_nodekey_length = k.length if k.length > max_nodekey_length
             end
-            header[0][0] = "%-#{max_nodekey_length}.#{max_nodekey_length}s"
-            format = header.map {|x| x[0]}.join(@delimiter)
-            label = format % header.map{|x| x[1]}.flatten
-            puts label
-            nodes.each do |k, n|
+            table = Table.new
+            add_header_to_table(table, header_configs)
+            nodes.each do |k, node|
               stats_data = queue[k].pop
               next if (args.size > 0 && !args.include?(k))
-              stats_data[:state] = n['state']
-              stats_data[:role] = n['role']
-              stats_data[:partition] = n['partition']
-              stats_data[:balance] = n['balance']
-              stats_data[:behind] = (threads.has_key?(k) || threads[k].has_key?('behind')) ? threads[k]['behind'] : "-"
-              output = [:hostname_port, :state, :role, :partition, :balance, :items,
-                        :conn, :behind, :hit_rate, :size, :uptime_short, :version].map {|x| stats_data[x]}
-              if @qps
-                query = {}
-                query[:query] = stats_data[:cmd_get].to_i+stats_data[:cmd_set].to_i
-                query[:query_r] = stats_data[:cmd_get].to_i
-                query[:query_w] = stats_data[:cmd_set].to_i
-                query[:time] = time = stats_data[:time]
-                if query_prev.has_key?(k)
-                  duration = (time-query_prev[k][:time]).to_f
-                  [:query, :query_r, :query_w].each do |x|
-                    diff = (query[x]-query_prev[k][x]).to_f
-                    qps = if diff > 0 then diff/duration else 0 end
-                    output << qps
-                  end
-                else
-                  output << 0 << 0 << 0
-                end
-                query_prev[k] = query.dup
-              end
-
-              puts format % output
+              behind = (threads.has_key?(k) || threads[k].has_key?('behind')) ? threads[k]['behind'] : "-"
+              r = record(stats_data, node, behind, query_prev, k)
+              add_record_to_table(table, header_configs, r)
             end
             interruptible {
               wait_for_stats
             }
+            puts table.prettify
           end
           s.close
 
           @cont = false
 
           queue.each do |k,q|
-            q.clear
+            q.pop until q.empty?
           end
-          
+
           interruptible {
             worker_threads.each do |t|
               t.join
             end
           }
-          
+
           S_OK
         end
 
+        private
+
         def wait_for_stats
           if @qps || @count > 1
             wait = @wait
@@ -229,7 +168,121 @@ module Flare
             end
           end
         end
-        
+
+        def enqueueing_node_stats(q, threads, config, hostname_port, data)
+          hostname, port = hostname_port.split(":", 2)
+          s = nil
+          while @cont
+            stats_data = nil
+            begin
+              s = Flare::Tools::Stats.open(hostname, data['port'], @timeout)
+              stats = s.stats
+              time = Time.now
+              behind = threads[hostname_port].has_key?('behind') ? threads[hostname_port]['behind'] : "-"
+              uptime_short = short_desc_of_second(stats['uptime'])
+              hit_rate = if stats.has_key?('cmd_get') && stats['cmd_get'] != "0"
+                           cmd_get = stats['cmd_get'].to_f
+                           get_hits = stats['get_hits'].to_f
+                           (get_hits / cmd_get * 100.0).round
+                         else
+                           "-"
+                         end
+              size =  stats['bytes'] == "0" ? "-" : (stats['bytes'].to_i / 1024 / 1024 / 1024) # gigabyte
+              stats_data = {
+                :hostname   => hostname,
+                :port       => port,
+                :hostname_port => "#{hostname}:#{port}",
+                :state      => data['state'],
+                :role       => data['role'],
+                :partition  => data['partition'] == "-1" ? "-" : data['partition'],
+                :balance    => data['balance'],
+                :items      => stats['curr_items'],
+                :conn       => stats['curr_connections'],
+                :behind     => behind,
+                :hit_rate   => hit_rate,
+                :size       => size,
+                :uptime     => stats['uptime'],
+                :uptime_short => uptime_short,
+                :version    => stats['version'],
+                :cmd_get    => stats['cmd_get'],
+                :cmd_set    => stats['cmd_set'],
+                :time       => time,
+              }
+            rescue Errno::ECONNREFUSED => e
+            rescue => e
+              begin
+                s.close unless s.nil?
+              rescue => close_error
+                error "Socket close failed: #{close_error.inspect}"
+              end
+              s = nil
+            end
+            if stats_data.nil?
+              stats_data = {
+                :hostname_port => "#{hostname}:#{port}",
+              }
+            end
+            q.push stats_data
+          end
+          s.close unless s.nil?
+        end
+
+        def add_header_to_table(table, header_configs)
+          row = Row.new(:separator => @delimiter)
+          header_configs.each do |header_config|
+            row.add_column(Column.new(header_config[0]))
+          end
+          table.add_row(row)
+        end
+
+        def add_record_to_table(table, header_configs, record)
+          row = Row.new(:separator => @delimiter)
+          header_configs.each_with_index do |header_config, index|
+            row.add_column(Column.new(record[index], header_config[1]))
+          end
+          table.add_row(row)
+        end
+
+        # You can override this method to extend stats infos.
+        def record(stats_data, node, behind, query_prev, index)
+          stats_data[:state] = node['state']
+          stats_data[:role] = node['role']
+          stats_data[:partition] = node['partition']
+          stats_data[:balance] = node['balance']
+          stats_data[:behind] = behind
+          output = [:hostname_port, :state, :role, :partition, :balance, :items,
+                    :conn, :behind, :hit_rate, :size, :uptime_short, :version].map {|x| stats_data[x]}
+          if @qps
+            query = {}
+            query[:query] = stats_data[:cmd_get].to_i+stats_data[:cmd_set].to_i
+            query[:query_r] = stats_data[:cmd_get].to_i
+            query[:query_w] = stats_data[:cmd_set].to_i
+            query[:time] = time = stats_data[:time]
+            if query_prev.has_key?(index)
+              duration = (time-query_prev[index][:time]).to_f
+              [:query, :query_r, :query_w].each do |x|
+                diff = (query[x]-query_prev[index][x]).to_f
+                qps = if diff > 0
+                        sprintf("%.1f", diff/duration)
+                      else
+                        '-'
+                      end
+                output << qps
+              end
+            else
+              output << '-' << '-' << '-'
+            end
+            query_prev[index] = query.dup
+          end
+          output
+        end
+
+        # You can override this method to extend stats infos.
+        def header_configs
+          configs = Marshal.load(Marshal.dump(HeaderConfigs))
+          configs += Marshal.load(Marshal.dump(HeaderConfigQpss)) if @qps
+          configs
+        end
       end
     end
   end