void redis_reshard::copy_slots(acl::redis_node& from, acl::redis_node& to)
{
const std::vector<std::pair<size_t, size_t> >& slots = from.get_slots();
std::vector<std::pair<size_t, size_t> >::const_iterator cit;
for (cit = slots.begin(); cit != slots.end(); ++cit)
to.add_slot_range(cit->first, cit->second);
}
bool redis_builder::master_set_slots(acl::redis& redis,
acl::redis_node& master)
{
const std::vector<std::pair<size_t, size_t> >& slots
= master.get_slots();
if (slots.size() != 1)
{
printf("%s: invalid slots's size: %d, addr: %s\r\n",
__FUNCTION__, (int) slots.size(), master.get_addr());
return false;
}
const std::pair<size_t, size_t> slot = slots[0];
size_t min_slot = slot.first, max_slot = slot.second;
size_t n = max_slot - min_slot + 1;
int *slot_array = (int*) malloc(sizeof(int) * n);
for (size_t i = 0; i < n; i++)
{
slot_array[i] = (int)min_slot;
min_slot++;
}
if (redis.cluster_addslots(slot_array, n) == false)
{
printf("%s: addslots error: %s, addr: %s, slots: %d, %d\r\n",
__FUNCTION__, redis.result_error(), master.get_addr(),
(int) min_slot, (int) max_slot);
return false;
}
return true;
}
bool redis_builder::build_master(acl::redis_node& master)
{
acl::redis_client client(master.get_addr());
acl::redis redis(&client);
if (master_set_slots(redis, master) == false)
return false;
acl::string id;
if (redis_util::get_node_id(redis, id) == false)
{
printf("%s: null id, master addr: %s\r\n",
__FUNCTION__, master.get_addr());
return false;
}
master.set_id(id.c_str());
printf("Build master: %s, %s\r\n", id.c_str(), master.get_addr());
const std::vector<acl::redis_node*>* slaves = master.get_slaves();
std::vector<acl::redis_node*>::const_iterator cit;
for (cit = slaves->begin(); cit != slaves->end(); ++cit)
{
if (add_slave(master, **cit) == false)
return false;
}
printf("Build master OK\r\n");
return true;
}
bool redis_builder::cluster_meet(acl::redis& redis,
const acl::redis_node& node)
{
acl::string buf(node.get_addr());
const std::vector<acl::string>& tokens = buf.split2(":");
if (tokens.size() != 2)
{
printf("%s: invalid addr: %s\r\n",
__FUNCTION__, node.get_addr());
return false;
}
if (!redis.cluster_meet(tokens[0].c_str(), atoi(tokens[1].c_str())))
{
printf("%s: cluster meet %s %s error: %s\r\n",
__FUNCTION__, tokens[0].c_str(), tokens[1].c_str(),
redis.result_error());
return false;
}
while (true)
{
if (cluster_meeting(redis, node.get_addr()) == true)
break;
acl_doze(meet_wait_);
}
return true;
}
bool redis_builder::add_slave(const acl::redis_node& master,
const acl::redis_node& slave)
{
acl::redis_client client(slave.get_addr());
acl::redis redis(&client);
const char* master_addr = master.get_addr();
if (master_addr == NULL || *master_addr == 0)
{
printf("%s: master addr null\r\n", __FUNCTION__);
return false;
}
acl::string buf(master_addr);
const std::vector<acl::string>& tokens = buf.split2(":");
if (tokens.size() != 2)
{
printf("%s: invalid master_addr: %s\r\n",
__FUNCTION__, master_addr);
return false;
}
// CLUSTER MEET master node
if (!redis.cluster_meet(tokens[0].c_str(), atoi(tokens[1].c_str())))
{
printf("%s: cluster meet %s %s error: %s\r\n",
__FUNCTION__, tokens[0].c_str(), tokens[1].c_str(),
redis.result_error());
return false;
}
// wait for the master recognizing the slave
while (true)
{
if (cluster_meeting(redis, master_addr) == true)
break;
acl_doze(meet_wait_);
}
if (redis.cluster_replicate(master.get_id()) == false)
{
printf("%s: cluster replicate id: %s, error: %s, addr: %s\r\n",
__FUNCTION__, master.get_id(), redis.result_error(),
slave.get_addr());
return false;
}
return true;
}
void redis_reshard::show_slots(const acl::redis_node& node)
{
const std::vector<std::pair<size_t, size_t> > slots = node.get_slots();
std::vector<std::pair<size_t, size_t> >::const_iterator cit;
for (cit = slots.begin(); cit != slots.end(); ++cit)
printf("slots: %d - %d\r\n",
(int) cit->first, (int) cit->second);
}
