136 lines
3.2 KiB
C++
136 lines
3.2 KiB
C++
// Copyright (c) Vitaliy Filippov, 2019+
|
|
// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
|
|
|
|
#include <unistd.h>
|
|
#include <assert.h>
|
|
|
|
#include "messenger.h"
|
|
|
|
void osd_messenger_t::cancel_osd_ops(osd_client_t *cl)
|
|
{
|
|
std::vector<osd_op_t*> cancel_ops;
|
|
cancel_ops.resize(cl->sent_ops.size());
|
|
int i = 0;
|
|
for (auto p: cl->sent_ops)
|
|
{
|
|
cancel_ops[i++] = p.second;
|
|
}
|
|
cl->sent_ops.clear();
|
|
cl->outbox.clear();
|
|
for (auto op: cancel_ops)
|
|
{
|
|
cancel_op(op);
|
|
}
|
|
}
|
|
|
|
void osd_messenger_t::cancel_op(osd_op_t *op)
|
|
{
|
|
if (op->op_type == OSD_OP_OUT)
|
|
{
|
|
op->reply.hdr.magic = SECONDARY_OSD_REPLY_MAGIC;
|
|
op->reply.hdr.id = op->req.hdr.id;
|
|
op->reply.hdr.opcode = op->req.hdr.opcode;
|
|
op->reply.hdr.retval = -EPIPE;
|
|
// Copy lambda to be unaffected by `delete op`
|
|
std::function<void(osd_op_t*)>(op->callback)(op);
|
|
}
|
|
else
|
|
{
|
|
// This function is only called in stop_client(), so it's fine to destroy the operation
|
|
delete op;
|
|
}
|
|
}
|
|
|
|
void osd_messenger_t::stop_client(int peer_fd, bool force)
|
|
{
|
|
assert(peer_fd != 0);
|
|
auto it = clients.find(peer_fd);
|
|
if (it == clients.end())
|
|
{
|
|
return;
|
|
}
|
|
uint64_t repeer_osd = 0;
|
|
osd_client_t *cl = it->second;
|
|
if (cl->peer_state == PEER_CONNECTED)
|
|
{
|
|
if (cl->osd_num)
|
|
{
|
|
// Reload configuration from etcd when the connection is dropped
|
|
if (log_level > 0)
|
|
printf("[OSD %lu] Stopping client %d (OSD peer %lu)\n", osd_num, peer_fd, cl->osd_num);
|
|
repeer_osd = cl->osd_num;
|
|
}
|
|
else
|
|
{
|
|
if (log_level > 0)
|
|
printf("[OSD %lu] Stopping client %d (regular client)\n", osd_num, peer_fd);
|
|
}
|
|
}
|
|
else if (!force)
|
|
{
|
|
return;
|
|
}
|
|
cl->peer_state = PEER_STOPPED;
|
|
clients.erase(it);
|
|
#ifndef __MOCK__
|
|
tfd->set_fd_handler(peer_fd, false, NULL);
|
|
if (cl->connect_timeout_id >= 0)
|
|
{
|
|
tfd->clear_timer(cl->connect_timeout_id);
|
|
cl->connect_timeout_id = -1;
|
|
}
|
|
#endif
|
|
if (cl->osd_num)
|
|
{
|
|
osd_peer_fds.erase(cl->osd_num);
|
|
}
|
|
if (cl->read_op)
|
|
{
|
|
if (cl->read_op->callback)
|
|
{
|
|
cancel_op(cl->read_op);
|
|
}
|
|
else
|
|
{
|
|
delete cl->read_op;
|
|
}
|
|
cl->read_op = NULL;
|
|
}
|
|
for (auto rit = read_ready_clients.begin(); rit != read_ready_clients.end(); rit++)
|
|
{
|
|
if (*rit == peer_fd)
|
|
{
|
|
read_ready_clients.erase(rit);
|
|
break;
|
|
}
|
|
}
|
|
for (auto wit = write_ready_clients.begin(); wit != write_ready_clients.end(); wit++)
|
|
{
|
|
if (*wit == peer_fd)
|
|
{
|
|
write_ready_clients.erase(wit);
|
|
break;
|
|
}
|
|
}
|
|
free(cl->in_buf);
|
|
cl->in_buf = NULL;
|
|
#ifndef __MOCK__
|
|
close(peer_fd);
|
|
#endif
|
|
if (repeer_osd)
|
|
{
|
|
// First repeer PGs as canceling OSD ops may push new operations
|
|
// and we need correct PG states when we do that
|
|
repeer_pgs(repeer_osd);
|
|
}
|
|
if (cl->osd_num)
|
|
{
|
|
// Cancel outbound operations
|
|
cancel_osd_ops(cl);
|
|
}
|
|
if (cl->refs <= 0)
|
|
{
|
|
delete cl;
|
|
}
|
|
}
|