trafficserver的ICP查询流程源码注释

最新推荐文章于 2020-09-18 11:56:23 发布

拉里山姆

最新推荐文章于 2020-09-18 11:56:23 发布

阅读量802

点赞数

分类专栏： Apache Traffic Server

Apache Traffic Server 专栏收录该内容

41 篇文章 5 订阅

订阅专栏

原创作品，允许转载，转载时请务必以超链接形式标明文章原始出处、作者信息和本声明。否则将追究法律责任。 http://chenpiaoping.blog.51cto.com/5631143/1369287

上面说过类ICPProcessorExt对外提供的接口有两个：start()和ICPQuery(),start()的功能是初始化并启动ICP模块，这个上面已经分析完了，剩下的就是ICPQuery()了，该函数的功能是执行一次ICP的查询。

ICPProcessor.cc中
Action *
ICPProcessorExt::ICPQuery(Continuation * c, URL * url)
{
//直接调用ICPProcessor的ICPQuery()函数
return _ICPpr->ICPQuery(c, url);
}

ICPProcessorExt::ICPQuery()--->ICPProcessor::ICPQuery()
该函数的功能是创建和初始化表示ICP查询请求的continuation，设置handler，然后立马调度之执行

Action *
ICPProcessor::ICPQuery(Continuation * c, URL * url)
{
//入参为上层continuation：HttpSM
EThread *thread = this_ethread();
ProxyMutex *mutex = thread->mutex;
//创建并初始化表示ICP查询请求的continuation：ICPRequestCont
ICPRequestCont *rc = new(ICPRequestCont_allocator.alloc()) ICPRequestCont(this, c, url);
ICP_INCREMENT_DYN_STAT(icp_query_requests_stat);
//设置启动时间
rc->SetRequestStartTime();
//设置ICPRequestCont的handler为ICPRequestCont::ICPRequestEvent，并立马调度执行
SET_CONTINUATION_HANDLER(rc, (ICPRequestContHandler) & ICPRequestCont::ICPRequestEvent);
eventProcessor.schedule_imm(rc, ET_ICP);
//返回上层continuation
return rc->GetActionPtr();
}
ICPProcessorExt::ICPQuery()--->ICPProcessor::ICPQuery()--->ICPRequestCont::ICPRequestEvent()
该函数的功能是进入ICP的状态机进行ICP查询请求操作，最后根据结果判断是否完成，如果完成则释放该continuation,否则是否继续进行ICP查询操作
int
ICPRequestCont::ICPRequestEvent(int event, Event * e)
{
ink_assert(event == NET_EVENT_DATAGRAM_WRITE_COMPLETE ||
event == NET_EVENT_DATAGRAM_WRITE_ERROR ||
event == EVENT_IMMEDIATE || event == EVENT_INTERVAL || event == ICP_RESPONSE_MESSAGE);
if ((event == NET_EVENT_DATAGRAM_WRITE_COMPLETE)
|| (event == NET_EVENT_DATAGRAM_WRITE_ERROR)) {
ink_assert(npending_actions > 0);
remove_from_pendingActions((Action *) e);
return EVENT_DONE;
}
switch (_next_state) {
case ICP_START:
case ICP_OFF_TERMINATE:
case ICP_QUEUE_REQUEST:
case ICP_AWAITING_RESPONSE:
case ICP_DEQUEUE_REQUEST:
case ICP_POST_COMPLETION:
case ICP_REQUEST_NOT_ACTIVE:
{
//进入ICP状态机进行ICP查询操作
if (ICPStateMachine(event, (void *) e) == EVENT_CONT) {
eventProcessor.schedule_in(this, HRTIME_MSECONDS(RETRY_INTERVAL), ET_ICP);
return EVENT_CONT;
} else if (_next_state == ICP_DONE) {
delete this;
break;
} else {
break;
}
}
case ICP_DONE:
default:
ink_release_assert(0);
}
return EVENT_DONE;
}
ICPProcessorExt::ICPQuery()--->ICPProcessor::ICPQuery()--->ICPRequestCont::ICPRequestEvent()--->ICPRequestCont::ICPStateMachine()
该函数的功能是处理一次ICP查询请求的完整过程，是使用状态机来实现的，ICP请求的所有状态以及每个状态的处理如下：
ICP_START：判断是否允许发送IC查询，构建ICP查询奇请求报文，切换到ICP_QUEUE_REQUEST状态
ICP_OFF_TERMINATE：ICP查询终止处理，切换到ICP_DONE状态
ICP_QUEUE_REQUEST：把该continuation加到ICP请求队列，从当前发送的peer开始向所有发送列表上的peer发送ICP请求报文：组播，设置超时处理，切换到ICP_AWAITING_RESPONSE状态
ICP_AWAITING_RESPONSE：遍历父peer列表，寻找有响应的peer直到找到，切换到ICP_DEQUEUE_REQUEST状态
ICP_DEQUEUE_REQUEST：从ICP请求队列中删除该continuation，切换到ICP_POST_COMPLETION状态
ICP_POST_COMPLETION：通知上层（POST）处理，切换到ICP_WAIT_SEND_COMPLETE状态
ICP_WAIT_SEND_COMPLETE：切换到ICP_REQUEST_NOT_ACTIVE状态
ICP_REQUEST_NOT_ACTIVE：释放相应结构
ICP_DONE：nothing

