mirror of
https://gitee.com/acl-dev/acl.git
synced 2024-12-15 17:30:53 +08:00
162 lines
3.4 KiB
C++
162 lines
3.4 KiB
C++
/**
|
|
* Copyright (C) 2015-2018
|
|
* All rights reserved.
|
|
*
|
|
* AUTHOR(S)
|
|
* Zheng Shuxin
|
|
* E-mail: zhengshuxin@qiyi.com
|
|
*
|
|
* VERSION
|
|
* Tue 27 Jun 2017 10:43:03 AM CST
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include <signal.h>
|
|
#include "master/master_params.h"
|
|
#include "master/master_api.h"
|
|
#include "manage/http_client.h"
|
|
#include "service_reload.h"
|
|
|
|
#define STATUS_TIMEOUT 503
|
|
|
|
service_reload::service_reload(http_client& client, reload_res_t& res)
|
|
: client_(client)
|
|
, res_(res)
|
|
, proc_count_(0)
|
|
, proc_signaled_(0)
|
|
, servers_finished_(0)
|
|
{
|
|
timeout_ = (long long) acl_var_master_reload_timeo * 1000;
|
|
}
|
|
|
|
bool service_reload::reload_one(const char* path, reload_res_data_t& data)
|
|
{
|
|
data.status = STATUS_TIMEOUT;
|
|
data.path = path;
|
|
data.proc_count = 0;
|
|
data.proc_signaled = 0;
|
|
data.proc_ok = 0;
|
|
data.proc_err = 0;
|
|
|
|
int ret = acl_master_reload(path, &data.proc_count,
|
|
&data.proc_signaled, service_reload_callback, this);
|
|
if (ret < 0)
|
|
{
|
|
data.status = 404;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool service_reload::run(const reload_req_t& req)
|
|
{
|
|
size_t n = 0;
|
|
|
|
if (req.timeout > 0)
|
|
timeout_ = req.timeout * 1000;
|
|
|
|
logger(">>>>timeout_: %lld, %lld<<<", timeout_, req.timeout);
|
|
|
|
acl_event_request_timer(acl_var_master_global_event,
|
|
service_reload_timer, this, timeout_, 0);
|
|
|
|
for (std::vector<reload_req_data_t>::const_iterator
|
|
cit = req.data.begin(); cit != req.data.end(); ++cit)
|
|
{
|
|
reload_res_data_t data;
|
|
if (reload_one((*cit).path.c_str(), data))
|
|
{
|
|
proc_count_ += data.proc_count;
|
|
proc_signaled_ += data.proc_signaled;
|
|
servers_[data.path] = data;
|
|
n++;
|
|
}
|
|
else
|
|
res_.data.push_back(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void service_reload::service_reload_timer(int, ACL_EVENT*, void* ctx)
|
|
{
|
|
service_reload* reload = (service_reload *) ctx;
|
|
reload->on_timeout();
|
|
}
|
|
|
|
void service_reload::service_reload_callback(ACL_MASTER_PROC* proc, int sig,
|
|
int status, void* ctx)
|
|
{
|
|
service_reload* reload = (service_reload *) ctx;
|
|
if (sig != SIGHUP)
|
|
{
|
|
logger_error("not SIGHUP, invalid signum=%d", sig);
|
|
return;
|
|
}
|
|
|
|
std::map<acl::string, reload_res_data_t>::iterator it =
|
|
reload->servers_.find(proc->serv->conf);
|
|
if (it == reload->servers_.end())
|
|
{
|
|
logger_error("not found, path=%s", proc->serv->conf);
|
|
return;
|
|
}
|
|
|
|
if (status == ACL_MASTER_STAT_SIGHUP_OK)
|
|
it->second.proc_ok++;
|
|
else
|
|
{
|
|
reload->res_.status = 500;
|
|
reload->res_.msg = "some services reload failed";
|
|
it->second.proc_err++;
|
|
}
|
|
|
|
if (it->second.proc_ok + it->second.proc_err == it->second.proc_count)
|
|
{
|
|
if (it->second.proc_err > 0)
|
|
it->second.status = 500;
|
|
else
|
|
it->second.status = 200;
|
|
reload->res_.data.push_back(it->second);
|
|
reload->servers_finished_++;
|
|
reload->check_all();
|
|
}
|
|
}
|
|
|
|
void service_reload::check_all(void)
|
|
{
|
|
if (servers_finished_ == servers_.size())
|
|
{
|
|
clean_all();
|
|
client_.on_reload_finish();
|
|
}
|
|
}
|
|
|
|
void service_reload::clean_all(void)
|
|
{
|
|
acl_event_cancel_timer(acl_var_master_global_event,
|
|
service_reload_timer, this);
|
|
for (std::map<acl::string, reload_res_data_t>::iterator
|
|
it = servers_.begin(); it != servers_.end(); ++it)
|
|
{
|
|
acl_master_reload_clean(it->first.c_str());
|
|
}
|
|
}
|
|
|
|
void service_reload::on_timeout(void)
|
|
{
|
|
clean_all();
|
|
|
|
logger("reload timeout reached, timeout=%lld ms", timeout_ / 1000);
|
|
|
|
for (std::map<acl::string, reload_res_data_t>::iterator
|
|
it = servers_.begin(); it != servers_.end(); ++it)
|
|
{
|
|
if (it->second.status == STATUS_TIMEOUT)
|
|
res_.data.push_back(it->second);
|
|
}
|
|
|
|
client_.on_reload_finish();
|
|
}
|