외부 redis 서버를 사용하여 tcl 스크립트를 테스트합니다.

Question

저는 Ubuntu 11.10을 실행하고 있습니다.

외부 redis 서버를 사용하여 TCL 테스트 스크립트를 실행하려고합니다.

sb@sb-laptop:~/Redis/redis$ tclsh tests/test_helper.tcl --host 192.168.1.130 --port 6379 

다음과 같은 오류 받기 :

Testing unit/type/list 
[exception]: Executing test client: couldn't open socket: connection refused. 
couldn't open socket: connection refused 
    while executing 
"socket $server $port" 
    (procedure "redis" line 2) 
    invoked from within 
"redis $::host $::port" 
    (procedure "start_server" line 9) 
    invoked from within 
"start_server {tags {"protocol"}} { 
    test "Handle an empty query" { 
     reconnect 
     r write "\r\n" 
     r flush 
     assert_equal "P..." 
    (file "tests/unit/protocol.tcl" line 1) 
    invoked from within 
"source $path" 
    (procedure "execute_tests" line 4) 
    invoked from within 
"execute_tests $data" 
    (procedure "test_client_main" line 9) 
    invoked from within 
"test_client_main $::test_server_port " 

redis.conf이 바인딩을 기본값으로 설정되어 있지만 주석

다음 사용.

이것이 가능한 경우 무엇을 잘못하고 있습니까?

추가 정보 : 아래

는 TCL의 서버를 시작 책임이 코드

proc start_server {options {code undefined}} { 
    # If we are runnign against an external server, we just push the 
    # host/port pair in the stack the first time 
    if {$::external} { 
     if {[llength $::servers] == 0} { 
      set srv {} 
      dict set srv "host" $::host 
      dict set srv "port" $::port 
      set client [redis $::host $::port] 
      dict set srv "client" $client 
      $client select 9 

      # append the server to the stack 
      lappend ::servers $srv 
     } 
     uplevel 1 $code 
     return 
    } 

    # setup defaults 
    set baseconfig "default.conf" 
    set overrides {} 
    set tags {} 

    # parse options 
    foreach {option value} $options { 
     switch $option { 
      "config" { 
       set baseconfig $value } 
      "overrides" { 
       set overrides $value } 
      "tags" { 
       set tags $value 
       set ::tags [concat $::tags $value] } 
      default { 
       error "Unknown option $option" } 
     } 
    } 

    set data [split [exec cat "tests/assets/$baseconfig"] "\n"] 
    set config {} 
    foreach line $data { 
     if {[string length $line] > 0 && [string index $line 0] ne "#"} { 
      set elements [split $line " "] 
      set directive [lrange $elements 0 0] 
      set arguments [lrange $elements 1 end] 
      dict set config $directive $arguments 
     } 
    } 

    # use a different directory every time a server is started 
    dict set config dir [tmpdir server] 

    # start every server on a different port 
    set ::port [find_available_port [expr {$::port+1}]] 
    dict set config port $::port 

    # apply overrides from global space and arguments 
    foreach {directive arguments} [concat $::global_overrides $overrides] { 
     dict set config $directive $arguments 
    } 

    # write new configuration to temporary file 
    set config_file [tmpfile redis.conf] 
    set fp [open $config_file w+] 
    foreach directive [dict keys $config] { 
     puts -nonewline $fp "$directive " 
     puts $fp [dict get $config $directive] 
    } 
    close $fp 

    set stdout [format "%s/%s" [dict get $config "dir"] "stdout"] 
    set stderr [format "%s/%s" [dict get $config "dir"] "stderr"] 

    if {$::valgrind} { 
     exec valgrind --suppressions=src/valgrind.sup src/redis-server $config_file > $stdout 2> $stderr & 
    } else { 
     exec src/redis-server $config_file > $stdout 2> $stderr & 
    } 

    # check that the server actually started 
    # ugly but tries to be as fast as possible... 
    set retrynum 100 
    set serverisup 0 

    if {$::verbose} { 
     puts -nonewline "=== ($tags) Starting server ${::host}:${::port} " 
    } 

    after 10 
    if {$code ne "undefined"} { 
     while {[incr retrynum -1]} { 
      catch { 
       if {[ping_server $::host $::port]} { 
        set serverisup 1 
       } 
      } 
      if {$serverisup} break 
      after 50 
     } 
    } else { 
     set serverisup 1 
    } 

    if {$::verbose} { 
     puts "" 
    } 

    if {!$serverisup} { 
     error_and_quit $config_file [exec cat $stderr] 
    } 

    # find out the pid 
    while {![info exists pid]} { 
     regexp {\[(\d+)\]} [exec cat $stdout] _ pid 
     after 100 
    } 

    # setup properties to be able to initialize a client object 
    set host $::host 
    set port $::port 
    if {[dict exists $config bind]} { set host [dict get $config bind] } 
    if {[dict exists $config port]} { set port [dict get $config port] } 

    # setup config dict 
    dict set srv "config_file" $config_file 
    dict set srv "config" $config 
    dict set srv "pid" $pid 
    dict set srv "host" $host 
    dict set srv "port" $port 
    dict set srv "stdout" $stdout 
    dict set srv "stderr" $stderr 

    # if a block of code is supplied, we wait for the server to become 
    # available, create a client object and kill the server afterwards 
    if {$code ne "undefined"} { 
     set line [exec head -n1 $stdout] 
     if {[string match {*already in use*} $line]} { 
      error_and_quit $config_file $line 
     } 

     while 1 { 
      # check that the server actually started and is ready for connections 
      if {[exec cat $stdout | grep "ready to accept" | wc -l] > 0} { 
       break 
      } 
      after 10 
     } 

     # append the server to the stack 
     lappend ::servers $srv 

     # connect client (after server dict is put on the stack) 
     reconnect 

     # execute provided block 
     set num_tests $::num_tests 
     if {[catch { uplevel 1 $code } error]} { 
      set backtrace $::errorInfo 

      # Kill the server without checking for leaks 
      dict set srv "skipleaks" 1 
      kill_server $srv 

      # Print warnings from log 
      puts [format "\nLogged warnings (pid %d):" [dict get $srv "pid"]] 
      set warnings [warnings_from_file [dict get $srv "stdout"]] 
      if {[string length $warnings] > 0} { 
       puts "$warnings" 
      } else { 
       puts "(none)" 
      } 
      puts "" 

      error $error $backtrace 
     } 

     # Don't do the leak check when no tests were run 
     if {$num_tests == $::num_tests} { 
      dict set srv "skipleaks" 1 
     } 

     # pop the server object 
     set ::servers [lrange $::servers 0 end-1] 

     set ::tags [lrange $::tags 0 end-[llength $tags]] 
     kill_server $srv 
    } else { 
     set ::tags [lrange $::tags 0 end-[llength $tags]] 
     set _ $srv 
    } 
} 

Answer 1

어느 것도, 호스트 192.168.1.130에서 수신이 없다 포트 6379 (물론, 추측에서) 또는 방화벽입니다 구성이 연결을 차단하고 있습니다. 모든 코드가 이니까 실제로는보고있는 것은 불가능합니다. "연결이 작동하지 않았습니다. 무언가가 '아니오'라고 ... ".