flushall of redis cluster

flushall.go

package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"strings"
	"time"

	"github.com/gomodule/redigo/redis"
)

var (
	addr    string
	passwd  string
	db      int
	pattern string
)

func init() {
	flag.StringVar(&addr, "addr", "", "addr, delim:','")
	flag.StringVar(&passwd, "passwd", "", "passwd")
	flag.StringVar(&pattern, "pattern", "*", "pattern to match")
	flag.IntVar(&db, "db", 1, "db")
	flag.Parse()
}

func main() {
	fmt.Println("vim-go")

	if addr == "" {
		flag.PrintDefaults()
		os.Exit(1)
	}

	addrs := strings.Split(addr, ",")
	for _, addr := range addrs {
		log.Printf("processing %s\n", addr)
		err := flushallNode(addr)
		if err != nil {
			log.Printf("flushallNode %v\n", err)
		}
	}
}

func flushallNode(addr string) error {
	pool := &redis.Pool{
		MaxIdle:     8,
		IdleTimeout: 1 * time.Second,
	}
	pool.Dial = func() (redis.Conn, error) {
		c, err := redis.Dial(
			"tcp",
			addr,
			redis.DialConnectTimeout(1*time.Second),
			redis.DialReadTimeout(1*time.Second),
			redis.DialWriteTimeout(1*time.Second),
			redis.DialPassword(passwd))
		if err != nil {
			log.Printf("dial redis error: %v\n", err)
			return nil, err
		}
		return c, err
	}

	pool.TestOnBorrow = func(c redis.Conn, t time.Time) error {
		_, err := c.Do("Ping")
		if err != nil {
			log.Printf("ping redis err: %v\n", err)
		}
		return err
	}

	keys, err := getAll(pool, pattern)
	if err != nil {
		log.Printf("get all err: %v\n", err)
		return err
	}

	for i, key := range keys {
		log.Printf("deleting %s\n", key)
		err := del(pool, key)
		if err != nil {
			log.Printf("del key: %v, err: %v\n", key, err)
		}
		if (i+1)%1000 == 0 {
			time.Sleep(1 * time.Millisecond)
		}
	}

	return nil
}

func getAll(pool *redis.Pool, pattern string) ([]string, error) {
	iter := 0
	keys := make([]string, 0)

	conn := pool.Get()
	defer conn.Close()

	for {
		result, err := redis.Values(conn.Do("SCAN", iter, "MATCH", pattern))
		if err != nil {
			return keys, err
		}

		iter, _ = redis.Int(result[0], nil)
		strs, _ := redis.Strings(result[1], nil)
		log.Printf("next iter: %d, add %d items", iter, len(strs))
		keys = append(keys, strs...)

		if iter == 0 {
			break
		}
	}

	log.Printf("keys size: %d\n", len(keys))

	return keys, nil
}

func del(pool *redis.Pool, key string) error {
	conn := pool.Get()
	defer conn.Close()
	_, err := redis.Int(conn.Do("DEL", key))
	if err != nil {
		return err
	}
	return nil
}