int
ICPRequestCont::ICPStateMachine(int event, void *d)
{
ICPConfiguration *ICPcf = _ICPpr->GetConfig();
ip_port_text_buffer ipb;
while (1) {
switch (_next_state) {
case ICP_START:
{
if (_act.cancelled) {
_next_state = ICP_DONE;
return EVENT_DONE;
}
if (!_ICPpr->Lock())
return EVENT_CONT;
if (_ICPpr->AllowICPQueries() && (ICPcf->globalConfig()->ICPconfigured() == ICP_MODE_SEND_RECEIVE)) {
if (_url->valid()) {
int host_len;
const char *host = _url->host_get(&host_len);
if (ptr_len_casecmp(host, host_len, "127.0.0.1") == 0 || ptr_len_casecmp(host, host_len, "localhost") == 0) {
_ICPpr->Unlock();
_next_state = ICP_OFF_TERMINATE;
Debug("icp", "[ICP_START] NULL/localhost URL ignored Id=%d", _sequence_number);
break;
}
}
_ICPpr->IncPendingQuery();
_ICPpr->Unlock();
char *urlstr = _url->string_get(NULL);
int urlstr_len = strlen(urlstr) + 1;
int status = BuildICPMsg(ICP_OP_QUERY,
_sequence_number = ICPReqSeqNumber(),
0 /* optflags */ , 0 /* optdata */ ,
0 /* shostid */ ,
(void *) urlstr, urlstr_len,
&_sendMsgHdr, _sendMsgIOV,
&_ICPmsg);
ink_assert(status == 0);
Debug("icp", "[ICP_START] ICP_OP_QUERY for [%s], Id=%d", urlstr, _sequence_number);
_next_state = ICP_QUEUE_REQUEST;
break;
} else {
ICP_INCREMENT_DYN_STAT(icp_start_icpoff_stat);
_ICPpr->Unlock();
_next_state = ICP_OFF_TERMINATE;
break;
}
}
case ICP_OFF_TERMINATE:
{
if (!MUTEX_TAKE_TRY_LOCK_FOR(mutex, this_ethread(), _cont)) {
return EVENT_CONT;
}
Debug("icp", "[ICP_OFF_TERMINATE] Id=%d", _sequence_number);
if (!_act.cancelled) {
_cont->handleEvent(_ret_status, (void *) &_ret_sockaddr);
}
MUTEX_UNTAKE_LOCK(mutex, this_ethread());
_next_state = ICP_DONE;
return EVENT_DONE;
}
case ICP_QUEUE_REQUEST:
{
int ret = AddICPRequest(_sequence_number, this);
ink_assert(ret == 0);
int bias = _ICPpr->GetStartingSendPeerBias();
int SendPeers = _ICPpr->GetSendPeers();
npending_actions = 0;
while (SendPeers > 0) {
Peer *P = _ICPpr->GetNthSendPeer(SendPeers, bias);
if (!P->IsOnline()) {
SendPeers--;
continue;
}
int was_expected = P->ExpectedReplies(&_expected_replies_list);
_expected_replies += was_expected;
npending_actions++;
Action *a = P->SendMsg_re(this, P, &_sendMsgHdr, NULL);
if (!a) {
a = ACTION_IO_ERROR;
}
if (a != ACTION_IO_ERROR) {
if (a != ACTION_RESULT_DONE) {
if (!pendingActions) {
pendingActions = NEW(new DynArray<Action *>(&default_action));
}
(*pendingActions) (npending_actions) = a;
}
P->LogSendMsg(&_ICPmsg, NULL); // log as send query
Debug("icp", "[ICP_QUEUE_REQUEST] Id=%d send query to [%s]",
_sequence_number, ats_ip_nptop(P->GetIP(), ipb, sizeof(ipb)));
} else {
_expected_replies_list.ClearBit(P->GetPeerID());
_expected_replies -= was_expected;
ICP_INCREMENT_DYN_STAT(send_query_partial_write_stat);
Debug("icp_warn",
"ICP query send, res=%d, ip=%s", ntohs(_ICPmsg.h.msglen),
ats_ip_ntop(P->GetIP(), ipb, sizeof(ipb)));
}
SendPeers--;
}
Debug("icp", "[ICP_QUEUE_REQUEST] Id=%d expected replies=%d", _sequence_number, _expected_replies);
if (!_expected_replies) {
ICP_INCREMENT_DYN_STAT(icp_queries_no_expected_replies_stat);
_next_state = ICP_DEQUEUE_REQUEST;
break;
}
ICP_SUM_DYN_STAT(total_udp_send_queries_stat, _expected_replies);
int tval = _ICPpr->GetConfig()->globalConfig()->ICPqueryTimeout();
_timeout = eventProcessor.schedule_in(this, HRTIME_SECONDS(tval), ET_ICP);
_next_state = ICP_AWAITING_RESPONSE;
return EVENT_DONE;
}
case ICP_AWAITING_RESPONSE:
{
Debug("icp", "[ICP_AWAITING_RESPONSE] Id=%d", _sequence_number);
ink_assert(d);
ICPRequestEventArgs_t dummyArgs;
ICPRequestEventArgs_t *args = 0;

if (event == ICP_RESPONSE_MESSAGE) {
args = (ICPRequestEventArgs_t *) d;
} else if (event == EVENT_INTERVAL) {
memset((void *) &dummyArgs, 0, sizeof(dummyArgs));
args = &dummyArgs;
} else {
ink_release_assert(0);
}
if (ICPResponseMessage(event, args->rICPmsg, args->peer) == EVENT_DONE) {
_next_state = ICP_DEQUEUE_REQUEST;
break;
} else {
return EVENT_DONE;
}
}
case ICP_DEQUEUE_REQUEST:
{
int ret = RemoveICPRequest(_sequence_number);
Debug("icp", "[ICP_DEQUEUE_REQUEST] Id=%d", _sequence_number);
ink_assert(ret == 0);
_next_state = ICP_POST_COMPLETION;
break;
}
case ICP_POST_COMPLETION:
{
if (!MUTEX_TAKE_TRY_LOCK_FOR(mutex, this_ethread(), _cont)) {
return EVENT_CONT;
}
Debug("icp", "[ICP_POST_COMPLETION] Id=%d", _sequence_number);
if (!_act.cancelled) {
_cont->handleEvent(_ret_status, (void *) &_ret_sockaddr);
}
MUTEX_UNTAKE_LOCK(mutex, this_ethread());
ICP_SUM_DYN_STAT(total_icp_request_time_stat, (ink_get_hrtime() - _start_time));

_next_state = ICP_WAIT_SEND_COMPLETE;
break;
}
case ICP_WAIT_SEND_COMPLETE:
{
if (npending_actions > 0) {
Debug("icp", "[ICP_WAIT_SEND_COMPLETE] Id=%d active=%d", _sequence_number, npending_actions);
} else {
_next_state = ICP_REQUEST_NOT_ACTIVE;
break;
}
}
break;
case ICP_REQUEST_NOT_ACTIVE:
{
Debug("icp", "[ICP_REQUEST_NOT_ACTIVE] Id=%d", _sequence_number);
_sequence_number = 0;
if (!_ICPpr->Lock())
return EVENT_CONT;
_ICPpr->DecPendingQuery();
_ICPpr->Unlock();
_next_state = ICP_DONE;
return EVENT_DONE;
}
case ICP_DONE:
default:
ink_release_assert(0);
}
}
}