func handleConn(w http.ResponseWriter, r *http.Request) { log.Println(r.URL) password := "" // no password set db := int64(-1) // use default DB client := redis.NewTCPClient("localhost:6379", password, db) defer client.Close() host := r.Header.Get("x-host") token := strings.Split(host, ".")[0] route := client.SRandMember("route::" + token) log.Println(token) log.Println(route.Val()) remote, err := url.Parse(route.Val()) if err != nil { panic(err) } proxy := httputil.NewSingleHostReverseProxy(remote) r.Header.Add("X-Proxy", "just-in-the-neighborhood-and-thought-i-would-drop-in") r.Header.Add("X-Articulated-Route", route.Val()) r.Header.Add("X-Token", token) proxy.ServeHTTP(w, r) }
// Creates a new ESPubSub handler. func New(redisHost, redisPassword string, redisDb int64) ESPubSub { s := new(chanCollection) s.channels = map[string]channel{} s.redisClient = redis.NewTCPClient(redisHost, redisPassword, redisDb) return s }
// Creat new Redis connection manager func (si *System) RedisConnect() *RedisManager { addr := fmt.Sprintf( "%s:%d", si.Config.Redis.Host, si.Config.Redis.Port, ) pw := si.Config.Redis.Password rm := RedisManager{map[string]*redis.Client{}} rm.DbConnect["bfs"] = redis.NewTCPClient(addr, pw, si.Config.Redis.BFSDb) rm.DbConnect["auth"] = redis.NewTCPClient(addr, pw, si.Config.Redis.AuthDb) rm.DbConnect["ext"] = redis.NewTCPClient(addr, pw, si.Config.Redis.ExtDb) rm.DbConnect["upload"] = redis.NewTCPClient(addr, pw, si.Config.Redis.UploadDb) return &rm }
func getRedisConn() *redis.Client { if redisConn == nil { redisConn := redis.NewTCPClient(redisConfig.Host, redisConfig.Password, redisConfig.DB) defer redisConn.Close() return redisConn } return redisConn }
func ExampleCustomCommand() { client := redis.NewTCPClient(":6379", "", -1) defer client.Close() get := Get(client, "key_does_not_exist") fmt.Println(get.Err(), get.Val()) // Output: (nil) }
func getRedisConn() *redis.Client { if redisConn == nil { redisConn := redis.NewTCPClient(redisConfig.Host, redisConfig.Password, redisConfig.DB) redisConn.ConnPool.(*redis.MultiConnPool).MaxCap = redisConfig.ConnPoolSize defer redisConn.Close() return redisConn } return redisConn }
func ExampleTCPClient() { password := "" // no password set db := int64(-1) // use default DB client := redis.NewTCPClient("localhost:6379", password, db) defer client.Close() ping := client.Ping() fmt.Println(ping.Err(), ping.Val()) // Output: <nil> PONG }
// NewRedisClient connects to redis after ensuring that the server is // indeed running. func NewRedisClient(addr, password string, database int64) (*redis.Client, error) { // Bug #97459 -- is the redis client library faking connection for // the down server? conn, err := net.Dial("tcp", addr) if err != nil { return nil, err } conn.Close() return redis.NewTCPClient(addr, password, database), nil }
func setup(t *testing.T) *testEnv { // comment out below to see logging log.SetOutput(ioutil.Discard) t.Log("creating a test env") e := new(testEnv) e.s = New(":6379", "", -1) e.redis = redis.NewTCPClient(":6379", "", 6) e.server = httptest.NewServer(e.s) return e }
func ExampleSetGet() { client := redis.NewTCPClient(":6379", "", -1) defer client.Close() set := client.Set("foo", "bar") fmt.Println(set.Err(), set.Val()) get := client.Get("foo") fmt.Println(get.Err(), get.Val()) // Output: <nil> OK // <nil> bar }
func (p *Persistor) getRedis() *redis.Client { // Guard in case someone else is opening Redis redisAddr := "localhost:6379" m := sync.Mutex{} m.Lock() if !p.connected { log.Printf("[Persistor] Opening Redis at [%v]\n", redisAddr) p.redis = redis.NewTCPClient(redisAddr, "", 0) p.connected = true } m.Unlock() return p.redis }
func InitTests() { server = httptest.NewServer(createRouter()) connectToRedis = func() *redis.Client { // CONFIGURE THIS! password := "" client := redis.NewTCPClient("localhost:6379", password, 1) return client } client := connectToRedis() defer client.Close() client.FlushDb() // Bootstrap the system, with an admin hash, _ := bcrypt.Hash("asdf") client.HMSet("user:admin", "isadmin", "1", "password", hash) }
func main() { password := "" // no password set db := int64(-1) // use default DB client := redis.NewTCPClient("localhost:6379", password, db) http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { log.Println("incoming request ", r.Header.Get("x-token")) hostname, err := os.Hostname() when := time.Now().Format("Mon Jan 2 15:04:05 -0700 MST 2006") if err != nil { fmt.Printf("error: ", err) return } fmt.Fprintf(w, " _____ _ \n") fmt.Fprintf(w, " / ____| | | \n") fmt.Fprintf(w, " | | __ ___ | | __ _ _ __ __ _ \n") fmt.Fprintf(w, " | | |_ |/ _ \\| |/ _` | '_ \\ / _` | \n") fmt.Fprintf(w, " | |__| | (_) | | (_| | | | | (_| | \n") fmt.Fprintf(w, " \\_____|\\___/|_|\\__,_|_| |_|\\__, | \n") fmt.Fprintf(w, " __/ | \n") fmt.Fprintf(w, " |___/ \n\n") token := r.Header.Get("x-token") members := client.SMembers("route::" + token) vals := members.Val() fmt.Fprintf(w, strings.Join(vals, ", ")) fmt.Fprintf(w, "\nHello World\n") fmt.Fprintf(w, "Path->%s\n", html.EscapeString(r.URL.Path)) fmt.Fprintf(w, "Golang %s\n", runtime.Version()) fmt.Fprintf(w, "%s %s %s %s %d %s\n", runtime.GOOS, hostname, runtime.Version(), when, runtime.NumCPU(), runtime.GOARCH) fmt.Fprintf(w, "headers->\n") keys := make([]string, 0) for it := range r.Header { keys = append(keys, it) } sort.Strings(keys) for it := range keys { fmt.Fprintf(w, "%s: %s\n", keys[it], r.Header.Get(keys[it])) } }) log.Fatal(http.ListenAndServe(":31338", nil)) }
func ExamplePipeline() { client := redis.NewTCPClient(":6379", "", -1) defer client.Close() var set *redis.StatusReq var get *redis.StringReq reqs, err := client.Pipelined(func(c *redis.PipelineClient) { set = c.Set("key1", "hello1") get = c.Get("key2") }) fmt.Println(err, reqs) fmt.Println(set) fmt.Println(get) // Output: <nil> [SET key1 hello1: OK GET key2: (nil)] // SET key1 hello1: OK // GET key2: (nil) }
func NewTracker(redisAddress string) (tracker *Tracker, err error) { password := "" // no password set conn := redis.NewTCPClient(redisAddress, password, -1) defer conn.Close() tracker = &Tracker{ Conn: conn, Notifier: make(data.EventsChannel, 1), Funnels: make(data.EventsChannel, 1), } go tracker.listenForPageviews() go tracker.listenForFunnels() return }
func ExampleTransaction() { client := redis.NewTCPClient(":6379", "", -1) defer client.Close() client.Del("key") multi, err := client.MultiClient() _ = err defer multi.Close() watch := multi.Watch("key") _ = watch.Err() reqs, err := transaction(multi) fmt.Println(err, reqs) // Output: <nil> [SET key 1: OK] }
func main() { var redisAddr = flag.String("redis-addr", "localhost:6379", "redis address") var redisPass = flag.String("redis-pass", "", "redis password") var redisDb = flag.Int("redis-db", 0, "redis database number") var urlPrefix = flag.String("url-prefix", "channel", "URL prefix") var listenAddr = flag.String("listen-addr", "localhost:8080", "listen address") var allowPosts = flag.Bool("allow-posts", true, "allow POSTing to the queue") var keepAlive = flag.Int("keepalive", 10, "seconds between keep-alive messages (0 to disable") var clientRetry = flag.Float64("client-retry", 3600*24, "seconds for the client to wait before reconnecting (0 to use browser defaults)") flag.Parse() log.Print("Redis Address : ", *redisAddr) log.Print("Redis Password : "******"Redis Database : ", *redisDb) log.Print("URL Prefix : ", *urlPrefix) log.Print("Listen Address : ", *listenAddr) log.Print("Allow POSTs : ", *allowPosts) log.Print("Keep-Alive : ", *keepAlive) if *clientRetry > 0.0 { log.Print("Client Retry : ", *clientRetry) clientRetryTime = strconv.Itoa(int(*clientRetry * 1000.0)) } keepAliveTime = time.Duration(*keepAlive) client = redis.NewTCPClient(*redisAddr, *redisPass, int64(*redisDb)) defer client.Close() router := mux.NewRouter() subroute := router.PathPrefix(fmt.Sprintf("/%s/", *urlPrefix)).Subrouter() subroute.HandleFunc("/{queue}", subscriber).Methods("GET") if *allowPosts { subroute.HandleFunc("/{queue}", publisher).Methods("POST") } err := http.ListenAndServe(*listenAddr, router) if err != nil { log.Fatal("http.ListenAndServe:", err) } }
func initRedis(addr string, db int64, pw string) { rds = redis.NewTCPClient(addr, pw, db) ret := rds.ScriptLoad(` local key, value, maxlength = KEYS[1], ARGV[1], tonumber(ARGV[2]) if not maxlength then return {err = "INVALID ARGUMENTS"} end redis.call("RPUSH", key, value) local listlength = redis.call("LLEN", key) if listlength >= maxlength then local start = listlength - maxlength redis.call("LTRIM", key, start, maxlength) end `) rdsCircularBufferHash = ret.Val() }
func Init() { srvAddr := "localhost:6379" Redis = r.NewTCPClient(srvAddr, "", -1) tcpAddr, _ := net.ResolveTCPAddr("tcp", srvAddr) if _, err := net.DialTCP("tcp", nil, tcpAddr); err != nil { fmt.Printf(" [NOTICE]\tRedis server not connected.\n") fmt.Printf(" [NOTICE]\tAttempting to boot up Redis server.\n") response := make(chan bool, 1) go bootRedisServer(response) <-response fmt.Printf(" [NOTICE]\tRedis server has connected.\n") } // clear stale data Redis.FlushDb() }
func ExamplePubSub() { client := redis.NewTCPClient(":6379", "", -1) defer client.Close() pubsub, err := client.PubSubClient() defer pubsub.Close() ch, err := pubsub.Subscribe("mychannel") _ = err subscribeMsg := <-ch fmt.Println(subscribeMsg.Err, subscribeMsg.Name) pub := client.Publish("mychannel", "hello") _ = pub.Err() msg := <-ch fmt.Println(msg.Err, msg.Message) // Output: <nil> subscribe // <nil> hello }
func New(host string, password string, db int64, list string) Log { return Log{ client: redis.NewTCPClient(host, password, db), List: list, } }
var buf string e := websocket.Message.Receive(ws, &buf) if e != nil { fmt.Println(e) break } e = websocket.Message.Send(ws, buf) if e != nil { fmt.Println(e) break } } } var rds *redis.Client = redis.NewTCPClient("localhost:6379", "", 0) func main() { defer rds.Close() router := mux.NewRouter() fmt.Println(rds) router.HandleFunc("/", handler) router.HandleFunc("/static/{path:.*}", staticHandler) router.HandleFunc("/post", newPostHandler).Methods("POST") router.HandleFunc("/post", getPostsHandler).Methods("GET") router.HandleFunc("/post/{id}/comments", newCommentHandler) router.HandleFunc("/post/{id}", postHandler) router.Handle("/ws/", websocket.Handler(websocket_handler)) http.ListenAndServe(":8000", router) }
package main import ( "fmt" "github.com/vmihailenco/redis" "net/http" // "regexp" "github.com/gorilla/mux" "github.com/jameskeane/bcrypt" ) var connectToRedis = func() *redis.Client { password := "" // no password set return redis.NewTCPClient("localhost:6379", password, -1) } func getSecret(user, realm string) string { client := connectToRedis() defer client.Close() return client.HMGet("user:"******"password").Val()[0].(string) } func checkAdm(auth *Basic) bool { if auth != nil { client := connectToRedis() defer client.Close() if checkUserPass(auth.Username, auth.Password, client) { if client.HGet("user:"******"isadmin").Val() == "1" { return true } }