func msetTestSingle(ch chan bool, cn, n int) error {
var err error
addr := utils.Addrcat(host, port)
conn, err := redis.DialTimeout("tcp", addr, 0, 1*time.Second, 1*time.Second)
if err != nil {
log.Printf("redis conn error: %s", err)
return err
}
defer conn.Close()
v := make([]byte, dataSize)
b := make([]interface{}, bucket+1)
b[0] = topicName
for i := 1; i < bucket+1; i++ {
b[i] = v
}
count := n / bucket
for i := 0; i < count; i++ {
start := time.Now()
_, err = conn.Do("MSET", b...)
if err != nil {
log.Printf("set error: c%d %v", cn, err)
} else {
end := time.Now()
duration := end.Sub(start).Seconds()
log.Printf("set succ: %s spend: %.3fms", topicName, duration*1000)
}
}
ch <- true
return nil
}
func getTestSingle(ch chan bool, cn, n int) error {
addr := utils.Addrcat(host, port)
conn, err := redis.DialTimeout("tcp", addr, 0, 1*time.Second, 1*time.Second)
if err != nil {
log.Printf("redis conn error: %s", err)
return err
}
defer conn.Close()
key := topicName + "/" + lineName
for i := 0; i < n; i++ {
start := time.Now()
reply, err := conn.Do("GET", key)
if err != nil {
log.Printf("get error: c%d %v", cn, err)
} else {
rpl, err := redis.Strings(reply, err)
if err != nil {
fmt.Printf("redis.values error: c%d %v\n", cn, err)
return err
}
// fmt.Printf("redis.strings %v\n", v)
end := time.Now()
duration := end.Sub(start).Seconds()
id := rpl[1]
log.Printf("get succ: %s spend: %.3fms", id, duration*1000)
}
}
ch <- true
return nil
}
// NewHTTPEntry returns a new HTTPEntry server
func NewHTTPEntry(host string, port int, messageQueue queue.MessageQueue) (*HTTPEntry, error) {
h := new(HTTPEntry)
addr := utils.Addrcat(host, port)
server := new(http.Server)
server.Addr = addr
server.Handler = h
h.host = host
h.port = port
h.server = server
h.messageQueue = messageQueue
return h, nil
}
func setTest(c, n int) {
ch := make(chan bool)
conn := utils.Addrcat(host, port)
mc := memcache.New(conn)
singleCount := n / c
for i := 0; i < c; i++ {
go setTestSingle(ch, mc, i, singleCount)
}
for i := 0; i < c; i++ {
select {
case <-ch:
log.Printf("set single succ: %s - c%d", topicName, i)
}
}
}
// ListenAndServe implements the ListenAndServe interface
func (h *HTTPEntry) ListenAndServe() error {
addr := utils.Addrcat(h.host, h.port)
l, err := net.Listen("tcp", addr)
if err != nil {
return err
}
stopListener, err := utils.NewStopListener(l)
if err != nil {
return err
}
h.stopListener = stopListener
log.Printf("http entrance serving at %s...", addr)
return h.server.Serve(h.stopListener)
}
// ListenAndServe implements the ListenAndServe interface
func (s *UnitedAdmin) ListenAndServe() error {
addr := utils.Addrcat(s.host, s.port)
l, err := net.Listen("tcp", addr)
if err != nil {
return err
}
stopListener, err := utils.NewStopListener(l)
if err != nil {
return err
}
s.stopListener = stopListener
log.Printf("admin server serving at %s...", addr)
return s.server.Serve(s.stopListener)
}
func initQueue() {
var mc *memcache.Client
conn := utils.Addrcat(host, port)
mc = memcache.New(conn)
err := mc.Add(&memcache.Item{Key: topicName, Value: []byte{}})
if err != nil {
log.Printf("add error: %v", err)
}
fullLineName := topicName + "/" + lineName
err = mc.Add(&memcache.Item{Key: fullLineName, Value: []byte{}})
if err != nil {
log.Printf("add error: %v", err)
}
}
func setTestSingle(ch chan bool, cn, n int) {
var err error
var mc *memcache.Client
conn := utils.Addrcat(host, port)
v := make([]byte, dataSize)
mc = memcache.New(conn)
for i := 0; i < n; i++ {
start := time.Now()
err = mc.Set(&memcache.Item{Key: topicName, Value: v})
if err != nil {
log.Printf("set error: c%d %v", cn, err)
} else {
end := time.Now()
duration := end.Sub(start).Seconds()
log.Printf("set succ: %s spend: %.3fms", topicName, duration*1000)
}
}
ch <- true
}
func getTestSingle(ch chan bool, cn, n int) {
var mc *memcache.Client
conn := utils.Addrcat(host, port)
key := topicName + "/" + lineName
keys := []string{key, "id"}
mc = memcache.New(conn)
for i := 0; i < n; i++ {
start := time.Now()
items, err := mc.GetMulti(keys)
if err != nil {
log.Printf("get error: c%d %v", cn, err)
} else {
end := time.Now()
duration := end.Sub(start).Seconds()
id := string(items["id"].Value)
log.Printf("get succ: %s spend: %.3fms", id, duration*1000)
}
}
ch <- true
}
// NewUnitedAdmin returns a UnitedAdmin
func NewUnitedAdmin(host string, port int, messageQueue queue.MessageQueue) (*UnitedAdmin, error) {
s := new(UnitedAdmin)
s.adminMux = map[string]func(http.ResponseWriter, *http.Request, string){
"/stat": s.statHandler,
"/empty": s.emptyHandler,
"/rm": s.rmHandler,
}
addr := utils.Addrcat(host, port)
server := new(http.Server)
server.Addr = addr
server.Handler = s
s.host = host
s.port = port
s.server = server
s.messageQueue = messageQueue
return s, nil
}
// ListenAndServe implements the ListenAndServe interface
func (r *RedisEntry) ListenAndServe() error {
addr := utils.Addrcat(r.host, r.port)
l, err := net.Listen("tcp", addr)
if err != nil {
return err
}
stopListener, err := utils.NewStopListener(l)
if err != nil {
return err
}
r.stopListener = stopListener
log.Printf("redis entrance serving at %s...", addr)
for {
conn, err := r.stopListener.Accept()
if err != nil {
// log.Printf("Accept failed: %s\n", err)
return err
}
go r.handlerConn(newSession(conn))
}
}
func initQueue() error {
addr := utils.Addrcat(host, port)
conn, err := redis.DialTimeout("tcp", addr, 0, 1*time.Second, 1*time.Second)
if err != nil {
log.Printf("redis conn error: %s", err)
return err
}
defer conn.Close()
_, err = conn.Do("ADD", topicName)
if err != nil {
log.Printf("add error: %v", err)
return err
}
fullLineName := topicName + "/" + lineName
_, err = conn.Do("ADD", fullLineName)
if err != nil {
log.Printf("add error: %v", err)
return err
}
return nil
}
// NewUnitedQueue returns a new UnitedQueue
func NewUnitedQueue(storage store.Storage, ip string, port int, etcdServers []string, etcdKey string) (*UnitedQueue, error) {
topics := make(map[string]*topic)
etcdStop := make(chan bool)
uq := new(UnitedQueue)
uq.topics = topics
uq.storage = storage
uq.etcdStop = etcdStop
if len(etcdServers) > 0 {
selfAddr := utils.Addrcat(ip, port)
uq.selfAddr = selfAddr
etcdClient := etcd.NewClient(etcdServers)
uq.etcdClient = etcdClient
uq.etcdKey = etcdKey
}
err := uq.loadQueue()
if err != nil {
return nil, err
}
go uq.etcdRun()
return uq, nil
}
// ListenAndServe implements the ListenAndServe interface
func (m *McEntry) ListenAndServe() error {
addr := utils.Addrcat(m.host, m.port)
l, err := net.Listen("tcp", addr)
if err != nil {
return err
}
stopListener, err := utils.NewStopListener(l)
if err != nil {
return err
}
m.stopListener = stopListener
log.Printf("mc entrance serving at %s...", addr)
for {
conn, e := m.stopListener.Accept()
if e != nil {
// log.Printf("Accept failed: %s\n", e)
return e
}
go m.handlerConn(conn)
}
}