Golang rolling_log.Printf函數代碼示例

func (p *fakeServer) Dispatch(r *Request) error {
	log.Printf("Request SeqId: %d, MethodName: %s\n", r.Request.SeqId, r.Request.Name)
	r.Wait.Add(1)
	go func() {
		time.Sleep(time.Millisecond)
		r.Response.Data = []byte(string(r.Request.Data))

		typeId, _, seqId, _ := DecodeThriftTypIdSeqId(r.Response.Data)
		log.Printf(Green("TypeId: %d, SeqId: %d\n"), typeId, seqId)
		r.Wait.Done()
	}()
	//	r.RestoreSeqId()
	//	r.Wait.Done()
	return nil
}

//
// 確保Socket成功連接到後端服務器
//
func (bc *BackendConn) ensureConn() (transport thrift.TTransport, err error) {
	// 1. 創建連接(隻要IP沒有問題， err一般就是空)
	timeout := time.Second * 5
	if strings.Contains(bc.addr, ":") {
		transport, err = thrift.NewTSocketTimeout(bc.addr, timeout)
	} else {
		transport, err = rpc_utils.NewTUnixDomainTimeout(bc.addr, timeout)
	}
	log.Printf(Cyan("[%s]Create Socket To: %s"), bc.service, bc.addr)

	if err != nil {
		log.ErrorErrorf(err, "[%s]Create Socket Failed: %v, Addr: %s", err, bc.service, bc.addr)
		// 連接不上，失敗
		return nil, err
	}

	// 2. 隻要服務存在，一般不會出現err
	sleepInterval := 1
	err = transport.Open()
	for err != nil && !bc.IsMarkOffline.Get() {
		log.ErrorErrorf(err, "[%s]Socket Open Failed: %v, Addr: %s", bc.service, err, bc.addr)

		// Sleep: 1, 2, 4這幾個間隔
		time.Sleep(time.Duration(sleepInterval) * time.Second)

		if sleepInterval < 4 {
			sleepInterval *= 2
		}
		err = transport.Open()
	}
	return transport, err
}

// 配對 Request, resp, err
// PARAM: resp []byte 為一幀完整的thrift數據包
func (bc *BackendConnLB) setResponse(r *Request, data []byte, err error) error {
	//	log.Printf("#setResponse:  data: %v", data)
	// 表示出現錯誤了
	if data == nil {
		log.Printf("No Data From Server, error: %v\n", err)
		r.Response.Err = err
	} else {
		// 從resp中讀取基本的信息
		typeId, method, seqId, err := DecodeThriftTypIdSeqId(data)

		// 解碼錯誤，直接報錯
		if err != nil {
			log.ErrorErrorf(err, "Decode SeqId Error: %v", err)
			return err
		}

		if typeId == MESSAGE_TYPE_STOP {
			// 不再接受新的輸入
			// 直接來自後端的服務(不遵循: Request/Reply模型)
			bc.MarkConnActiveFalse()
			return nil
		}

		// 找到對應的Request

		req := bc.seqNumRequestMap.Pop(seqId)

		// 如果是心跳，則OK
		if typeId == MESSAGE_TYPE_HEART_BEAT {
			bc.hbLastTime.Set(time.Now().Unix())
			return nil
		}

		if req == nil {
			log.Errorf("#setResponse not found, seqId: %d", seqId)
			return nil
		} else {

			if req.Response.SeqId != seqId {
				log.Errorf("Data From Server, SeqId not match, Ex: %d, Ret: %d", req.Request.SeqId, seqId)
			}
			r = req
			r.Response.TypeId = typeId
			if req.Request.Name != method {
				data = nil
				err = req.NewInvalidResponseError(method, "conn_lb")
			}
		}
	}

	r.Response.Data, r.Response.Err = data, err
	// 還原SeqId
	if data != nil {
		r.RestoreSeqId()
	}

	r.Wait.Done()
	return err
}

func (s *BackService) StateChanged(conn *BackendConn) {
	//	log.Printf(Cyan("[%s]StateChanged: %s, Index: %d, Count: %d, IsConnActive: %t"),
	//		s.serviceName, conn.addr, conn.Index, len(s.activeConns),
	//		conn.IsConnActive.Get())

	s.activeConnsLock.Lock()
	defer s.activeConnsLock.Unlock()

	if conn.IsConnActive.Get() {
		// 上線: BackendConn
		log.Printf(Cyan("[%s]MarkConnActiveOK: %s, Index: %d, Count: %d"),
			s.serviceName, conn.addr, conn.Index, len(s.activeConns))

		if conn.Index == INVALID_ARRAY_INDEX {
			conn.Index = len(s.activeConns)
			s.activeConns = append(s.activeConns, conn)

			log.Printf(Green("[%s]Add BackendConn to activeConns: %s, Total Actives: %d"),
				s.serviceName, conn.Addr(), len(s.activeConns))
		}
	} else {
		// 下線BackendConn(急速執行
		connIndex := conn.Index
		if conn.Index != INVALID_ARRAY_INDEX {
			lastIndex := len(s.activeConns) - 1

			// 將最後一個元素和當前的元素交換位置
			if lastIndex != conn.Index {

				lastConn := s.activeConns[lastIndex]
				s.activeConns[conn.Index] = lastConn
				lastConn.Index = conn.Index
			}

			s.activeConns[lastIndex] = nil
			conn.Index = INVALID_ARRAY_INDEX

			// slice
			s.activeConns = s.activeConns[0:lastIndex]
			log.Printf(Red("[%s]Remove BackendConn From activeConns: %s, Remains: %d"),
				s.serviceName, conn.Addr(), len(s.activeConns))
		}
		log.Printf(Red("[%s]Remove BackendConn From activeConns: %s, Index: %d"),
			s.serviceName, conn.Addr(), connIndex)
	}
}

