support latest version of go r60 (released 2011/09/07)

Added goinstall instruction to readme.

Removed a debug output.

tkawachi: Changed a response type for KEYS to MULTI_BULK simonjefford hopefully, this will now work with goinstall

I know this project has a lot of followers, it would be great if it could be installed with go get. The best way to do this is probably by renaming the repository to 'redis'. I did this here: https://github.com/bpowers/redis For my own personal use.

Thoughts?

goinstall allows you to auto-install github repos. I'm new to Go so I'm not sure what the underlying problem is. This would make it easy for noobs like me to install and use your project quickly.

http://golang.org/cmd/goinstall/

> goinstall -u github.com/alphazero/Go-Redis
goinstall: github.com/alphazero/Go-Redis: package has no files

I have a long-running web service that uses Go-Redis. Once on a while I get the following stack trace:

SIGSEGV: segmentation violation Faulting address: 0x20 PC=0x40a44d

redis·_connHdl·ServiceRequest+0x28b /home/mike/workspace/Go-Redis/src/pkg/redis/connection.go:263 redis·_connHdl·ServiceRequest(0x7947e1a0, 0x7fae, 0x4b5d60, 0x0, 0x785cd7d0, ...) redis·_syncClient·Llen+0xfc /home/mike/workspace/Go-Redis/src/pkg/redis/synchclient.go:442 redis·_syncClient·Llen(0x79479930, 0x7fae, 0x785d7ba0, 0x7fae, 0x16, ...)

It seems that GetResponse in protocol.go sometimes returns a nil object. However, connection.go always assumes it's not nil. Perhaps a check should be added in connection.go that tests if the response is nil?

The LREM command of Redis server in version 5.0.3 expects three arguments in the order key count value. See the docs for more information.

Currently, the commend seems to be implemented with the arguments in the wrong order (key value count) and therefore does not work.

For replication of this problem try the following code:

package main

import (
	"github.com/alphazero/go-redis"
)

func main() {
	spec := redis.DefaultSpec().Host(redis.DefaultRedisHost).Port(redis.DefaultRedisPort).Password(redis.DefaultRedisPassword).Db(1)
	client, err := redis.NewSynchClientWithSpec(spec)
	if err != nil {
		return
	}

	defer client.Quit()

	client.Lpush("test", []byte("Test"))
	client.Lpush("test", []byte("Test"))
	client.Lpush("test", []byte("Test"))

	removedItems, err := client.Lrem("test", []byte("test"), 0) // current implementation
	// removedItems, err := client.Lrem("test", 0, []byte("test")) // Should be implemented like this
	if err != nil {
		println(err)
	}
}

Thanks in advance for your help with this problem! schoeppi5

I have a web API written in Go using Go redis. the API will connection to redis,fetch the newest 5 items in a 20-items list,do some iter computation,and reture the result. (I will use RPUSH to store the list )

However,when a use http_load to run benchmark,the log shows that redis is slow. The slow rate is about 0.1%. Every time I run the benchmark,there will be slow log

When I use Python script ,the redis response always in ms! How is that?

the init connection code is as this:

spec := redis.DefaultSpec().Host(host).Port(port).Db(db)
conn, e := redis.NewAsynchClientWithSpec(spec)
if e != nil {
    log.Fatal("Error creating client for worker: ", e)
    os.Exit(1)
}

And the Lrange code is as this:

futureData,err = (*Redis).Lrange("my redis key",- 5,-1)
timeout := 100*time.Millisecond
t := time.Now()
mydata,err,timedout  := futureData.TryGet(timeout)
if time.Since(t) > time.Second {
    log.Println("slow redis query[fetch result]"）
}

Quick change that allows the benchmark files to be run without modifying GOPATH. With this change it should be possible to run the following series of commands

go get github.com/alphazero/Go-redis echo "requirepass go-redis" | redis-server - & for i in src/github.com/alphazero/Go-redis/bench/*.go ; do go run $i done kill %1

The idea is to make it super simple to run.

Tested using the above commands.

Calling flag.Parse() in our init() inhibits others from using the flag module.

All flag definitions must happen before flag.Parse() is called, and flag.Parse() can only effectively be called once. So a client pulling in Go-Redis also using the flag module would get an error of the form: flag provided but not defined: -the-client-app-flag

We can't effectively coerce that flag.Parse() must happen, unless we use sync.Once to call it in our own API guarded by a call to flag.Parsed().

Please make the package installable using "go get" instead of the manual steps described in the readme. The go tool is the standard way to download and install packages. It does not look like anything in your package should prevent the use the go tool for installation.

Adds reconnect() methods for connHdl and asyncConnHdl which get called when connHdl.ServiceRequest() or asyncConnHdl.QueueRequest() fail. Adds basic implementation of asyncConnHdl.disconnect().

calling flag.Parse() in init() breaks flags module

$ cat test/test_redis.go package main import ( "fmt" "flag" redis "Go-Redis" ) func main() { var configfile string flag.StringVar(&configfile, "config", "/etc/config.ini", "configuration file") flag.Parse() fmt.Println("Config file", configfile)

spec := redis.DefaultSpec()
_ = spec

--- output ---

go run test/test_redis.go -config /etc/config.ini flag provided but not defined: -config Usage of /tmp/go-build929316002/command-line-arguments/_obj/a.out: -redis:d=false: debug flag for go-redis exit status 2

Is there mismatch between description and code example? 1,From my understanding when introducing sync,async code is used,and introducing async,a old version async code is used.I can't find method "NewRedisPipeline(spec)".

2, AsyncClient equals pipeline,right? and you didn't give a method named like "flush" or "batchCommit" for committing batched commands,the "futureBytes.Get()" is equivalent,right?