module Roma::Command::SystemCommandReceiver

Public Instance Methods

ev_add_latency_avg_calc_cmd(s) click to toggle source

add_calc_latency_average <command1> <command2>.…

    # File lib/roma/command/sys_command_receiver.rb
598 def ev_add_latency_avg_calc_cmd(s)
599   #check argument
600   if s.length < 2
601     return send_data("CLIENT_ERROR number of arguments (0 for 2)\r\n")
602   end
603   #check support commands
604   s.each_index {|idx|
605     if idx >= 1 && (!Event::Handler::ev_list.include?(s[idx]) || Event::Handler::system_commands.include?(s[idx]))
606        return send_data("NOT SUPPORT [#{s[idx]}] command\r\n")
607     end
608     if idx >= 1 && @stats.latency_check_cmd.include?(s[idx])
609       return send_data("ALREADY SET [#{s[idx]}] command\r\n")
610     end
611   }
612 
613   arg ="radd_latency_avg_calc_cmd"
614   s.each_index {|idx|
615     arg += " #{s[idx]}" if idx>=1
616   }
617   res = broadcast_cmd("#{arg}\r\n")
618 
619   s.each_index {|idx|
620     @stats.latency_check_cmd.push(s[idx]) if idx >= 1
621   }
622   res[@stats.ap_str] = "SET"
623   send_data("#{res}\r\n")
624 end
ev_balse(s) click to toggle source

balse [reason]

   # File lib/roma/command/sys_command_receiver.rb
 9 def ev_balse(s)
10   send_data("Are you sure?(yes/no)\r\n")
11   if gets != "yes\r\n"
12     close_connection_after_writing
13     return
14   end
15 
16   if s.length == 2
17     @log.info("Receive a balse #{s[1]}")
18   else
19     @log.info("Receive a balse command.")
20   end
21   @rttable.enabled_failover = false
22   res = broadcast_cmd("rbalse\r\n")
23   res[@stats.ap_str] = "BYE"
24   send_data("#{res.inspect}\r\n")
25   close_connection_after_writing
26   @stop_event_loop = true
27 end
ev_chg_latency_avg_calc_time_count(s) click to toggle source

chg_calc_latency_average_denominator <count>

    # File lib/roma/command/sys_command_receiver.rb
692 def ev_chg_latency_avg_calc_time_count(s)
693   #check argument
694   if s.length != 2
695     return send_data("CLIENT_ERROR number of arguments (0 for 2)\r\n")
696   elsif s[1] != "nil" && s[1].to_i < 1
697     return send_data("s[1].class = #{s[1].class}\r\n")
698     return send_data("<count> must be greater than zero or nil[DEACTIVATE]\r\n")
699   end
700 
701   res = broadcast_cmd("rchg_latency_avg_calc_time_count #{s[1]}\r\n")
702 
703   if s[1] != "nil"
704     @stats.latency_check_time_count = s[1].to_i
705     @stats.latency_log = true
706   elsif s[1] == "nil"
707     @stats.latency_check_time_count = false
708     @stats.latency_log = false
709   end
710   res[@stats.ap_str] = "CHANGED"
711   send_data("#{res}\r\n")
712 end
ev_dcnice(s) click to toggle source

dcnice command is setting priority for a data-copy thread. a niceness of 1 is the highest priority and 5 is the lowest priority. dcnice <priority:1 to 5>

    # File lib/roma/command/sys_command_receiver.rb
310 def ev_dcnice(s)
311   if s.length < 2
312     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
313   end
314   res = broadcast_cmd("rdcnice #{s[1]}\r\n")
315   res[@stats.ap_str] = dcnice(s[1].to_i)
316   send_data("#{res}\r\n")
317 end
ev_del_latency_avg_calc_cmd(s) click to toggle source

del_calc_latency_average <command1> <command2>.…

    # File lib/roma/command/sys_command_receiver.rb
