Rabbitmq heartbea心跳檢測機制原理解析

import pika 
import time 

credit = pika.PlainCredentials(username='cloud', password='cloud')
connection = pika.BlockingConnection(pika.ConnectionParameters(
  host='10.32.1.12', credentials=credit))
channel = connection.channel() 
while True:
  connect_close = connection.is_closed
  connect_open = connection.is_open
  channel_close = channel.is_closed
  channel_open = channel.is_open
  
  print("connection is_closed ", connect_close)
  print("connection is_open ", connect_open)
  print("channel is_closed ", channel_close)
  print("channel is_open ", channel_open)
  print("")
  time.sleep(5)

import pika

while True:
  try:
    connection = pika.BlockingConnection()
    channel = connection.channel()
    channel.basic_consume('test', on_message_callback)
    channel.start_consuming()
  # Don't recover if connection was closed by broker
  except pika.exceptions.ConnectionClosedByBroker:
    break
  # Don't recover on channel errors
  except pika.exceptions.AMQPChannelError:
    break
  # Recover on all other connection errors
  except pika.exceptions.AMQPConnectionError:
    continue

from retry import retry

@retry(pika.exceptions.AMQPConnectionError, delay=5, jitter=(1, 3))
def consume():
  connection = pika.BlockingConnection()
  channel = connection.channel()
  channel.basic_consume('test', on_message_callback)
  try:
    channel.start_consuming()
  # Don't recover connections closed by server
  except pika.exceptions.ConnectionClosedByBroker:
    pass
consume()

start(SupPid, Sock, SendTimeoutSec,
   SendFun, ReceiveTimeoutSec, ReceiveFun) ->
  %%數(shù)據(jù)發(fā)送檢測進程
  {ok, Sender} = start_heartbeater(SendTimeoutSec, SupPid, Sock,
                   SendFun, heartbeat_sender,
                   start_heartbeat_sender),
  %%數(shù)據(jù)接收檢測進程
  {ok, Receiver} = start_heartbeater(ReceiveTimeoutSec, SupPid,
                    Sock, ReceiveFun,
                    heartbeat_receiver,
                    start_heartbeat_receiver),
  {Sender, Receiver}.

start_heartbeat_sender(Sock, TimeoutSec, SendFun) ->
  %% the 'div 2' is there so that we don't end up waiting for
  %% nearly 2 * TimeoutSec before sending a heartbeat in the
  %% boundary case
  heartbeater({Sock, TimeoutSec * 1000 div 2, send_oct, 0,
         fun () -> SendFun(), continue end}).

start_heartbeat_receiver(Sock, TimeoutSec, ReceiveFun) ->
  %% we check for incoming data every interval, and time out after
  %% two checks with no change. As a result we will time out
  %% between 2 and 3 intervals after the last data has been
  %% received
  heartbeater({Sock, TimeoutSec * 1000, recv_oct, 1,
        fun () -> ReceiveFun(), stop end}).

heartbeater({Sock, TimeoutMillisec, 
       StatName, Threshold, Handler} = Params,
      Deb,
      {StatVal, SameCount} = State) ->
  Recurse = fun (State1) -> heartbeater(Params, Deb, State1) end,
  receive
    ...
  %% 定時檢測
  after TimeoutMillisec ->
    case rabbit_net:getstat(Sock, [StatName]) of
      {ok, [{StatName, NewStatVal}]} ->
        %% 收發(fā)數(shù)據(jù)有變化
        if NewStatVal =/= StatVal ->
            %%重新開始檢測
            Recurse({NewStatVal, 0});
          %%未達到指定次數(shù), 發(fā)送為0, 接收為1
          SameCount < Threshold ->
            %%計數(shù)加1, 再次檢測
            Recurse({NewStatVal, SameCount + 1});
          %%heartbeat超時
          true ->
            %%對于發(fā)送檢測超時, 向客戶端發(fā)送heartbeat包
            %%對于接收檢測超時, 向父進程發(fā)送超時通知
            %%由父進程觸發(fā)tcp關閉等操作
            case Handler() of
              %%接收檢測超時
              stop   -> ok;
              %%發(fā)送檢測超時
              continue -> Recurse({NewStatVal, 0})
            end;
      ...