func (s *Server) processAction(e interface{}) {
if strings.Index(GetEventPath(e), models.GetProxyPath(s.top.ProductName)) == 0 {
// proxy event, should be order for me to suicide
s.handleProxyCommand()
return
}
// re-watch
nodes, err := s.top.WatchChildren(models.GetWatchActionPath(s.top.ProductName), s.evtbus)
if err != nil {
log.Fatal(errors.ErrorStack(err))
}
seqs, err := models.ExtraSeqList(nodes)
if err != nil {
log.Fatal(errors.ErrorStack(err))
}
if len(seqs) == 0 || !s.top.IsChildrenChangedEvent(e) {
return
}
// get last pos
index := -1
for i, seq := range seqs {
if s.lastActionSeq < seq {
index = i
break
}
}
if index < 0 {
return
}
actions := seqs[index:]
for _, seq := range actions {
exist, err := s.top.Exist(path.Join(s.top.GetActionResponsePath(seq), s.pi.ID))
if err != nil {
log.Fatal(errors.ErrorStack(err))
}
if exist {
continue
}
if s.checkAndDoTopoChange(seq) {
s.responseAction(int64(seq))
}
}
s.lastActionSeq = seqs[len(seqs)-1]
}
func NewServer(conf *Conf) *Server {
log.Infof("start with configuration: %+v", conf)
f := func(addr string) (*redisconn.Conn, error) {
return newRedisConn(addr, conf.NetTimeout, RedisConnReaderSize, RedisConnWiterSize, conf.StoreAuth)
}
s := &Server{
conf: conf,
evtbus: make(chan interface{}, EventBusNum),
top: topo.NewTopo(conf.ProductName, conf.CoordinatorAddr, conf.f, conf.Coordinator),
counter: stats.NewCounters("router"),
lastActionSeq: -1,
startAt: time.Now(),
moper: newMultiOperator(conf.Addr, conf.ProxyAuth),
reqCh: make(chan *PipelineRequest, PipelineRequestNum),
pools: redisconn.NewPools(PoolCapability, f),
pipeConns: make(map[string]*taskRunner),
bufferedReq: list.New(),
}
s.pi.ID = conf.ProxyID
s.pi.State = models.PROXY_STATE_OFFLINE
addr := conf.Addr
addrs := strings.Split(addr, ":")
if len(addrs) != 2 {
log.Fatalf("bad addr %s", addr)
}
hname, err := os.Hostname()
if err != nil {
log.Fatal("get host name failed", err)
}
s.pi.Addr = hname + ":" + addrs[1]
debugVarAddr := conf.HTTPAddr
debugVarAddrs := strings.Split(debugVarAddr, ":")
if len(debugVarAddrs) != 2 {
log.Fatalf("bad debugVarAddr %s", debugVarAddr)
}
s.pi.DebugVarAddr = hname + ":" + debugVarAddrs[1]
s.pi.Pid = os.Getpid()
s.pi.StartAt = time.Now().String()
log.Infof("proxy_info:%+v", s.pi)
stats.Publish("evtbus", stats.StringFunc(func() string {
return strconv.Itoa(len(s.evtbus))
}))
stats.Publish("startAt", stats.StringFunc(func() string {
return s.startAt.String()
}))
s.RegisterAndWait(true)
s.registerSignal()
_, err = s.top.WatchChildren(models.GetWatchActionPath(conf.ProductName), s.evtbus)
if err != nil {
log.Fatal(errors.ErrorStack(err))
}
s.FillSlots()
// start event handler
go s.handleTopoEvent()
go s.dumpCounter()
log.Info("proxy start ok")
return s
}
func (s *testProxyRouterSuite) initEnv(c *C) {
go once.Do(func() {
conn = zkhelper.NewConn()
conf = &Conf{
ProductName: "test",
CoordinatorAddr: "localhost:2181",
NetTimeout: 5,
f: func(string) (zkhelper.Conn, error) { return conn, nil },
Proto: "tcp4",
ProxyID: "proxy_test",
Addr: ":19000",
HTTPAddr: ":11000",
ProxyAuth: proxyAuth,
StoreAuth: storeAuth,
}
// init action path
prefix := models.GetWatchActionPath(conf.ProductName)
err := models.CreateActionRootPath(conn, prefix)
c.Assert(err, IsNil)
// init slot
err = models.InitSlotSet(conn, conf.ProductName, 1024)
c.Assert(err, IsNil)
// init server group
g1 := models.NewServerGroup(conf.ProductName, 1)
g1.Create(conn)
g2 := models.NewServerGroup(conf.ProductName, 2)
g2.Create(conn)
s1 := models.NewServer(models.SERVER_TYPE_MASTER, s.s1.addr)
s2 := models.NewServer(models.SERVER_TYPE_MASTER, s.s2.addr)
g1.AddServer(conn, s1, storeAuth)
g2.AddServer(conn, s2, storeAuth)
// set slot range
err = models.SetSlotRange(conn, conf.ProductName, 0, 511, 1, models.SLOT_STATUS_ONLINE)
c.Assert(err, IsNil)
err = models.SetSlotRange(conn, conf.ProductName, 512, 1023, 2, models.SLOT_STATUS_ONLINE)
c.Assert(err, IsNil)
go func() { //set proxy online
time.Sleep(3 * time.Second)
err := models.SetProxyStatus(conn, conf.ProductName, conf.ProxyID, models.PROXY_STATE_ONLINE)
c.Assert(err, IsNil)
time.Sleep(2 * time.Second)
proxyMutex.Lock()
defer proxyMutex.Unlock()
pi := ss.getProxyInfo()
c.Assert(pi.State, Equals, models.PROXY_STATE_ONLINE)
}()
proxyMutex.Lock()
ss = NewServer(conf)
proxyMutex.Unlock()
ss.Run()
})
waitonce.Do(func() {
time.Sleep(10 * time.Second)
})
}