func delKey(key string, i *int32) { spec := redis.DefaultSpec() client, e := redis.NewSynchClientWithSpec(spec) if e != nil { log.Println("failed to create the client", e) return } for { if *i > MAXKEYS/2 { s := strconv.Itoa(int(*i)) key := key + s value, e := client.Get(key) if e != nil { log.Println("error on Get", e) return } if value != nil { client.Del(key) fmt.Println("Deleted " + key) atomic.AddInt32(i, -1) runtime.Gosched() } } time.Sleep(time.Millisecond * 100) } }
func addKey(key string, new_value string, i *int32) { spec := redis.DefaultSpec() client, e := redis.NewSynchClientWithSpec(spec) if e != nil { log.Println("failed to create the client", e) return } for { atomic.AddInt32(i, 1) if *i > MAXKEYS { done <- true } else { if *i%100000 == 0 { fmt.Printf("Inserted %d \n", *i) } } key := key + strconv.Itoa(int(*i)) value, e := client.Get(key) if e != nil { log.Println("error on Get", e) return } if value == nil { value2set := []byte(new_value) client.Set(key, value2set) runtime.Gosched() } else { //fmt.Println("Already found " + string(key)) } //time.Sleep(time.Millisecond * 10) } }
// Reflect over the methods defined in redis.Client // and send back as []string (tolowercase) // TOOD get rid of redundant code in switch // (REVU: needs minor update to core code) func getDefinedMethods(ctype clientType) (map[string]string, *error_) { var mmap = map[string]string{} spec := redis.DefaultSpec().Db(13).Password("go-redis") var e redis.Error var client interface{} switch ctype { case sync: client, e = redis.NewSynchClientWithSpec(spec) case async: client, e = redis.NewAsynchClientWithSpec(spec) } if e != nil { log.Println("ignoring - ", e) } if client == nil { return mmap, &error_{"client is nil", nil} } else { defer client.Quit() } tc := reflect.TypeOf(client) nm := tc.NumMethod() for i := 0; i < nm; i++ { m := tc.Method(i) mname := strings.ToLower(m.Name) mmap[mname] = mname } return mmap, nil }
func NewClient(t *testing.T) redis.Client { client, err := redis.NewSynchClientWithSpec(getTestConnSpec()) if err != nil { t.Fatalf("TestGet - ", err) } return client }
func makeConcurrentClients(workers int) (clients []redis.Client, err error) { clients = make([]redis.Client, workers) for i := 0; i < workers; i++ { spec := redis.DefaultSpec().Db(13).Password("go-redis") client, e := redis.NewSynchClientWithSpec(spec) if e != nil { log.Println("Error creating client for worker: ", e) return nil, e } clients[i] = client } return }
func doOne(cnt int) error { var delta time.Duration spec := redis.DefaultSpec().Db(13).Password("go-redis") fmt.Printf("\n\n=== Bench synchclient ================ 1 Client -- %d opts --- \n", cnt) fmt.Println() client, e := redis.NewSynchClientWithSpec(spec) if e != nil { return onError("on NewSynchClient call: ", e) } if client == nil { return failedTest("NewSynchClient returned nil!") } // defer client.Quit() // will be deprecated soon defer client.Quit() client.Flushdb() delta = doPing(client, cnt) report("PING", delta, cnt) delta = doIncr(client, cnt) report("INCR", delta, cnt) delta = doSet(client, cnt) report("SET", delta, cnt) delta = doGet(client, cnt) report("GET", delta, cnt) delta = doSadd(client, cnt) report("SADD", delta, cnt) delta = doLpush(client, cnt) report("LPUSH", delta, cnt) delta = doRpush(client, cnt) report("RPUSH", delta, cnt) delta = doLpop(client, cnt) report("LPOP", delta, cnt) delta = doRpop(client, cnt) report("RPOP", delta, cnt) return nil }
func syncPublish(spec *redis.ConnectionSpec, channel string) { client, e := redis.NewSynchClientWithSpec(spec) if e != nil { log.Println("failed to create the sync client", e) return } for i := 0; i < 100; i++ { msg := []byte(fmt.Sprintf("this is message # %d (using sync client)!", i)) rcvCnt, err := client.Publish(channel, msg) if err != nil { fmt.Printf("Error on Publish - %s", err) } else { fmt.Printf("Message sent to %d subscribers\n", rcvCnt) } } client.Quit() }
func main() { // Parse command-line flags; needed to let flags used by Go-Redis be parsed. flag.Parse() // create the client. Here we are using a synchronous client. // Using the default ConnectionSpec, we are specifying the client to connect // to db 13 (e.g. SELECT 13), and a password of go-redis (e.g. AUTH go-redis) spec := redis.DefaultSpec().Db(13).Password("go-redis") client, e := redis.NewSynchClientWithSpec(spec) if e != nil { log.Println("failed to create the client", e) return } key := "examples/hello/user.name" value, e := client.Get(key) if e != nil { log.Println("error on Get", e) return } if value == nil { fmt.Printf("\nHello, don't believe we've met before!\nYour name? ") reader := bufio.NewReader(os.Stdin) user, _ := reader.ReadString(byte('\n')) if len(user) > 1 { user = user[0 : len(user)-1] value = []byte(user) client.Set(key, value) } else { fmt.Printf("vafanculo!\n") return } } fmt.Printf("Hey, ciao %s!\n", fmt.Sprintf("%s", value)) }
func addSingleKey(key string, new_value string) { spec := redis.DefaultSpec() client, e := redis.NewSynchClientWithSpec(spec) if e != nil { log.Println("failed to create the client", e) return } value, e := client.Get(key) if e != nil { log.Println("error on Get", e) return } if value == nil { value2set := []byte(new_value) client.Set(key, value2set) runtime.Gosched() } else { fmt.Println("Already found " + string(key)) } //time.Sleep(time.Millisecond * 10) }