void elliptics_service_t::on_bulk_read_completed(deferred<std::map<std::string, std::string> > promise,
const key_name_map &keys,
const ioremap::elliptics::sync_read_result &result,
const ioremap::elliptics::error_info &error)
{
if (error) {
promise.abort(-error.code(), error.message());
} else {
std::map<std::string, std::string> read_result;
for (size_t i = 0; i < result.size(); ++i) {
const auto &entry = result[i];
const auto &id = reinterpret_cast<const dnet_raw_id &>(entry.command()->id);
auto it = keys.find(id);
if (it == keys.end()) {
continue;
}
read_result[it->second] = entry.file().to_string();
}
promise.write(read_result);
}
}
void on_search_finished(wookie::find_result &fobj, const ioremap::elliptics::error_info &err) {
if (err) {
log(ioremap::swarm::LOG_ERROR, "Failed to search: %s", err.message().c_str());
send_reply(ioremap::swarm::url_fetcher::response::service_unavailable);
return;
}
ioremap::thevoid::elliptics::JsonValue result_object;
rapidjson::Value indexes;
indexes.SetArray();
auto ids = fobj.results_array();
for (size_t i = 0; i < ids.size(); ++i) {
char id_str[2 * DNET_ID_SIZE + 1];
dnet_dump_id_len_raw(ids[i].id, DNET_ID_SIZE, id_str);
rapidjson::Value index(id_str, result_object.GetAllocator());
indexes.PushBack(index, result_object.GetAllocator());
}
result_object.AddMember("result", indexes, result_object.GetAllocator());
auto data = result_object.ToString();
swarm::url_fetcher::response reply;
reply.set_code(ioremap::swarm::url_fetcher::response::ok);
reply.headers().set_content_length(data.size());
send_reply(std::move(reply), std::move(data));
}
void proxy::req_get::on_read_chunk(const ioremap::elliptics::sync_read_result &srr, const ioremap::elliptics::error_info &error) {
if (error) {
BH_LOG(logger(), SWARM_LOG_ERROR
, "Get %s %s: on_read_chunk: %s"
, m_key.remote().c_str(), m_key.to_string().c_str(), error.message().c_str());
HANDY_MDS_GET_REPLY(500);
send_reply(500);
return;
}
BH_LOG(logger(), SWARM_LOG_INFO
, "Get %s %s: on_read_chunk: chunk was read"
, m_key.remote().c_str(), m_key.to_string().c_str());
const auto &rr = srr.front();
auto file = rr.file();
std::string data = file.to_string();
if (m_first_chunk) {
m_first_chunk = false;
ioremap::thevoid::http_response reply;
reply.set_code(200);
reply.headers().set_content_length(m_size);
if (NULL == server()->m_magic.get()) {
server()->m_magic.reset(new magic_provider());
}
reply.headers().set_content_type(server()->m_magic->type(data));
{
time_t timestamp = (time_t)(rr.io_attribute()->timestamp.tsec);
char ts_str[128] = {0};
struct tm tmp;
strftime(ts_str, sizeof (ts_str), "%a, %d %b %Y %T %Z", gmtime_r(×tamp, &tmp));
if (m_if_modified_since) {
if (*m_if_modified_since == ts_str) {
HANDY_MDS_GET_REPLY(304);
send_reply(304);
return;
}
}
reply.headers().set_last_modified(ts_str);
}
HANDY_MDS_GET_REPLY(reply.code());
send_headers(std::move(reply), std::function<void (const boost::system::error_code &)>());
}
send_data(std::move(data), std::bind(&proxy::req_get::on_sent_chunk, shared_from_this(), std::placeholders::_1));
m_offset += file.size();
}
void elliptics_service_t::on_remove_completed(deferred<void> promise,
const ioremap::elliptics::sync_remove_result &,
const ioremap::elliptics::error_info &error)
{
if (error) {
promise.abort(-error.code(), error.message());
} else {
promise.close();
}
}
void elliptics_service_t::on_find_completed(deferred<std::vector<std::string> > promise,
const ioremap::elliptics::sync_find_indexes_result &result,
const ioremap::elliptics::error_info &error)
{
if (error) {
promise.abort(-error.code(), error.message());
} else {
promise.write(storage::elliptics_storage_t::convert_list_result(result));
}
}
void elliptics_service_t::on_read_completed(deferred<std::string> promise,
const ioremap::elliptics::sync_read_result &result,
const ioremap::elliptics::error_info &error)
{
if (error) {
promise.abort(-error.code(), error.message());
} else {
promise.write(result[0].file().to_string());
}
}
void proxy::req_get::on_lookup(const ioremap::elliptics::sync_lookup_result &slr, const ioremap::elliptics::error_info &error) {
if (error) {
if (error.code() == -ENOENT) {
BH_LOG(logger(), SWARM_LOG_INFO
, "Get %s %s: on_lookup: file not found"
, m_key.remote().c_str(), m_key.to_string().c_str());
HANDY_MDS_GET_REPLY(404);
send_reply(404);
} else {
BH_LOG(logger(), SWARM_LOG_ERROR
, "Get %s %s: on_lookup: %s"
, m_key.remote().c_str(), m_key.to_string().c_str(), error.message().c_str());
HANDY_MDS_GET_REPLY(500);
send_reply(500);
}
return;
}
const auto &entry = slr.front();
auto total_size = entry.file_info()->size;
if (m_offset >= total_size) {
BH_LOG(logger(), SWARM_LOG_INFO
, "Get %s %s: offset greater than total_size"
, m_key.remote().c_str()
, m_key.to_string().c_str());
HANDY_MDS_GET_REPLY(400);
send_reply(400);
return;
}
total_size -= m_offset;
if (m_size == 0 || m_size > total_size) {
m_size = total_size;
}
std::vector<int> groups;
for (auto it = slr.begin(), end = slr.end(); it != end; ++it) {
groups.push_back(it->command()->id.group_id);
}
m_session->set_groups(groups);
read_chunk();
}
void proxy::req_delete::on_lookup(const ioremap::elliptics::sync_lookup_result &slr, const ioremap::elliptics::error_info &error) {
if (error) {
BH_LOG(logger(), SWARM_LOG_ERROR, "Delete request=\"%s\" lookup error: %s"
, url_str.c_str(), error.message().c_str());
HANDY_MDS_DELETE_REPLY(error.code() == -ENOENT ? 404 : 500);
send_reply(error.code() == -ENOENT ? 404 : 500);
return;
}
const auto &entry = slr.front();
total_size = entry.file_info()->size;
// all_with_ack because all doesn't mean all in some cases e.g. remove act
session->set_filter(ioremap::elliptics::filters::all_with_ack);
session->set_timeout(server()->timeout.remove);
BH_LOG(logger(), SWARM_LOG_DEBUG, "Delete %s: data size %d"
, url_str.c_str(), static_cast<int>(total_size));
session->remove(key).connect(wrap(std::bind(&req_delete::on_finished, shared_from_this(), std::placeholders::_1, std::placeholders::_2)));
}
void request_complete(std::shared_ptr<request> req, const ioremap::elliptics::error_info &error)
{
if (error) {
fprintf(stderr, "%s %d: queue request completion error: %s\n", dnet_dump_id(&req->id), req->src_key, error.message().c_str());
} else {
//fprintf(stderr, "%s %d: queue request completed\n", dnet_dump_id(&req->id), req->src_key);
}
--running_requests;
condition.notify_one();
}