module Roma::Command::SystemCommandReceiver
Public Instance Methods
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
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
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
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
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
# 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
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
quit
# File lib/roma/command/sys_command_receiver.rb 103 def ev_quit(s) 104 close_connection 105 end
# 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
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
# 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
# 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
# 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
# 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
# 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
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
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
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
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
# 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
# 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
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
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
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
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
# 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
# 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
# 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
<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
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
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
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
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
# 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
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
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
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
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
# 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
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
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
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
<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
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
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
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
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
# 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
# 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
stats [regexp]
# File lib/roma/command/sys_command_receiver.rb 112 def ev_stats(s); ev_stat(s); end
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
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
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
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
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
# File lib/roma/command/sys_command_receiver.rb 107 def ev_whoami(s) 108 send_data("#{@stats.name}\r\n") 109 end
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
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
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
# 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
# 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
# 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