//
// 後端如何處理一個Request
//
func (s *Router) Dispatch(r *Request) error {
	backService := s.GetBackService(r.Service)
	if backService == nil {
		log.Printf(Cyan("Service Not Found for: %s.%s\n"), r.Service, r.Request.Name)
		r.Response.Data = GetServiceNotFoundData(r)
		return nil
	} else {
		return backService.HandleRequest(r)
	}
}

//
// MarkOffline發生場景:
// 1. 後端服務即將下線，預先通知
// 2. 後端服務已經掛了，zk檢測到
//
// BackendConn 在這裏暫時理解關閉conn, 而是從 backend_service_proxy中下線當前的conn,
// 然後conn的關閉根據 心跳&Conn的讀寫異常來判斷; 因此 IsConnActive = false 情況下，心跳不能關閉
//
func (bc *BackendConn) MarkOffline() {
	if !bc.IsMarkOffline.Get() {
		log.Printf(Magenta("[%s]BackendConn: %s MarkOffline"), bc.service, bc.addr)
		bc.IsMarkOffline.Set(true)

		// 不再接受(來自backend_service_proxy的)新的輸入
		bc.MarkConnActiveFalse()

		close(bc.input)
	}
}

func (bc *BackendConn) MarkConnActiveFalse() {
	if bc.IsConnActive.Get() {
		// 從Active切換到非正常狀態
		bc.IsConnActive.Set(false)

		if bc.delegate != nil {
			bc.delegate.StateChanged(bc) // 通知其他人狀態出現問題
		}

		// 日誌延後, 控製信息盡快生效
		log.Printf(Red("[%s]MarkConnActiveFalse: %s, %p"), bc.service, bc.addr, bc.delegate)
	}
}

// run之間 transport剛剛建立，因此服務的可靠性比較高
func (bc *BackendConnLB) Run() {
	log.Printf(Green("[%s]Add New BackendConnLB: %s"), bc.serviceName, bc.address)

	// 1. 首先BackendConn將當前 input中的數據寫到後端服務中
	err := bc.loopWriter()

	// 2. 從Active切換到非正常狀態, 同時不再從backend_service_lb接受新的任務
	//    可能出現異常，也可能正常退出(反正不幹活了)
	bc.MarkConnActiveFalse()

	log.Printf(Red("[%s]Remove Faild BackendConnLB: %s"), bc.serviceName, bc.address)

	if err == nil {
		// bc.input被關閉了，應該就沒有 Request 了
	} else {
		// 如果出現err, 則將bc.input中現有的數據都flush回去（直接報錯)
		for i := len(bc.input); i != 0; i-- {
			r := <-bc.input
			bc.setResponse(r, nil, err)
		}
	}

}

func NewThriftRpcServer(config *Config, processor thrift.TProcessor) *ThriftRpcServer {
	log.Printf("FrontAddr: %s\n", Magenta(config.FrontendAddr))

	return &ThriftRpcServer{
		config:       config,
		ZkAddr:       config.ZkAddr,
		ProductName:  config.ProductName,
		ServiceName:  config.Service,
		FrontendAddr: config.FrontendAddr,
		Verbose:      config.Verbose,
		Processor:    processor,
	}

}

func NewNonBlockSessionSize(c thrift.TTransport, address string, verbose bool,
	lastRequestTime *atomic2.Int64, bufsize int, timeout int) *NonBlockSession {
	s := &NonBlockSession{
		RemoteAddress:            address,
		lastRequestTime:          lastRequestTime,
		verbose:                  verbose,
		TBufferedFramedTransport: NewTBufferedFramedTransport(c, time.Microsecond*100, 20),
	}

	// 還是基於c net.Conn進行讀寫，隻是采用Redis協議進行編碼解碼
	// Reader 處理Client發送過來的消息
	// Writer 將後端服務的數據返回給Client
	log.Printf(Green("Session From Proxy [%s] created"), address)
	return s
}

