func PutRedisClient(client *redis.Client) {
if RedisClientPool == nil {
RedisClientPool = make(chan *redis.Client, MAX_POOL_SIZE)
}
if len(RedisClientPool) >= MAX_POOL_SIZE {
client.Quit()
return
}
RedisClientPool <- client
}
func handler(p *httputil.ReverseProxy, redisClient *redis.Client) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
hash := hashKey(r)
serializableResponse := SerializableResponse{make(map[string][]string), nil}
s, err := redisClient.Get(hash)
if err != nil { // The request is not cached
rec := httptest.NewRecorder()
log.Println("Non cached: " + hash)
// Perform the real request and cache it
p.ServeHTTP(rec, r)
for k, v := range rec.Header() {
serializableResponse.Header[k] = v
}
serializableResponse.Body = rec.Body.Bytes()
jsonResponse, err := json.Marshal(serializableResponse)
if err != nil {
panic(err)
}
redisClient.Set(hash, jsonResponse)
w.Header().Set("X-Eidetic", "Live request")
} else { // The request is cached
log.Println("Cached!: " + hash)
// Load the cached request
err = json.Unmarshal([]byte(s), &serializableResponse)
if err != nil {
panic(err)
}
w.Header().Set("X-Eidetic", "Cached request")
}
//Copy the data to the actual ResponseWriter
// log.Println("\n\n\nResponse Headers:")
for k, v := range serializableResponse.Header {
w.Header()[k] = v
// log.Println(k + ": ")
// for _, str := range v {
// log.Println(" " + str)
// }
}
w.Write([]byte(serializableResponse.Body))
// log.Println("\nResponse body:\n" + string(serializableResponse.Body))
}
}
func spawnConsumer() error {
var err error
var consumer *redis.Client
consumer = redis.New()
err = consumer.ConnectNonBlock(host, port)
if err != nil {
log.Fatalf("Consumer failed to connect: %s\n", err.Error())
return err
}
log.Println("Consumer connected to redis-server.")
rec := make(chan []string)
log.Printf("Consumer will read exactly 6 messages before quitting.\n")
go consumer.Subscribe(rec, "channel")
var ls []string
for j := 0; j < 6; j++ {
ls = <-rec
log.Printf("Consumer received message[%d]: %v\n", j, strings.Join(ls, ", "))
}
log.Printf("Closing consumer...\n")
consumer.Quit()
return nil
}
//初始化redis连接
//传入配置参数
func Init(config ...*Config) {
config = checkConfig(config)
for i := 0; i < len(config); i++ {
var client *redis.Client
client = redis.New()
err1 := client.Connect(config[i].Host, config[i].Port)
log.Println(config[i].Host+":"+strconv.Itoa(int(config[i].Port)), "Connect ...")
_, err2 := client.Ping()
if err1 != nil || err2 != nil {
log.Println("ERROR: Redis Connect failed!")
os.Exit(0)
}
redisSlice = append(redisSlice, client)
for j := 0; j < len(config[i].Data); j++ {
structRedis[config[i].Data[j]] = client
}
}
}
func (s SerialReader) processSerialData(redisConnection *redis.Client) {
serialConnection := s.newSerialConnection()
reader := bufio.NewReader(serialConnection)
re := regexp.MustCompile("^([^:]+):(.+)$")
for {
reply, err := reader.ReadBytes('\n')
if err != nil {
log.Printf("processSerialData() #1: %s", err)
continue
}
data := strings.TrimSpace(string(reply))
if len(data) == 0 {
continue
}
log.Printf("%s", data)
raw_data := re.FindStringSubmatch(data)
if len(raw_data) == 0 {
continue
}
metrics := strings.Split(raw_data[2], ",")
channel := fmt.Sprintf("rpi-moteino-collector:%s", raw_data[1])
for i := 0; i < len(metrics); i++ {
metric_key_and_value := strings.Split(metrics[i], ":")
if len(metric_key_and_value) != 2 {
continue
}
value := fmt.Sprintf("%s,%d,%s", metric_key_and_value[0], uint64(time.Now().Unix()), metric_key_and_value[1])
_, err := redisConnection.LPush(channel, value)
if err != nil {
log.Printf("processSerialData() #2: %s", err)
}
_, err = redisConnection.Publish(channel, value)
if err != nil {
log.Printf("processSerialData() #3: %s", err)
}
}
_, err = redisConnection.LTrim(channel, 0, 10)
if err != nil {
log.Printf("processSerialData() #4: %s", err)
}
}
}
func main() {
var client *redis.Client
client = redis.New()
client.Connect("localhost", 6379)
s, _ := client.Ping()
fmt.Println(s)
client.Incr("hello")
s, _ = client.Get("hello")
fmt.Println(s)
client.Quit()
}
func spawnPublisher() error {
var err error
var publisher *redis.Client
publisher = redis.New()
err = publisher.Connect(host, port)
if err != nil {
log.Fatalf("Publisher failed to connect: %s\n", err.Error())
return err
}
log.Println("Publisher connected to redis-server.")
log.Println("Publishing some messages...")
publisher.Publish("channel", "Hello world!")
publisher.Publish("channel", "Do you know how to count?")
for i := 0; i < 3; i++ {
publisher.Publish("channel", i)
}
log.Printf("Closing publisher...\n")
publisher.Quit()
return nil
}