dnet_addr parse_addr(const std::string& addr) {
dnet_addr ret;
int port, family;
memset(&ret, 0, sizeof(ret));
ret.addr_len = sizeof(ret.addr);
std::string str_addr(addr);
int err = dnet_parse_addr(const_cast<char *>(str_addr.c_str()), &port, &family);
if (err) {
std::cerr << "Wrong remote addr: " << addr << "\n" << std::endl;
exit(1);
}
ret.family = family;
dnet_fill_addr(&ret, const_cast<char *>(str_addr.c_str()), port, SOCK_STREAM, IPPROTO_TCP);
return ret;
}
void node::add_remote(const char *orig_addr)
{
int port, family;
/*
* addr will be modified, so use this ugly hack
*/
std::string addr(orig_addr);
int err = dnet_parse_addr(const_cast<char *>(addr.c_str()), &port, &family);
if (err)
throw_error(err, "Failed to parse remote addr %s", addr.c_str());
err = dnet_add_state(m_data->node_ptr, const_cast<char *>(addr.c_str()), port, family, 0);
if (err)
throw_error(err, "Failed to add remote addr %s", addr.c_str());
}
dnet_addr parse_addr(const std::string& addr) {
dnet_addr ret;
int port, family;
memset(&ret, 0, sizeof(ret));
ret.addr_len = sizeof(ret.addr);
std::vector<char> tmp_addr(addr.begin(), addr.end());
tmp_addr.push_back('\0');
int err = dnet_parse_addr(tmp_addr.data(), &port, &family);
if (err) {
std::cerr << "Wrong remote addr: " << addr << "\n" << std::endl;
exit(1);
}
ret.family = family;
dnet_fill_addr(&ret, tmp_addr.data(), port, SOCK_STREAM, IPPROTO_TCP);
return ret;
}
void node::add_remote(const std::string &addr)
{
if (!m_data)
throw_error(-EINVAL, "Failed to add remote addr to null node");
int port, family;
/*
* addr will be modified, so use this ugly hack
*/
std::vector<char> addr_tmp;
addr_tmp.reserve(addr.size() + 1);
addr_tmp.assign(addr.begin(), addr.end());
addr_tmp.push_back('\0');
int err = dnet_parse_addr(addr_tmp.data(), &port, &family);
if (err)
throw_error(err, "Failed to parse remote addr %s", addr.c_str());
err = dnet_add_state(m_data->node_ptr, addr_tmp.data(), port, family, 0);
if (err)
throw_error(err, "Failed to add remote addr %s", addr.c_str());
}
int main(int argc, char *argv[])
{
int ch, err;
struct dnet_node *n = NULL;
struct dnet_config cfg;
char *remote_addr = NULL;
int remote_port = -1;
int remote_family = -1;
char *logfile = default_log;
int daemonize = 0;
FILE *log = NULL;
struct dnet_check_request r, *req, *req2;
struct tm tm;
char *file = NULL;
int group_num = 0, *groups;
char *ns = NULL;
int nsize = 0;
struct dnet_session *s;
memset(&cfg, 0, sizeof(struct dnet_config));
cfg.wait_timeout = INT_MAX;
check_logger.log_level = DNET_LOG_INFO;
cfg.check_timeout = 60;
memset(&tm, 0, sizeof(tm));
memset(&r, 0, sizeof(r));
r.thread_num = 1;
while ((ch = getopt(argc, argv, "b:B:DN:f:n:t:u:U:MRm:w:l:dr:g:h")) != -1) {
switch (ch) {
case 'b':
r.blob_start = atoi(optarg);
break;
case 'B':
r.blob_num = atoi(optarg);
break;
case 'N':
ns = optarg;
nsize = strlen(optarg);
break;
case 'f':
file = optarg;
break;
case 'n':
r.thread_num = atoi(optarg);
if (r.thread_num > 1)
fprintf(stderr, "You are going to run your recovery process with %d threads, "
"this can heavily screw up your system performance.\n", r.thread_num);
break;
case 't':
if (!strptime(optarg, "%F %T", &tm)) {
fprintf(stderr, "Invalid timestamp string in -t\n");
check_usage(argv[0]);
return -EINVAL;
}
r.timestamp = mktime(&tm);
break;
case 'u':
if (!strptime(optarg, "%F %T", &tm)) {
fprintf(stderr, "Invalid timestamp string in -u\n");
check_usage(argv[0]);
return -EINVAL;
}
r.updatestamp_start = mktime(&tm);
break;
case 'U':
if (!strptime(optarg, "%F %T", &tm)) {
fprintf(stderr, "Invalid timestamp string in -U\n");
check_usage(argv[0]);
return -EINVAL;
}
r.updatestamp_stop = mktime(&tm);
break;
case 'D':
r.flags |= DNET_CHECK_DRY_RUN;
break;
case 'M':
r.flags |= DNET_CHECK_MERGE;
break;
// case 'F':
// r.flags |= DNET_CHECK_FULL;
// break;
case 'R':
r.flags |= DNET_CHECK_DELETE;
break;
case 'm':
check_logger.log_level = strtoul(optarg, NULL, 0);
break;
case 'w':
cfg.check_timeout = cfg.wait_timeout = atoi(optarg);
break;
case 'l':
logfile = optarg;
break;
case 'd':
daemonize = 1;
break;
case 'r':
err = dnet_parse_addr(optarg, &remote_port, &remote_family);
if (err)
return err;
remote_addr = optarg;
break;
case 'g':
group_num = dnet_parse_groups(optarg, &groups);
if (group_num <= 0)
return -1;
break;
case 'h':
default:
check_usage(argv[0]);
return -1;
}
}
if (!remote_addr) {
fprintf(stderr, "No remote node specified to route requests.\n");
return -ENOENT;
}
log = fopen(logfile, "a");
if (!log) {
err = -errno;
fprintf(stderr, "Failed to open log file %s: %s.\n", logfile, strerror(errno));
return err;
}
if (daemonize) {
if (logfile == default_log) {
fprintf(stderr, "You should specify log file for daemon mode\n");
} else {
dnet_background();
}
}
check_logger.log_private = log;
check_logger.log = dnet_common_log;
cfg.log = &check_logger;
n = dnet_node_create(&cfg);
if (!n)
return -1;
err = dnet_add_state(n, remote_addr, remote_port, remote_family, DNET_CFG_NO_ROUTE_LIST);
if (err)
return err;
s = dnet_session_create(n);
if (!s)
return -ENOMEM;
err = dnet_session_set_ns(s, ns, nsize);
if (err)
return err;
req = &r;
if (file) {
req = dnet_check_gen_request(s, &r, file);
if (!req)
return -EINVAL;
}
if (group_num > 0) {
req2 = malloc(sizeof(struct dnet_check_request) + req->obj_num * sizeof(struct dnet_id) + group_num * sizeof(int));
if (!req2)
return -ENOMEM;
memcpy(req2, req, sizeof(struct dnet_check_request) + req->obj_num * sizeof(struct dnet_id));
memcpy((char *)req2 + sizeof(struct dnet_check_request) + req->obj_num * sizeof(struct dnet_id), groups,
group_num * sizeof(int));
req2->group_num = group_num;
req = req2;
}
return dnet_request_check(s, req);
}
int main(int argc, char *argv[])
{
int ch, err, have_remote = 0, i;
struct dnet_node *n = NULL;
struct dnet_config cfg, rem;
int max_id_idx = 1000, id_idx = 0, group_id = 0;
unsigned char id[max_id_idx][DNET_ID_SIZE];
char *logfile = "/dev/stderr", *notify_file = "/dev/stdout";
FILE *log = NULL, *notify;
memset(&cfg, 0, sizeof(struct dnet_config));
cfg.sock_type = SOCK_STREAM;
cfg.proto = IPPROTO_TCP;
cfg.wait_timeout = 60*60;
notify_logger.log_mask = DNET_LOG_ERROR | DNET_LOG_INFO;
memcpy(&rem, &cfg, sizeof(struct dnet_config));
while ((ch = getopt(argc, argv, "g:m:w:l:I:a:r:h")) != -1) {
switch (ch) {
case 'm':
notify_logger.log_mask = strtoul(optarg, NULL, 0);
break;
case 'w':
cfg.wait_timeout = atoi(optarg);
break;
case 'L':
notify_file = optarg;
break;
case 'l':
logfile = optarg;
break;
case 'I':
if (id_idx < max_id_idx) {
err = dnet_parse_numeric_id(optarg, id[id_idx]);
if (err)
return err;
id_idx++;
}
break;
case 'g':
group_id = atoi(optarg);
break;
case 'a':
err = dnet_parse_addr(optarg, &cfg);
if (err)
return err;
break;
case 'r':
err = dnet_parse_addr(optarg, &rem);
if (err)
return err;
have_remote = 1;
break;
case 'h':
default:
notify_usage(argv[0]);
return -1;
}
}
if (!id_idx) {
fprintf(stderr, "No ID specified to watch.\n");
return -EINVAL;
}
if (!have_remote) {
fprintf(stderr, "No remote node specified to route requests.\n");
return -ENOENT;
}
log = fopen(logfile, "a");
if (!log) {
err = -errno;
fprintf(stderr, "Failed to open log file %s: %s.\n", logfile, strerror(errno));
return err;
}
notify_logger.log_private = log;
notify_logger.log = dnet_common_log;
cfg.log = ¬ify_logger;
notify = fopen(notify_file, "a");
if (!notify) {
err = -errno;
fprintf(stderr, "Failed to open notify file %s: %s.\n", notify_file, strerror(errno));
return err;
}
n = dnet_node_create(&cfg);
if (!n)
return -1;
err = dnet_add_state(n, &rem);
if (err)
return err;
for (i=0; i<id_idx; ++i) {
struct dnet_id raw;
dnet_setup_id(&raw, group_id, id[i]);
err = dnet_request_notification(n, &raw, notify_complete, notify);
}
while (1) {
sleep(1);
}
return 0;
}
void node::parse_config(const std::string &path, struct dnet_config &cfg,
std::list<address> &remotes,
std::vector<int> &groups,
int &log_level)
{
std::ifstream in(path.c_str());
std::string line;
int line_num = 0;
while (std::getline(in, line)) {
boost::trim(line);
line_num++;
if (line.size() < 3 || line.data()[0] == '#')
continue;
std::vector<std::string> strs;
boost::split(strs, line, boost::is_any_of("="));
std::string key = strs[0];
boost::trim(key);
if (strs.size() != 2) {
throw_error(-EIO, "%s: invalid elliptics config: line: %d,"
" key: '%s': string is broken: size: %zu",
path.c_str(), line_num, key.c_str(), strs.size());
}
std::string value = strs[1];
boost::trim(value);
if (key == "remote") {
std::vector<std::string> rem;
boost::split(rem, value, boost::is_any_of(" "));
for (std::vector<std::string>::iterator it = rem.begin(); it != rem.end(); ++it) {
int remote_port, remote_family;
std::string addr_str = *it;
/* XXX: modifies addr_str's content in place */
if (dnet_parse_addr((char *)addr_str.c_str(), &remote_port, &remote_family)) {
throw_error(-EIO, "%s: invalid elliptics config: '%s' "
"%s: invalid elliptics config: line: %d, "
"key: '%s': remote addr is invalid",
path.c_str(), key.c_str(), path.c_str(),
line_num, key.c_str());
}
address addr((char *)addr_str.c_str(), remote_port, remote_family);
remotes.push_back(addr);
}
}
if (key == "groups") {
std::vector<std::string> gr;
boost::split(gr, value, boost::is_any_of(":"));
for (std::vector<std::string>::iterator it = gr.begin(); it != gr.end(); ++it) {
int group = atoi(it->c_str());
if (group != 0)
groups.push_back(group);
}
}
if (key == "check_timeout")
cfg.check_timeout = strtoul(value.c_str(), NULL, 0);
if (key == "wait_timeout")
cfg.wait_timeout = strtoul(value.c_str(), NULL, 0);
if (key == "log_level")
log_level = strtoul(value.c_str(), NULL, 0);
}
}
int main(int argc, char *argv[])
{
int ch, err, i, have_remote = 0;
struct dnet_node *n = NULL;
struct dnet_session *s = NULL;
struct dnet_config cfg, rem;
int max_id_idx = 1000, id_idx = 0;
int timeout;
unsigned char id[max_id_idx][DNET_ID_SIZE];
char *logfile = "/dev/stderr", *statfile = "/dev/stdout";
FILE *log = NULL, *stat;
memset(&cfg, 0, sizeof(struct dnet_config));
cfg.sock_type = SOCK_STREAM;
cfg.proto = IPPROTO_TCP;
cfg.wait_timeout = 60*60;
stat_logger.log_level = DNET_LOG_ERROR;
timeout = 1;
memcpy(&rem, &cfg, sizeof(struct dnet_config));
while ((ch = getopt(argc, argv, "MFAt:m:w:l:I:r:h")) != -1) {
switch (ch) {
case 'M':
stat_mem = 1;
break;
case 'F':
stat_fs = 1;
break;
case 'A':
stat_la = 1;
break;
case 't':
timeout = atoi(optarg);
break;
case 'm':
stat_logger.log_level = strtoul(optarg, NULL, 0);
break;
case 'w':
cfg.wait_timeout = atoi(optarg);
break;
case 'L':
statfile = optarg;
break;
case 'l':
logfile = optarg;
break;
case 'I':
if (id_idx < max_id_idx) {
err = dnet_parse_numeric_id(optarg, id[id_idx]);
if (err)
return err;
id_idx++;
}
break;
case 'r':
err = dnet_parse_addr(optarg, &rem);
if (err)
return err;
have_remote = 1;
break;
case 'h':
default:
stat_usage(argv[0]);
return -1;
}
}
if (!have_remote) {
fprintf(stderr, "No remote node specified to route requests.\n");
return -ENOENT;
}
log = fopen(logfile, "a");
if (!log) {
err = -errno;
fprintf(stderr, "Failed to open log file %s: %s.\n", logfile, strerror(errno));
return err;
}
stat_logger.log_private = log;
stat_logger.log = dnet_common_log;
cfg.log = &stat_logger;
stat = fopen(statfile, "a");
if (!stat) {
err = -errno;
fprintf(stderr, "Failed to open stat file %s: %s.\n", statfile, strerror(errno));
return err;
}
n = dnet_node_create(&cfg);
if (!n)
return -1;
s = dnet_session_create(n);
if (!s)
return -1;
err = dnet_add_state(n, &rem);
if (err)
return err;
while (1) {
struct dnet_id raw;
if (!id_idx) {
err = dnet_request_stat(s, NULL, DNET_CMD_STAT, 0, stat_complete, stat);
if (err < 0)
return err;
}
for (i=0; i<id_idx; ++i) {
dnet_setup_id(&raw, 0, id[i]);
err = dnet_request_stat(s, &raw, DNET_CMD_STAT, 0, stat_complete, stat);
if (err < 0)
return err;
}
sleep(timeout);
}
return 0;
}