//
// 先寫入數據，然後再Flush Transport
//
func (p *TBufferedFramedTransport) FlushBuffer(force bool) error {
	size := p.Buffer.Len()

	// 沒有有效的數據，直接返回
	if size == 0 {
		return nil
	}
	// TODO: 待優化
	force = true

	// 1. 將p.buf的大小以BigEndian模式寫入: buf中
	buf := p.LenghW[:4]
	binary.BigEndian.PutUint32(buf, uint32(size))

	//	log.Printf("----> Frame Size: %d, %v\n", size, buf)
	// 然後transport中先寫入: 長度信息
	_, err := p.Writer.Write(buf)
	if err != nil {
		return thrift.NewTTransportExceptionFromError(err)
	}

	// 2. 然後繼續寫入p.buf中的數據
	if size > 0 {
		var (
			n   int64
			err error
		)
		// 如果 err == io.ErrShortWrite， p.Writer中也有buffer, 因此可以不用考慮異常
		if n, err = p.Buffer.WriteTo(p.Writer); err != nil {
			log.ErrorErrorf(err, "Error Flushing Expect Write: %d, but %d\n",
				size, n)
			return thrift.NewTTransportExceptionFromError(err)
		}
		if n < int64(size) {
			log.Printf(Red("Buffer Write Not Finished"))
		}
	}

	p.nbuffered++

	// Buffer重新開始處理數據
	p.Buffer.Reset()

	// Flush Buffer
	return p.flushTransport(force)
}

// 處理所有的等待中的請求
func (bc *BackendConnLB) flushRequests(err error) {
	// 告訴BackendService, 不再接受新的請求
	bc.MarkConnActiveFalse()

	seqRequest := bc.seqNumRequestMap.Purge()

	for _, request := range seqRequest {
		if request.Request.TypeId == MESSAGE_TYPE_HEART_BEAT {
			// 心跳出錯了，則直接直接跳過
		} else {
			log.Printf(Red("Handle Failed Request: %s.%s"), request.Service, request.Request.Name)
			request.Response.Err = err
			request.Wait.Done()
		}
	}

	// 關閉輸入
	close(bc.input)

}

//
// 不斷建立到後端的邏輯，負責: BackendConn#input到redis的數據的輸入和返回
//
func (bc *BackendConn) Run() {

	for k := 0; !bc.IsMarkOffline.Get(); k++ {

		// 1. 首先BackendConn將當前 input中的數據寫到後端服務中
		transport, err := bc.ensureConn()
		if err != nil {
			log.ErrorErrorf(err, "[%s]BackendConn#ensureConn error: %v", bc.service, err)
			return
		}

		connOver := &sync.WaitGroup{}
		c := NewTBufferedFramedTransport(transport, 100*time.Microsecond, 20)

		bc.MarkConnActiveOK() // 準備接受數據
		connOver.Add(1)
		bc.loopReader(c, connOver) // 異步(讀取來自後端服務器的返回數據)
		// 2. 將 bc.input 中的請求寫入 後端的Rpc Server
		err = bc.loopWriter(c) // 同步

		// 3. 停止接受Request
		bc.MarkConnActiveFalse()

		// 等待Conn正式關閉
		connOver.Wait()

		// 4. 將bc.input中剩餘的 Request直接出錯處理
		if err == nil {
			log.Printf(Red("[%s]BackendConn#loopWriter normal Exit..."), bc.service)
			break
		} else {
			// 對於尚未處理的Request, 直接報錯
			for i := len(bc.input); i != 0; i-- {
				r := <-bc.input
				bc.setResponse(r, nil, err)
			}
		}
	}
}

// 處理來自Client的請求
func (s *Session) handleRequest(request []byte, d Dispatcher) (*Request, error) {
	// 構建Request
	if s.verbose {
		log.Printf("HandleRequest: %s", string(request))
	}
	r, err := NewRequest(request, true)
	if err != nil {
		return r, err
	}

	// 增加統計
	s.LastOpUnix = time.Now().Unix()
	s.Ops++
	if r.Request.TypeId == MESSAGE_TYPE_HEART_BEAT {
		HandleProxyPingRequest(r) // 直接返回數據
		return r, nil
	}

	// 交給Dispatch
	// Router
	return r, d.Dispatch(r)
}

func (s *BackService) Stop() {
	// 標誌停止
	s.stop.Set(true)
	// 觸發一個事件（之後ServiceNodes也不再監控)
	s.evtbus <- true
	go func() {
		// TODO:
		for true {
			now := time.Now().Unix()
			if now-s.lastRequestTime.Get() > 10 {
				break
			} else {
				time.Sleep(time.Second)
			}
		}
		for len(s.activeConns) > 0 {
			s.activeConns[0].MarkOffline()
		}

		log.Printf(Red("Mark All Connections Off: %s"), s.serviceName)

	}()
}