646 def ev_del_latency_avg_calc_cmd(s)
647   #check argument
648   if s.length < 2
649     return send_data("CLIENT_ERROR number of arguments (0 for 2)\r\n")
650   end
651   
652   #check support commands
653   s.each_index {|idx|
654     if idx >= 1 && !@stats.latency_check_cmd.include?(s[idx])
655       return send_data("[#{s[idx]}] command is NOT set\r\n")
656     end
657   }
658 
659   arg ="rdel_latency_avg_calc_cmd"
660   s.each_index {|idx|
661     arg += " #{s[idx]}" if idx>=1
662   }
663   res = broadcast_cmd("#{arg}\r\n")
664 
665   s.each_index {|idx|
666     @stats.latency_check_cmd.delete(s[idx]) if idx >= 1
667     @stats.latency_data.delete(s[idx]) if idx >= 1
668   }
669   res[@stats.ap_str] = "DELETED"
670   send_data("#{res}\r\n")
671 end
ev_forcedly_start(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
443 def ev_forcedly_start(s)
444   @log.info("ROMA forcedly start.")
445   AsyncProcess::queue.clear
446   @rttable.enabled_failover = true
447   Command::Receiver::mk_evlist
448   $roma.startup = false
449   send_data("STARTED\r\n")
450 end
ev_out(s) click to toggle source

out <key> <vn>

    # File lib/roma/command/sys_command_receiver.rb
372 def ev_out(s)
373   key,hname = s[1].split("\e")
374   hname ||= @defhash
375   if s.length >= 3
376     vn = s[2].to_i
377   else
378     d = Digest::SHA1.hexdigest(key).hex % @rttable.hbits
379     vn = @rttable.get_vnode_id(d)
380   end
381   res = @storages[hname].out(vn, key, 0)
382   @stats.out_message_count += 1
383   unless res
384     return send_data("NOT_DELETED\r\n")
385   end
386   send_data("DELETED\r\n")
387 end
ev_quit(s) click to toggle source

quit

    # File lib/roma/command/sys_command_receiver.rb
103 def ev_quit(s)
104   close_connection
105 end
ev_radd_latency_avg_calc_cmd(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
626 def ev_radd_latency_avg_calc_cmd(s)
627   if s.length < 2
628     return send_data("CLIENT_ERROR number of arguments (0 for 2)\r\n")
629   end
630   s.each_index {|idx|
631     if idx >= 2 && (!Event::Handler::ev_list.include?(s[idx]) || Event::Handler::system_commands.include?(s[idx]))
632        return send_data("NOT SUPPORT [#{s[idx]}] command\r\n")
633     end
634     if idx >= 1 && @stats.latency_check_cmd.include?(s[idx])
635       return send_data("ALREADY SET [#{s[idx]}] command\r\n")
636     end
637   }
638 
639   s.each_index {|idx|
640     @stats.latency_check_cmd.push(s[idx]) if idx >= 1
641   }
642   send_data("SET\r\n")
643 end
ev_rbalse(s) click to toggle source

rbalse [reason]

   # File lib/roma/command/sys_command_receiver.rb
30 def ev_rbalse(s)
31   if s.length == 2
32     @log.info("Receive a rbalse #{s[1]}")
33   else
34     @log.info("Receive a rbalse command.")
35   end
36   @rttable.enabled_failover = false
37   send_data("BYE\r\n")
38   close_connection_after_writing
39   @stop_event_loop = true
40 end
ev_rchg_latency_avg_calc_time_count(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
714 def ev_rchg_latency_avg_calc_time_count(s)
715   if s.length != 2
716     return send_data("CLIENT_ERROR number of arguments (0 for 2)\r\n")
717   elsif s[1] != "nil" && s[1].to_i < 1
718     return send_data("<count> must be greater than zero\r\n")
719   end
720 
721   if s[1] != "nil"
722     @stats.latency_check_time_count = s[1].to_i
723     @stats.latency_log = true
724   elsif s[1] == "nil"
725     @stats.latency_check_time_count = false
726     @stats.latency_log = false
727   end
728   @stats.latency_check_time_count = s[1].to_i
729   send_data("CHANGED\r\n")
730 end
ev_rdcnice(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
319 def ev_rdcnice(s)
320   if s.length < 2
321     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
322   end
323 
324   send_data("#{dcnice(s[1].to_i)}\r\n")
325 end
ev_rdel_latency_avg_calc_cmd(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
673 def ev_rdel_latency_avg_calc_cmd(s)
674   if s.length < 2
675     return send_data("CLIENT_ERROR number of arguments (0 for 2)\r\n")
676   end
677 
678   # reset
679   s.each_index {|idx|
680     if idx >= 1 && !@stats.latency_check_cmd.include?(s[idx])
681       return send_data("[#{s[idx]}] command is NOT set\r\n")
682     end
683   }
684   s.each_index {|idx|
685     @stats.latency_check_cmd.delete(s[idx]) if idx >= 1
686     @stats.latency_data.delete(s[idx]) if idx >= 1
687   }
688   send_data("DELETED\r\n")
689 end
ev_restart(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
327 def ev_restart(s)
328   res = broadcast_cmd("rrestart\r\n")
329   $roma.eventloop = true
330   @rttable.enabled_failover = false
331   Messaging::ConPool.instance.close_all
332   Event::EMConPool::instance.close_all
333   EventMachine::stop_event_loop
334   res[@stats.ap_str] = "RESTARTED"
335   send_data("#{res}\r\n")
336 end
ev_rrestart(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
338 def ev_rrestart(s)
339   $roma.eventloop = true
340   @rttable.enabled_failover = false
341   Messaging::ConPool.instance.close_all
342   Event::EMConPool::instance.close_all
343   EventMachine::stop_event_loop
344   send_data("RESTARTED\r\n")
345 end
ev_rset(s) click to toggle source

rset <key> <hash value> <timelimit> <length> “set” means “store this data”. <command name> <key> <digest> <exptime> <bytes> [noreply]rn <data block>rn

    # File lib/roma/command/sys_command_receiver.rb
393 def ev_rset(s)
394   key,hname = s[1].split("\e")
395   hname ||= @defhash
396   d = s[2].to_i
397   d = Digest::SHA1.hexdigest(key).hex % @rttable.hbits if d == 0
398   data = read_bytes(s[5].to_i)
399   read_bytes(2)
400   vn = @rttable.get_vnode_id(d)
401   unless @storages.key?(hname)
402     send_data("SERVER_ERROR #{hname} does not exists.\r\n")
403     return
404   end
405   if @storages[hname].rset(vn, key, d, s[3].to_i, s[4].to_i, data)
406     send_data("STORED\r\n")
407   else
408     @log.error("rset NOT_STORED:#{@storages[hname].error_message} #{vn} #{s[1]} #{d} #{s[3]} #{s[4]}")
409     send_data("NOT_STORED\r\n")
410   end
411   @stats.redundant_count += 1
412 end
ev_rset_accepted_connection_expire_time(s) click to toggle source

rset_accepted_connection_expire_time <sec>

    # File lib/roma/command/sys_command_receiver.rb
830 def ev_rset_accepted_connection_expire_time(s)
831   if s.length != 2
832     return send_data("CLIENT_ERROR number of arguments\r\n")
833   end
834   Event::Handler::connection_expire_time = s[1].to_i
835   send_data("STORED\r\n")
836 end
ev_rset_connection_pool_expire_time(s) click to toggle source

rset_connection_pool_expire_time <sec>

    # File lib/roma/command/sys_command_receiver.rb
852 def ev_rset_connection_pool_expire_time(s)
853   if s.length != 2
854     return send_data("CLIENT_ERROR number of arguments\r\n")
855   end
856   Messaging::ConPool.instance.expire_time = s[1].to_i
857   send_data("STORED\r\n")
858 end
ev_rset_connection_pool_maxlength(s) click to toggle source

rset_connection_pool_maxlength <length>

    # File lib/roma/command/sys_command_receiver.rb
775 def ev_rset_connection_pool_maxlength(s)
776   if s.length != 2
777     return send_data("CLIENT_ERROR number of arguments\r\n")
778   end
779   if s[1].to_i < 1
780     return send_data("CLIENT_ERROR length must be greater than zero\r\n")
781   end
782 
783   Messaging::ConPool.instance.maxlength = s[1].to_i
784   send_data("STORED\r\n")
785 end
ev_rset_continuous_limit(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
747 def ev_rset_continuous_limit(s)
748   if s.length < 2
749     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
750   end
751   if Event::Handler.set_ccl(s[1])
752     send_data("STORED\r\n")
753   else
754     send_data("NOT_STORED\r\n")
755   end
756 end
ev_rset_descriptor_table_size(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
508 def ev_rset_descriptor_table_size(s)
509   if s.length != 2
510     return send_data("CLIENT_ERROR number of arguments\r\n")
511   elsif s[1].to_i < 1024
512     return send_data("CLIENT_ERROR length must be greater than 1024\r\n")
513   end
514 
515   EM.set_descriptor_table_size(s[1].to_i)
516   send_data("STORED\r\n")
517 end
ev_rset_emconnection_pool_expire_time(s) click to toggle source

rset_emconnection_pool_expire_time <sec>

    # File lib/roma/command/sys_command_receiver.rb
878 def ev_rset_emconnection_pool_expire_time(s)
879   if s.length != 2
880     return send_data("CLIENT_ERROR number of arguments\r\n")
881   end
882   Event::EMConPool::instance.expire_time = s[1].to_i
883   send_data("STORED\r\n")
884 end
ev_rset_emconnection_pool_maxlength(s) click to toggle source

rset_connection_pool_maxlength <length>

    # File lib/roma/command/sys_command_receiver.rb
804 def ev_rset_emconnection_pool_maxlength(s)
805   if s.length != 2
806     return send_data("CLIENT_ERROR number of arguments\r\n")
807   end
808   if s[1].to_i < 1
809     return send_data("CLIENT_ERROR length must be greater than zero\r\n")
810   end
811 
812   Event::EMConPool.instance.maxlength = s[1].to_i
813   send_data("STORED\r\n")
814 end
ev_rset_gui_last_snapshot(s) click to toggle source

rset_gui_last_snapshot(s)

     # File lib/roma/command/sys_command_receiver.rb
1228 def ev_rset_gui_last_snapshot(s)
1229   if s.length != 2
1230     return send_data("CLIENT_ERROR number of arguments\n\r")
1231   end
1232   if s[1] !~ /^\d+\/\d+\/\d+T\d+:\d+:\d+$/
1233     return send_data("CLIENT_ERROR format is [%Y/%m/%dT%H:%M:%S]\r\n")
1234   end
1235   @stats.gui_last_snapshot = s[1]
1236   send_data("PUSHED\r\n")
1237 end
ev_rset_hilatency_warn_time(s) click to toggle source

rset_hilatency_warn_time <sec>

    # File lib/roma/command/sys_command_receiver.rb
943 def ev_rset_hilatency_warn_time(s)
944   if s.length != 2
945     return send_data("CLIENT_ERROR number of arguments\r\n")
946   end
947   if s[1].to_f <= 0
948     return send_data("CLIENT_ERROR time value must be lager than 0\r\n")
949   end
950   @stats.hilatency_warn_time = s[1].to_f
951   send_data("STORED\r\n")
952 end
ev_rset_latency_avg_calc_rule(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
564 def ev_rset_latency_avg_calc_rule(s)
565   if /^on$|^off$/ !~ s[1]
566     return send_data("CLIENT_ERROR argument 1: please input \"on\" or \"off\"\r\n")
567   elsif s[1] == "on" && (s.length <= 3 || s[2].to_i < 1)
568     return send_data("CLIENT_ERROR number of arguments (0 for 3) and <count> must be greater than zero\r\n")
569   elsif s[1] == "off" && !(s.length == 2)
570     return send_data("CLIENT_ERROR number of arguments (0 for 1, or more 3)\r\n")
571   end
572 
573   s.each_index {|idx|
574     if idx >= 3 && (!Event::Handler::ev_list.include?(s[idx]) || Event::Handler::system_commands.include?(s[idx]))
575        return send_data("NOT SUPPORT [#{s[idx]}] command\r\n")
576     end
577   }
578 
579   if s[1] =="on"
580     @latency_data = Hash.new { |hash,key| hash[key] = {}}
581     @stats.latency_check_cmd = []
582     s.each_index {|idx|
583       @stats.latency_check_cmd.push(s[idx]) if idx >= 3
584     }
585     @stats.latency_check_time_count = s[2].to_i
586     @stats.latency_log = true
587     send_data("ACTIVATED\r\n")
588   elsif s[1] =="off"
589     @latency_data = Hash.new { |hash,key| hash[key] = {}}
590     @stats.latency_check_cmd = []
591     @stats.latency_check_time_count = false
592     @stats.latency_log = false
593     send_data("DEACTIVATED\r\n")
594   end
595 end
ev_rset_log_shift_age(s) click to toggle source
     # File lib/roma/command/sys_command_receiver.rb
1305 def ev_rset_log_shift_age(s)
1306   if s.length != 2
1307     return send_data("CLIENT_ERROR number of arguments\r\n")
1308   elsif s[1].to_i < 1 && !['0', 'min', 'hour', 'daily', 'weekly', 'monthly'].include?(s[1])
1309     return send_data("CLIENT_ERROR invalid arguments\r\n")
1310   end
1311 
1312   if s[1].to_i > 0 || s[1] == '0'
1313     @log.set_log_shift_age(s[1].to_i)
1314     @stats.log_shift_age = s[1].to_i
1315   else
1316     @log.set_log_shift_age(s[1])
1317     @stats.log_shift_age = s[1]
1318   end
1319   send_data("STORED\r\n")
1320 end
ev_rset_log_shift_size(s) click to toggle source
     # File lib/roma/command/sys_command_receiver.rb
1272 def ev_rset_log_shift_size(s)
1273   if s.length != 2
1274     return send_data("CLIENT_ERROR number of arguments\r\n")
1275   elsif s[1].to_i < 1
1276     return send_data("CLIENT_ERROR length must be greater than zero\r\n")
1277   end
1278   
1279   @log.set_log_shift_size(s[1].to_i)
1280   @stats.log_shift_size = s[1].to_i
1281   send_data("STORED\r\n")
1282 end
ev_rset_reqpushv_timeout_count(s) click to toggle source

ev_rset_reqpushv_timeout_count <sec>

     # File lib/roma/command/sys_command_receiver.rb
1023 def ev_rset_reqpushv_timeout_count(s)
1024   if s.length != 2
1025     return send_data("CLIENT_ERROR number of arguments\n\r")
1026   end
1027   if s[1].to_i <= 0
1028     return send_data("CLIENT_ERROR time value must be lager than 0\r\n")
1029   end
1030   @stats.reqpushv_timeout_count = s[1].to_i
1031   send_data("STORED\r\n")
1032 end
ev_rset_routing_trans_timeout(s) click to toggle source

rset_set_routing_trans_timeout <sec>

    # File lib/roma/command/sys_command_receiver.rb
970 def ev_rset_routing_trans_timeout(s)
971   if s.length != 2
972     return send_data("CLIENT_ERROR number of arguments\n\r")
973   end
974   if s[1].to_f <= 0
975     return send_data("CLIENT_ERROR time value must be lager than 0\r\n")
976   end
977   @stats.routing_trans_timeout = s[1].to_f
978 
979   send_data("STORED\r\n")
980 end
ev_rset_spushv_klength_warn(s) click to toggle source

rset_set_spushv_klength_warn <byte>

     # File lib/roma/command/sys_command_receiver.rb
1049 def ev_rset_spushv_klength_warn(s)
1050   if s.length != 2   
1051     return send_data("CLIENT_ERROR number of arguments\n\r")
1052   end
1053   if s[1].to_i <= 0
1054     return send_data("CLIENT_ERROR size value must be larger than 0 \r\n")
1055   end 
1056   @stats.spushv_klength_warn = s[1].to_i 
1057   send_data("STORED\r\n") 
1058 end
ev_rset_spushv_read_timeout(s) click to toggle source

rset_spushv_read_timeout <sec>

     # File lib/roma/command/sys_command_receiver.rb
 997 def ev_rset_spushv_read_timeout(s)
 998   if s.length != 2
 999     return send_data("CLIENT_ERROR number of arguments\n\r")
1000   end
1001   if s[1].to_i <= 0
1002     return send_data("CLIENT_ERROR time value must be lager than 0\r\n")
1003   end
1004   @stats.spushv_read_timeout = s[1].to_i
1005   send_data("STORED\r\n")
1006 end
ev_rset_spushv_vlength_warn(s) click to toggle source

rset_set_spushv_vlength_warn <byte>

     # File lib/roma/command/sys_command_receiver.rb
1075 def ev_rset_spushv_vlength_warn(s)
1076   if s.length != 2   
1077     return send_data("CLIENT_ERROR number of arguments\n\r")
1078   end
1079   if s[1].to_i <= 0
1080     return send_data("CLIENT_ERROR size value must be larger than 0\r\n")
1081   end 
1082   @stats.spushv_vlength_warn = s[1].to_i 
1083   send_data("STORED\r\n") 
1084 end
ev_rset_wb_shift_size(s) click to toggle source
     # File lib/roma/command/sys_command_receiver.rb
1142 def ev_rset_wb_shift_size(s)
1143   if s.length != 2
1144     return send_data("CLIENT_ERROR number of arguments\r\n")
1145   elsif s[1].to_i < 1
1146     return send_data("CLIENT_ERROR length must be greater than zero\r\n")
1147   end
1148 
1149   $roma.wb_writer.shift_size = s[1].to_i
1150   send_data("STORED\r\n")
1151 end
ev_rshutdown(s) click to toggle source

rshutdown [reason]

   # File lib/roma/command/sys_command_receiver.rb
64 def ev_rshutdown(s)
65   if s.length == 2
66     @log.info("Receive a rshutdown #{s[1]}")
67   else
68     @log.info("Receive a rshutdown command.")
69   end
70   @rttable.enabled_failover = false
71   send_data("BYE\r\n")
72   close_connection_after_writing
73   @stop_event_loop = true
74 end
ev_rswitch_dns_caching(s) click to toggle source

rswitch_dns_caching <on|off|true|false>

    # File lib/roma/command/sys_command_receiver.rb
908 def ev_rswitch_dns_caching(s)
909   if s.length != 2
910     return send_data("CLIENT_ERROR number of arguments\r\n")
911   end
912 
913   if s[1] == 'on' || s[1] == 'true'
914     DNSCache.instance.enable_dns_cache
915     @log.info("DNS caching enabled")
916     return send_data("ENABLED\r\n")
917   elsif s[1] == 'off' || s[1] == 'false'
918     DNSCache.instance.disable_dns_cache
919     @log.info("DNS caching disabled")
920     return send_data("DISABLED\r\n")
921   else
922     send_data("NOTSWITCHED\r\n")
923   end
924 end
ev_rswitch_failover(s) click to toggle source

rswitch_failover <on|off>

    # File lib/roma/command/sys_command_receiver.rb
475 def ev_rswitch_failover(s)
476   if s.length != 2
477     return send_data("CLIENT_ERROR number of arguments\r\n")
478   end
479   if s[1] == 'on'
480     Messaging::ConPool.instance.close_all
481     Event::EMConPool::instance.close_all
482     @rttable.enabled_failover = true
483     @log.info("failover enabled")
484     return send_data("ENABLED\r\n")
485   elsif s[1] == 'off'
486     @rttable.enabled_failover = false
487     @log.info("failover disabled")
488     return send_data("DISABLED\r\n")
489   else
490     send_data("NOTSWITCHED\r\n")
491   end
492 end
ev_rswitch_replication(s) click to toggle source

rswitch_replication <true|false> [nid] [copy target]

    # File lib/roma/command/sys_command_receiver.rb
271 def ev_rswitch_replication(s)
272   unless s.length.between?(2, 4)
273     return send_data("CLIENT_ERROR number of arguments\n\r")
274   end
275   unless s[1] =~ /^(true|false)$/
276     return send_data("CLIENT_ERROR value must be true or false\n\r")
277   end
278   if s[3] && s[3] != 'all'
279     return send_data("CLIENT_ERROR [copy target] must be all or nil\r\n")
280   end
281 
282   timeout(1){
283     case s[1]
284     when 'true'
285       $roma.cr_writer.update_mklhash(s[2])
286       $roma.cr_writer.update_nodelist(s[2])
287       $roma.cr_writer.update_rttable(s[2])
288       $roma.cr_writer.run_replication = true
289       if s[3] == 'all'
290         $roma.cr_writer.run_existing_data_replication = true
291         Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_replicate_existing_data_process', [$roma.cr_writer.replica_rttable]))
292       end
293       send_data("ACTIVATED\r\n")
294     when 'false'
295       $roma.cr_writer.replica_mklhash = nil
296       $roma.cr_writer.replica_nodelist = []
297       $roma.cr_writer.replica_rttable = nil
298       $roma.cr_writer.run_replication = false
299       $roma.cr_writer.run_existing_data_replication = false
300       send_data("DEACTIVATED\r\n")
301     end
302   }
303 rescue => e
304   send_data("#{e.class}: #{e}\r\n")
305 end
ev_rwb_command_map(s) click to toggle source
     # File lib/roma/command/sys_command_receiver.rb
1110 def ev_rwb_command_map(s)
1111   if s.length < 2
1112     return send_data("CLIENT_ERROR number of arguments\r\n")
1113   end
1114   map = {}
1115   cmd = s[1..-1].join
1116   if cmd =~ /^\{(.+)\}$/
1117     $1.split(',').each do |kv|
1118       k, v = kv.split('=>')
1119       map[k[1..-1].to_sym] = v.to_i if v && k[0]==':'
1120     end
1121     @stats.wb_command_map = map
1122     send_data("#{map}\r\n")
1123   else
1124     send_data("CLIENT_ERROR hash string parse error\r\n")
1125   end        
1126 end
ev_rwritebehind_get_current_file(s) click to toggle source

rwritebehind_get_current_file [hash_name]

    # File lib/roma/command/sys_command_receiver.rb
215 def ev_rwritebehind_get_current_file(s)
216   if s.length < 2
217     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
218   end
219   ret = $roma.wb_get_current_file_path(s[1])
220   if ret
221     send_data("#{ret}\r\n")
222   else
223     send_data("NOT_OPEND\r\n")
224   end
225 end
ev_rwritebehind_get_path(s) click to toggle source

rwritebehind_get_path [hash_name]

    # File lib/roma/command/sys_command_receiver.rb
189 def ev_rwritebehind_get_path(s)
190   if s.length < 2
191     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
192   end
193   
194   ret = $roma.wb_get_path(s[1])
195   send_data("#{ret}\r\n")
196 end
ev_rwritebehind_rotate(s) click to toggle source

rwritebehind_rotate [hash_name]

    # File lib/roma/command/sys_command_receiver.rb
164 def ev_rwritebehind_rotate(s)
165   if s.length < 2
166     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
167   end
168   if $roma.wb_rotate(s[1])
169     send_data("ROTATED\r\n")
170   else
171     send_data("NOT_OPEND\r\n")
172   end
173 end
ev_rzset(s) click to toggle source

<command name> <key> <digest> <exptime> <bytes> [noreply]rn <compressed data block>rn

    # File lib/roma/command/sys_command_receiver.rb
416       def ev_rzset(s)
417         key,hname = s[1].split("\e")
418         hname ||= @defhash
419         d = s[2].to_i
420         d = Digest::SHA1.hexdigest(key).hex % @rttable.hbits if d == 0
421         zdata = read_bytes(s[5].to_i)
422         read_bytes(2)
423         vn = @rttable.get_vnode_id(d)
424         unless @storages.key?(hname)
425           send_data("SERVER_ERROR #{hname} does not exists.\r\n")
426           return
427         end
428 
429         data = Zlib::Inflate.inflate(zdata)
430 # @log.debug("data = #{data}")
431         if @storages[hname].rset(vn, key, d, s[3].to_i, s[4].to_i, data)
432           send_data("STORED\r\n")
433         else
434           @log.error("rzset NOT_STORED:#{@storages[hname].error_message} #{vn} #{s[1]} #{d} #{s[3]} #{s[4]}")
435           send_data("NOT_STORED\r\n")
436         end
437         @stats.redundant_count += 1
438       rescue Zlib::DataError => e
439         @log.error("rzset NOT_STORED:#{e} #{vn} #{s[1]} #{d} #{s[3]} #{s[4]}")
440         send_data("NOT_STORED\r\n")
441       end
ev_set_accepted_connection_expire_time(s) click to toggle source

set_accepted_connection_expire_time <sec> set to expired time(sec) for accepted connections

    # File lib/roma/command/sys_command_receiver.rb
818 def ev_set_accepted_connection_expire_time(s)
819   if s.length != 2
820     return send_data("CLIENT_ERROR number of arguments\r\n")
821   end
822 
823   res = broadcast_cmd("rset_accepted_connection_expire_time #{s[1]}\r\n")
824   Event::Handler::connection_expire_time = s[1].to_i
825   res[@stats.ap_str] = "STORED"
826   send_data("#{res}\r\n")
827 end
ev_set_cleanup_regexp(s) click to toggle source

set_cleanup_regexp <regexp>

     # File lib/roma/command/sys_command_receiver.rb
1240 def ev_set_cleanup_regexp(s)
1241   if s.length != 2
1242     return send_data("CLIENT_ERROR number of arguments #{s.length-1} to 1\r\n")
1243   end
1244 
1245   # failover check
1246   unless @rttable.enabled_failover
1247     return send_data("CLIENT_ERROR failover disable now!!\r\n")
1248   end
1249 
1250   @storages.each{|hname,st|
1251     st.cleanup_regexp = s[1]
1252     st.stop_clean_up
1253     send_data("STORED\r\n")
1254   }
1255 end
ev_set_connection_pool_expire_time(s) click to toggle source

set_connection_pool_expire_time <sec> set to expired time(sec) for connection_pool expire time

    # File lib/roma/command/sys_command_receiver.rb
840 def ev_set_connection_pool_expire_time(s)
841   if s.length != 2
842     return send_data("CLIENT_ERROR number of arguments\r\n")
843   end
844 
845   res = broadcast_cmd("rset_connection_pool_expire_time #{s[1]}\r\n")
846   Messaging::ConPool.instance.expire_time = s[1].to_i
847   res[@stats.ap_str] = "STORED"
848   send_data("#{res}\r\n")
849 end
ev_set_connection_pool_maxlength(s) click to toggle source

set_connection_pool_maxlength <length> set to max length of the connection pool

    # File lib/roma/command/sys_command_receiver.rb
760 def ev_set_connection_pool_maxlength(s)
761   if s.length != 2
762     return send_data("CLIENT_ERROR number of arguments\r\n")
763   end
764   if s[1].to_i < 1
765     return send_data("CLIENT_ERROR length must be greater than zero\r\n")
766   end
767 
768   res = broadcast_cmd("rset_connection_pool_maxlength #{s[1]}\r\n")
769   Messaging::ConPool.instance.maxlength = s[1].to_i
770   res[@stats.ap_str] = "STORED"
771   send_data("#{res}\r\n")
772 end
ev_set_continuous_limit(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
732 def ev_set_continuous_limit(s)
733   if s.length < 2
734     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
735   end
736 
737   res = broadcast_cmd("rset_continuous_limit #{s[1]}\r\n")
738 
739   if Event::Handler.set_ccl(s[1])
740     res[@stats.ap_str] = "STORED"
741   else
742     res[@stats.ap_str] = "NOT_STORED"
743   end
744   send_data("#{res}\r\n")
745 end
ev_set_descriptor_table_size(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
494 def ev_set_descriptor_table_size(s)
495   if s.length != 2
496     return send_data("CLIENT_ERROR number of arguments\r\n")
497   elsif s[1].to_i < 1024
498     return send_data("CLIENT_ERROR length must be greater than 1024\r\n")
499   end
500 
501   res = broadcast_cmd("rset_descriptor_table_size #{s[1]}\r\n")
502 
503   EM.set_descriptor_table_size(s[1].to_i)
504   res[@stats.ap_str] = "STORED"
505   send_data("#{res}\r\n")
506 end
ev_set_emconnection_pool_expire_time(s) click to toggle source

set_emconnection_pool_expire_time <sec>

    # File lib/roma/command/sys_command_receiver.rb
861 def ev_set_emconnection_pool_expire_time(s)
862   # chcking s incude command and value (NOT check digit)
863   if s.length != 2
864     return send_data("CLIENT_ERROR number of arguments\r\n")
865   end
866 
867   #if ARGV is 0, expire time become infinity(NOT happen expire)
868   if s[1].to_i == 0
869     s[1] = "2147483647"
870   end
871   res = broadcast_cmd("rset_emconnection_pool_expire_time #{s[1]}\r\n")
872   Event::EMConPool::instance.expire_time = s[1].to_i
873   res[@stats.ap_str] = "STORED"
874   send_data("#{res}\r\n")
875 end
ev_set_emconnection_pool_maxlength(s) click to toggle source

set_connection_pool_maxlength <length> set to max length of the connection pool

    # File lib/roma/command/sys_command_receiver.rb
789 def ev_set_emconnection_pool_maxlength(s)
790   if s.length != 2
791     return send_data("CLIENT_ERROR number of arguments\r\n")
792   end
793   if s[1].to_i < 1
794     return send_data("CLIENT_ERROR length must be greater than zero\r\n")
795   end
796 
797   res = broadcast_cmd("rset_emconnection_pool_maxlength #{s[1]}\r\n")
798   Event::EMConPool.instance.maxlength = s[1].to_i
799   res[@stats.ap_str] = "STORED"
800   send_data("#{res}\r\n")
801 end
ev_set_gui_last_snapshot(s) click to toggle source

set_gui_last_snapshot_date [%Y/%m/%d %H:%M:%S]

     # File lib/roma/command/sys_command_receiver.rb
1214 def ev_set_gui_last_snapshot(s)
1215   if s.length != 2
1216     return send_data("CLIENT_ERROR number of arguments\n\r")
1217   end
1218   if s[1] !~ /^\d+\/\d+\/\d+T\d+:\d+:\d+$/
1219     return send_data("CLIENT_ERROR format is [%Y/%m/%dT%H:%M:%S]\r\n")
1220   end
1221   res = broadcast_cmd("rset_gui_last_snapshot #{s[1]}\r\n")
1222   @stats.gui_last_snapshot = s[1]
1223   res[@stats.ap_str] = "PUSHED"
1224   send_data("#{res}\r\n")
1225 end
ev_set_gui_run_snapshot(s) click to toggle source

set_gui_run_snapshot [true|false]

     # File lib/roma/command/sys_command_receiver.rb
1196 def ev_set_gui_run_snapshot(s)
1197   if s.length != 2
1198     return send_data("CLIENT_ERROR number of arguments\n\r")
1199   end
1200 
1201   case s[1]
1202   when 'true'
1203     @stats.gui_run_snapshot = true
1204     send_data("STORED\r\n")
1205   when 'false'
1206     @stats.gui_run_snapshot = false
1207     send_data("STORED\r\n")
1208   else
1209     return send_data("CLIENT_ERROR value must be true or false\r\n")
1210   end
1211 end
ev_set_hilatency_warn_time(s) click to toggle source

set_hilatency_warn_time <sec> set to threshold of warn message into a log when hilatency occured in a command.

    # File lib/roma/command/sys_command_receiver.rb
928 def ev_set_hilatency_warn_time(s)
929   if s.length != 2
930     return send_data("CLIENT_ERROR number of arguments\r\n")
931   end
932   if s[1].to_f <= 0
933     return send_data("CLIENT_ERROR time value must be lager than 0\r\n")
934   end
935 
936   res = broadcast_cmd("rset_hilatency_warn_time #{s[1]}\r\n")
937   @stats.hilatency_warn_time = s[1].to_f
938   res[@stats.ap_str] = "STORED"
939   send_data("#{res}\r\n")
940 end
ev_set_latency_avg_calc_rule(s) click to toggle source

set_latency_avg_calc_rule <mode> <count> <command1> <command2>.… <mode> is on/off <count> is denominator to calculate average. <commandx> is target command

    # File lib/roma/command/sys_command_receiver.rb
523 def ev_set_latency_avg_calc_rule(s)
524   #check argument
525   if /^on$|^off$/ !~ s[1]
526     return send_data("CLIENT_ERROR argument 1: please input \"on\" or \"off\"\r\n")
527   elsif s[1] == "on" && (s.length <= 3 || s[2].to_i < 1)
528     return send_data("CLIENT_ERROR number of arguments (0 for 3) and <count> must be greater than zero\r\n")
529   elsif s[1] == "off" && !(s.length == 2)
530     return send_data("CLIENT_ERROR number of arguments (0 for 1, or more 3)\r\n")
531   end
532 
533   #check support commands
534   s.each_index {|idx|
535     if idx >= 3 && (!Event::Handler::ev_list.include?(s[idx]) || Event::Handler::system_commands.include?(s[idx]))
536        return send_data("NOT SUPPORT [#{s[idx]}] command\r\n")
537     end
538   }
539 
540   arg ="rset_latency_avg_calc_rule"
541   s.each_index {|idx|
542     arg += " #{s[idx]}" if idx>=1
543   }
544   res = broadcast_cmd("#{arg}\r\n")
545 
546   if s[1] =="on"
547     @stats.latency_check_cmd = [] #reset
548     s.each_index {|idx|
549       @stats.latency_check_cmd.push(s[idx]) if idx >= 3
550     }
551     @stats.latency_check_time_count = s[2].to_i
552     @stats.latency_log = true
553     res[@stats.ap_str] = "ACTIVATED"
554   elsif s[1] =="off"
555     @stats.latency_check_cmd = [] #reset
556     @stats.latency_check_time_count = false
557     @stats.latency_log = false
558     res[@stats.ap_str] = "DEACTIVATED"
559   end
560   @stats.latency_data = Hash.new { |hash,key| hash[key] = {}}
561   send_data("#{res}\r\n")
562 end
ev_set_log_level(s) click to toggle source

set_log_level [ 'debug' | 'info' | 'warn' | 'error' ]

    # File lib/roma/command/sys_command_receiver.rb
348 def ev_set_log_level(s)
349   if s.length < 2
350     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
351   end
352 
353   case s[1].downcase
354   when 'debug'
355     @log.level = Roma::Logging::RLogger::Severity::DEBUG
356   when 'info'
357     @log.level = Roma::Logging::RLogger::Severity::INFO
358   when 'warn'
359     @log.level = Roma::Logging::RLogger::Severity::WARN
360   when 'error'
361     @log.level = Roma::Logging::RLogger::Severity::ERROR
362   else
363     return send_data("CLIENT_ERROR no match log-level string\r\n")
364   end
365 
366   @stats.log_level = s[1].downcase
367 
368   send_data("STORED\r\n")
369 end
ev_set_log_shift_age(s) click to toggle source

set_log_shift_age <age>

     # File lib/roma/command/sys_command_receiver.rb
1285 def ev_set_log_shift_age(s)
1286   if s.length != 2
1287     return send_data("CLIENT_ERROR number of arguments\r\n")
1288   elsif s[1].to_i < 1 && !['0', 'min', 'hour', 'daily', 'weekly', 'monthly'].include?(s[1])
1289     return send_data("CLIENT_ERROR invalid arguments\r\n")
1290   end
1291 
1292   res = broadcast_cmd("rset_log_shift_age #{s[1]}\r\n")
1293 
1294   if s[1].to_i > 0 || s[1] == '0'
1295     @log.set_log_shift_age(s[1].to_i)
1296     @stats.log_shift_age = s[1].to_i
1297   else
1298     @log.set_log_shift_age(s[1])
1299     @stats.log_shift_age = s[1]
1300   end
1301   res[@stats.ap_str] = "STORED"
1302   send_data("#{res}\r\n")
1303 end
ev_set_log_shift_size(s) click to toggle source

set_log_shift_size <size>

     # File lib/roma/command/sys_command_receiver.rb
1258 def ev_set_log_shift_size(s)
1259   if s.length != 2
1260     return send_data("CLIENT_ERROR number of arguments\r\n")
1261   elsif s[1].to_i < 1
1262     return send_data("CLIENT_ERROR length must be greater than zero\r\n")
1263   end
1264 
1265   res = broadcast_cmd("rset_log_shift_size #{s[1]}\r\n")
1266   @log.set_log_shift_size(s[1].to_i)
1267   @stats.log_shift_size = s[1].to_i
1268   res[@stats.ap_str] = "STORED"
1269   send_data("#{res}\r\n")
1270 end
ev_set_reqpushv_timeout_count(s) click to toggle source

set_reqpushv_timeout_count <sec>

     # File lib/roma/command/sys_command_receiver.rb
1009 def ev_set_reqpushv_timeout_count(s)
1010   if s.length != 2
1011     return send_data("CLIENT_ERROR number of arguments\n\r")
1012   end
1013   if s[1].to_i <= 0
1014     return send_data("CLIENT_ERROR time value must be lager than 0\r\n")
1015   end
1016   res = broadcast_cmd("rset_reqpushv_timeout_count #{s[1]}\r\n")
1017   @stats.reqpushv_timeout_count = s[1].to_i
1018   res[@stats.ap_str] = "STORED"
1019   send_data("#{res}\r\n")
1020 end
ev_set_routing_trans_timeout(s) click to toggle source

set_routing_trans_timeout <sec>

    # File lib/roma/command/sys_command_receiver.rb
955 def ev_set_routing_trans_timeout(s)
956   if s.length != 2
957     return send_data("CLIENT_ERROR number of arguments\n\r")
958   end
959   if s[1].to_f <= 0
960     return send_data("CLIENT_ERROR time value must be lager than 0\r\n")
961   end
962   res = broadcast_cmd("rset_routing_trans_timeout #{s[1]}\r\n")
963   @stats.routing_trans_timeout = s[1].to_f
964   res[@stats.ap_str] = "STORED"
965 
966   send_data("#{res}\r\n")
967 end
ev_set_spushv_klength_warn(s) click to toggle source

set_spushv_klength_warn <byte>

     # File lib/roma/command/sys_command_receiver.rb
1035 def ev_set_spushv_klength_warn(s)
1036   if s.length != 2
1037     return send_data("CLIENT_ERROR number of arguments\n\r")        
1038   end
1039   if s[1].to_i <= 0
1040     return send_data("CLIENT_ERROR size value must be larger than 0 \r\n")
1041   end
1042   res = broadcast_cmd("rset_spushv_klength_warn #{s[1]}\r\n")
1043   @stats.spushv_klength_warn = s[1].to_i 
1044   res[@stats.ap_str] = "STORED"
1045   send_data("#{res}\r\n")
1046 end
ev_set_spushv_read_timeout(s) click to toggle source

set_spushv_read_timeout <sec>

    # File lib/roma/command/sys_command_receiver.rb
983 def ev_set_spushv_read_timeout(s)
984   if s.length != 2
985     return send_data("CLIENT_ERROR number of arguments\n\r")
986   end
987   if s[1].to_i <= 0
988     return send_data("CLIENT_ERROR time value must be lager than 0\r\n")
989   end
990   res = broadcast_cmd("rset_spushv_read_timeout #{s[1]}\r\n")
991   @stats.spushv_read_timeout = s[1].to_i
992   res[@stats.ap_str] = "STORED"
993   send_data("#{res}\r\n")
994 end
ev_set_spushv_vlength_warn(s) click to toggle source

set_spushv_vlength_warn <byte>

     # File lib/roma/command/sys_command_receiver.rb
1061 def ev_set_spushv_vlength_warn(s)
1062   if s.length != 2
1063     return send_data("CLIENT_ERROR number of arguments\n\r")       
1064   end
1065   if s[1].to_i <= 0
1066     return send_data("CLIENT_ERROR size value must be larger than 0 \r\n")
1067   end
1068   res = broadcast_cmd("rset_spushv_vlength_warn #{s[1]}\r\n")
1069   @stats.spushv_vlength_warn = s[1].to_i
1070   res[@stats.ap_str] = "STORED"
1071   send_data("#{res}\r\n")
1072 end
ev_set_storage_status(s) click to toggle source

set_storage_status [number of file]{hash_name}

     # File lib/roma/command/sys_command_receiver.rb
1154 def ev_set_storage_status(s)
1155   if s.length < 3
1156     return send_data("CLIENT_ERROR number of arguments (#{s.length - 1} for 2)\r\n")
1157   end
1158 
1159   if s.length >= 4
1160     hname = s[3]
1161   else
1162     hname = 'roma'
1163   end
1164   st = @storages[hname]
1165   unless st
1166     return send_data("CLIENT_ERROR hash_name = #{hanme} does not found\r\n")
1167   end
1168   dn = s[1].to_i
1169   if st.divnum <= dn
1170     return send_data("CLIENT_ERROR divnum <= #{dn}\r\n")
1171   end
1172   if s[2] == 'safecopy'
1173     if st.dbs[dn] != :normal
1174       return send_data("CLIENT_ERROR storage[#{dn}] != :normal status\r\n")
1175     end
1176     if st.set_db_stat(dn, :safecopy_flushing) == false
1177       return send_data("CLIENT_ERROR storage[#{dn}] status can't changed\r\n")
1178     end
1179     Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_storage_flush_process',[hname, dn]))
1180   elsif s[2] ==  'normal'
1181     if st.dbs[dn] != :safecopy_flushed
1182       return send_data("CLIENT_ERROR storage[#{dn}] != :safecopy_flushed status\r\n")
1183     end
1184     if st.set_db_stat(dn, :cachecleaning) == false
1185       return send_data("CLIENT_ERROR storage[#{dn}] status can't changed\r\n")
1186     end
1187     Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_storage_cachecleaning_process',[hname, dn]))
1188   else
1189     return send_data("CLIENT_ERROR status parse error\r\n")
1190   end
1191   
1192   send_data("PUSHED\r\n")
1193 end
ev_set_wb_shift_size(s) click to toggle source

set_wb_shift_size <size>

     # File lib/roma/command/sys_command_receiver.rb
1129 def ev_set_wb_shift_size(s)
1130   if s.length != 2
1131     return send_data("CLIENT_ERROR number of arguments\r\n")
1132   elsif s[1].to_i < 1
1133     return send_data("CLIENT_ERROR length must be greater than zero\r\n")
1134   end
1135 
1136   res = broadcast_cmd("rset_wb_shift_size #{s[1]}\r\n")
1137   $roma.wb_writer.shift_size = s[1].to_i
1138   res[@stats.ap_str] = "STORED"
1139   send_data("#{res}\r\n")
1140 end
ev_shutdown(s) click to toggle source

shutdown [reason]

   # File lib/roma/command/sys_command_receiver.rb
43 def ev_shutdown(s)
44   send_data("*** ARE YOU REALLY SURE TO SHUTDOWN? *** (yes/no)\r\n")
45   if gets != "yes\r\n"
46     close_connection_after_writing
47     return
48   end
49 
50   if s.length == 2
51     @log.info("Receive a shutdown #{s[1]}")
52   else
53     @log.info("Receive a shutdown command.")
54   end
55   @rttable.enabled_failover = false
56   res = broadcast_cmd("rshutdown\r\n")
57   res[@stats.ap_str] = "BYE"
58   send_data("#{res.inspect}\r\n")
59   close_connection_after_writing
60   @stop_event_loop = true
61 end
ev_shutdown_self(s) click to toggle source

shutdown_self

   # File lib/roma/command/sys_command_receiver.rb
77 def ev_shutdown_self(s)
78   if s.length != 1
79     send_data("ERROR: shutdown_instance has irregular argument.\r\n")
80   else
81     send_data("\r\n=================================================================\r\n")
82     send_data("CAUTION!!: \r\n\tThis command kill the instance!\r\n\tThere is some possibility of occuring redundancy down!\r\n")
83     send_data("=================================================================\r\n")
84     send_data("\r\nAre you sure to shutdown this instance?(yes/no)\r\n")
85     if gets != "yes\r\n"
86       close_connection_after_writing
87       return
88     end
89     @log.info("Receive a shutdown_self command.")
90     @rttable.enabled_failover = false
91     send_data("BYE\r\n")
92     @stop_event_loop = true
93     close_connection_after_writing
94   end
95 end
ev_stat(s) click to toggle source

stat [regexp]

    # File lib/roma/command/sys_command_receiver.rb
115 def ev_stat(s)
116   regexp = s[1] if s.length == 2
117   h = {}
118   h['version'] = Roma::VERSION
119   send_stat_result(nil,h,regexp)
120   send_stat_result(nil,get_config_stat,regexp)
121   send_stat_result(nil,@stats.get_stat,regexp)
122   @storages.each{|hname,st|
123     send_stat_result("storages[#{hname}].",st.get_stat,regexp)
124   }
125   send_stat_result(nil,$roma.wb_get_stat,regexp)
126   send_stat_result(nil,@rttable.get_stat(@stats.ap_str),regexp)
127   send_stat_result(nil,conn_get_stat,regexp)
128   send_stat_result(nil,DNSCache.instance.get_stat,regexp)
129   send_data("END\r\n")
130 end
ev_stats(s) click to toggle source

stats [regexp]

    # File lib/roma/command/sys_command_receiver.rb
112 def ev_stats(s); ev_stat(s); end
ev_switch_dns_caching(s) click to toggle source

switch_dns_caching <on|off|true|false>

    # File lib/roma/command/sys_command_receiver.rb
887 def ev_switch_dns_caching(s)
888   if s.length != 2
889     return send_data("CLIENT_ERROR number of arguments\r\n")
890   end
891 
892   res = broadcast_cmd("rswitch_dns_caching #{s[1]}\r\n")
893   if s[1] == 'on' || s[1] == 'true'
894     DNSCache.instance.enable_dns_cache
895     @log.info("DNS caching enabled")
896     res[@stats.ap_str] = "ENABLED"
897   elsif s[1] == 'off' || s[1] == 'false'
898     DNSCache.instance.disable_dns_cache
899     @log.info("DNS caching disabled")
900     res[@stats.ap_str] = "DISABLED"
901   else
902     res[@stats.ap_str] = "NOTSWITCHED"
903   end
904   send_data("#{res}\r\n")
905 end
ev_switch_failover(s) click to toggle source

switch_failover <on|off>

    # File lib/roma/command/sys_command_receiver.rb
453 def ev_switch_failover(s)
454   if s.length != 2
455     return send_data("CLIENT_ERROR number of arguments\r\n")
456   end
457   res = broadcast_cmd("rswitch_failover #{s[1]}\r\n")
458   if s[1] == 'on'
459     Messaging::ConPool.instance.close_all
460     Event::EMConPool::instance.close_all
461     @rttable.enabled_failover = true
462     @log.info("failover enabled")
463     res[@stats.ap_str] = "ENABLED"
464   elsif s[1] == 'off'
465     @rttable.enabled_failover = false
466     @log.info("failover disabled")
467     res[@stats.ap_str] = "DISABLED"
468   else
469     res[@stats.ap_str] = "NOTSWITCHED"
470   end
471   send_data("#{res}\r\n")
472 end
ev_switch_replication(s) click to toggle source

switch_replication command is change status of cluster replication if you want to activate, assign 1 nid(addr_port) of replication cluster as argument. if you want to copy existing data, add the 'all' after nid as argument switch_replication <true|false> [nid] [copy target]

    # File lib/roma/command/sys_command_receiver.rb
231 def ev_switch_replication(s)
232   unless s.length.between?(2, 4)
233     return send_data("CLIENT_ERROR number of arguments\r\n")
234   end
235   unless s[1] =~ /^(true|false)$/
236     return send_data("CLIENT_ERROR value must be true or false\r\n")
237   end
238   if s[3] && s[3] != 'all'
239     return send_data("CLIENT_ERROR [copy target] must be all or nil\r\n")
240   end
241 
242   res = broadcast_cmd("rswitch_replication #{s[1]} #{s[2]} #{s[3]}\r\n")
243 
244   timeout(1){
245     case s[1]
246     when 'true'
247       $roma.cr_writer.update_mklhash(s[2])
248       $roma.cr_writer.update_nodelist(s[2])
249       $roma.cr_writer.update_rttable(s[2])
250       $roma.cr_writer.run_replication = true
251       if s[3] == 'all'
252         $roma.cr_writer.run_existing_data_replication = true
253         Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_replicate_existing_data_process', [$roma.cr_writer.replica_rttable]))
254       end
255       res[@stats.ap_str] = "ACTIVATED"
256     when 'false'
257       $roma.cr_writer.replica_mklhash = nil
258       $roma.cr_writer.replica_nodelist = []
259       $roma.cr_writer.replica_rttable = nil
260       $roma.cr_writer.run_replication = false
261       $roma.cr_writer.run_existing_data_replication = false
262       res[@stats.ap_str] = "DEACTIVATED"
263     end
264   }
265   send_data("#{res}\r\n")
266 rescue => e
267   send_data("#{e.class}: #{e}\r\n")
268 end
ev_version(s) click to toggle source

version

    # File lib/roma/command/sys_command_receiver.rb
 98 def ev_version(s)
 99   send_data("VERSION ROMA-#{Roma::VERSION}\r\n")
100 end
ev_wb_command_map(s) click to toggle source

wb_command_map <hash string> ex. {:set=>1,:append=>2,:delete=>3}

     # File lib/roma/command/sys_command_receiver.rb
1089 def ev_wb_command_map(s)
1090   if s.length < 2
1091     return send_data("CLIENT_ERROR number of arguments\r\n")
1092   end
1093   map = {}
1094   cmd = s[1..-1].join
1095   if cmd =~ /^\{(.+)\}$/
1096     $1.split(',').each do |kv|
1097       k, v = kv.split('=>')
1098       map[k[1..-1].to_sym] = v.to_i if v && k[0]==':'
1099     end
1100 
1101     res = broadcast_cmd("rwb_command_map #{s[1..-1].join}\r\n")
1102     @stats.wb_command_map = map
1103     res[@stats.ap_str] = map.inspect
1104     send_data("#{res}\r\n")
1105   else
1106     send_data("CLIENT_ERROR hash string parse error\r\n")
1107   end
1108 end
ev_whoami(s) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
107 def ev_whoami(s)
108   send_data("#{@stats.name}\r\n")
109 end
ev_writebehind_get_current_file(s) click to toggle source

writebehind_get_current_file [hash_name]

    # File lib/roma/command/sys_command_receiver.rb
199 def ev_writebehind_get_current_file(s)
200   if s.length < 2
201     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
202   end
203   res = broadcast_cmd("rwritebehind_get_current_file #{s[1]}\r\n")
204 
205   ret = $roma.wb_get_current_file_path(s[1])
206   if ret
207     res[@stats.ap_str] = ret
208   else
209     res[@stats.ap_str] = "NOT_OPEND"
210   end
211   send_data("#{res}\r\n")
212 end
ev_writebehind_get_path(s) click to toggle source

writebehind_get_path [hash_name]

    # File lib/roma/command/sys_command_receiver.rb
176 def ev_writebehind_get_path(s)
177   if s.length < 2
178     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
179   end
180   res = broadcast_cmd("rwritebehind_get_path #{s[1]}\r\n")
181   
182   ret = $roma.wb_get_path(s[1])
183   res[@stats.ap_str] = ret
184 
185   send_data("#{res}\r\n")
186 end
ev_writebehind_rotate(s) click to toggle source

writebehind_rotate [hash_name]

    # File lib/roma/command/sys_command_receiver.rb
149 def ev_writebehind_rotate(s)
150   if s.length < 2
151     return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
152   end
153   res = broadcast_cmd("rwritebehind_rotate #{s[1]}\r\n")
154 
155   if $roma.wb_rotate(s[1])
156     res[@stats.ap_str] = "ROTATED"
157   else
158     res[@stats.ap_str] = "NOT_OPEND"
159   end
160   send_data("#{res}\r\n")
161 end

Private Instance Methods

dcnice(p) click to toggle source
     # File lib/roma/command/sys_command_receiver.rb
1324 def dcnice(p)
1325   case(p)
1326   when 1 # highest priority
1327     @stats.stream_copy_wait_param = 0.001
1328     @storages.each_value{|st|
1329       st.each_vn_dump_sleep = 0.001
1330       st.each_vn_dump_sleep_count = 1000
1331     }
1332   when 2
1333     @stats.stream_copy_wait_param = 0.005
1334     @storages.each_value{|st|
1335       st.each_vn_dump_sleep = 0.005
1336       st.each_vn_dump_sleep_count = 100
1337     }
1338   when 3 # default priority
1339     @stats.stream_copy_wait_param = 0.01
1340     @storages.each_value{|st|
1341       st.each_vn_dump_sleep = 0.001
1342       st.each_vn_dump_sleep_count = 10
1343     }
1344   when 4
1345     @stats.stream_copy_wait_param = 0.01
1346     @storages.each_value{|st|
1347       st.each_vn_dump_sleep = 0.005
1348       st.each_vn_dump_sleep_count = 10
1349     }
1350   when 5 # lowest priority
1351     @stats.stream_copy_wait_param = 0.01
1352     @storages.each_value{|st|
1353       st.each_vn_dump_sleep = 0.01
1354       st.each_vn_dump_sleep_count = 10
1355     }
1356   else
1357     return "CLIENT_ERROR You sholud input a priority from 1 to 5."
1358   end
1359   @stats.dcnice = p
1360   "STORED"
1361 end
get_config_stat() click to toggle source
     # File lib/roma/command/sys_command_receiver.rb
1363 def get_config_stat
1364   ret = {}
1365   ret['config.DEFAULT_LOST_ACTION'] = Config::DEFAULT_LOST_ACTION
1366   ret['config.LOG_SHIFT_AGE'] = Config::LOG_SHIFT_AGE
1367   ret['config.LOG_SHIFT_SIZE'] = Config::LOG_SHIFT_SIZE
1368   ret['config.LOG_PATH'] = File.expand_path(Config::LOG_PATH)
1369   ret['config.RTTABLE_PATH'] = File.expand_path(Config::RTTABLE_PATH)
1370   ret['config.STORAGE_DELMARK_EXPTIME'] = Config::STORAGE_DELMARK_EXPTIME
1371   if Config.const_defined?(:STORAGE_EXCEPTION_ACTION)
1372     ret['config.STORAGE_EXCEPTION_ACTION'] = Config::STORAGE_EXCEPTION_ACTION
1373   end
1374   ret['config.DATACOPY_STREAM_COPY_WAIT_PARAM'] = Config::DATACOPY_STREAM_COPY_WAIT_PARAM
1375   ret['config.PLUGIN_FILES'] = Config::PLUGIN_FILES.inspect
1376   ret['config.WRITEBEHIND_PATH'] = File.expand_path(Config::WRITEBEHIND_PATH)
1377   ret['config.WRITEBEHIND_SHIFT_SIZE'] = Config::WRITEBEHIND_SHIFT_SIZE
1378   if Config.const_defined?(:CONNECTION_DESCRIPTOR_TABLE_SIZE)
1379     ret['config.CONNECTION_DESCRIPTOR_TABLE_SIZE'] = Config::CONNECTION_DESCRIPTOR_TABLE_SIZE
1380   end
1381   ret
1382 end
send_stat_result(prefix,h,regexp = nil) click to toggle source
    # File lib/roma/command/sys_command_receiver.rb
132 def send_stat_result(prefix,h,regexp = nil)
133   h.each{|k,v|         
134     if prefix
135       key = "#{prefix}#{k}"
136     else
137       key = "#{k}"
138     end
139     if regexp
140       send_data("#{key} #{v}\r\n") if key =~ /#{regexp}/
141     else
142       send_data("#{key} #{v}\r\n")
143     end
144   }
145 end