Skip to content

Commit

Permalink
apply Redis server blacklist to all servers, not just in cluster mode…
Browse files Browse the repository at this point in the history 
…. also clean up a bit.
  • Loading branch information
@slact
slact committed Feb 29, 2024
2 parents 6212ad1 + 3995f5d commit b4d6b42
Show file tree
Hide file tree
Showing 2 changed files with 49 additions and 68 deletions.
113 changes: 47 additions & 66 deletions src/store/redis/redis_nodeset.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -659,8 +659,7 @@ static int node_transfer_slaves(redis_node_t *src, redis_node_t *dst) {
int transferred = 0;
redis_node_t **cur;
for(cur = nchan_list_first(&src->peers.slaves); cur != NULL; cur = nchan_list_next(cur)) {
node_set_master_node(*cur, dst);
node_add_slave_node(dst, *cur); //won't be added if it's already there
node_set_master_slave_relationship(dst, *cur);
transferred++;
}
return transferred;
Expand Down Expand Up @@ -875,8 +874,7 @@ static int nodeset_link_cluster_node_roles(redis_nodeset_t *ns) {
return 0;
}

node_set_master_node(cur, master); //this is idempotent
node_add_slave_node(master, cur); //so is this
node_set_master_slave_relationship(master, cur);
}
}
return 1;
Expand Down Expand Up @@ -1491,63 +1489,43 @@ ngx_int_t nodeset_node_destroy(redis_node_t *node) {
return NGX_OK;
}

static void node_discover_slave(redis_node_t *master, redis_connect_params_t *rcp) {
redis_node_t *slave;
if((slave = nodeset_node_find_by_connect_params(master->nodeset, rcp))!= NULL) {
static void node_discover(redis_node_t *source, redis_connect_params_t *rcp, redis_node_role_t role) {
assert(role == REDIS_NODE_ROLE_SLAVE || role == REDIS_NODE_ROLE_MASTER);

nchan_redis_ip_range_t *matched;
redis_node_t *discovered_node = NULL;

if ((matched = node_ip_blacklisted(source->nodeset, rcp)) != NULL) {
node_log_notice(source, "skipping discovered %s %V blacklisted by %V", node_role_cstr(role), &rcp->hostname, &matched->str);
return;
}

if((discovered_node = nodeset_node_find_by_connect_params(source->nodeset, rcp))!= NULL) {
//we know about it already
if(slave->role != REDIS_NODE_ROLE_SLAVE && slave->state > REDIS_NODE_GET_INFO) {
node_log_notice(slave, "Node appears to have changed to slave -- need to update");
node_set_role(slave, REDIS_NODE_ROLE_UNKNOWN);
node_disconnect(slave, REDIS_NODE_FAILED);
node_connect(slave);
if(discovered_node->role != role && discovered_node->state > REDIS_NODE_GET_INFO) {
node_log_notice(discovered_node, "Node appears to have changed to %s -- need to update", node_role_cstr(role));
node_set_role(discovered_node, REDIS_NODE_ROLE_UNKNOWN);
node_disconnect(discovered_node, REDIS_NODE_FAILED);
node_connect(discovered_node);
}
//assert(slave->peers.master == master);
}
else {


slave = nodeset_node_create_with_connect_params(master->nodeset, rcp);
slave->discovered = 1;
node_set_role(slave, REDIS_NODE_ROLE_SLAVE);
node_log_notice(master, "Discovering own slave %s", rcp_cstr(rcp));
}
node_set_master_node(slave, master); //this is idempotent
node_add_slave_node(master, slave); //so is this
//try to connect
if(slave->state <= REDIS_NODE_DISCONNECTED) {
node_connect(slave);
}
}

static void node_discover_master(redis_node_t *slave, redis_connect_params_t *rcp) {
nchan_redis_ip_range_t *matched;
redis_node_t *master = NULL;

if ((matched = node_ip_blacklisted(slave->nodeset, rcp)) != NULL) {
node_log_notice(slave, "skipping master %V blacklisted by %V", &rcp->hostname, &matched->str);
return;
discovered_node = nodeset_node_create_with_connect_params(source->nodeset, rcp);
discovered_node->discovered = 1;
node_set_role(discovered_node, role);
node_log_notice(source, "Discovering own %s %s", node_role_cstr(role), rcp_cstr(rcp));
}
else if ((master = nodeset_node_find_by_connect_params(slave->nodeset, rcp)) != NULL) {
if (master->role != REDIS_NODE_ROLE_MASTER && master->state > REDIS_NODE_GET_INFO) {
node_log_notice(master, "Node appears to have changed to master -- need to update");
node_set_role(master, REDIS_NODE_ROLE_UNKNOWN);
node_disconnect(master, REDIS_NODE_FAILED);
node_connect(master);
}
//assert(node_find_slave_node(master, slave));
//node_log_notice(slave, "Discovering master %s... already known", rcp_cstr(rcp));

if(role == REDIS_NODE_ROLE_MASTER) {
node_set_master_slave_relationship(discovered_node, source);
}
else {
master = nodeset_node_create_with_connect_params(slave->nodeset, rcp);
master->discovered = 1;
node_set_role(master, REDIS_NODE_ROLE_MASTER);
node_log_notice(slave, "Discovering own master %s", rcp_cstr(rcp));
node_set_master_slave_relationship(source, discovered_node);
}
node_set_master_node(slave, master);
node_add_slave_node(master, slave);
//try to connect
if(master->state <= REDIS_NODE_DISCONNECTED) {
node_connect(master);

//try to connect
if(discovered_node->state <= REDIS_NODE_DISCONNECTED && !discovered_node->connecting) {
node_connect(discovered_node);
}
}

Expand Down Expand Up @@ -1860,13 +1838,6 @@ void node_set_role(redis_node_t *node, redis_node_role_t role) {
}
}

int node_set_master_node(redis_node_t *node, redis_node_t *master) {
if(node->peers.master && node->peers.master != master) {
node_remove_slave_node(master, node);
}
node->peers.master = master;
return 1;
}
redis_node_t *node_find_slave_node(redis_node_t *node, redis_node_t *slave) {
redis_node_t **cur;
for(cur = nchan_list_first(&node->peers.slaves); cur != NULL; cur = nchan_list_next(cur)) {
Expand All @@ -1876,15 +1847,25 @@ redis_node_t *node_find_slave_node(redis_node_t *node, redis_node_t *slave) {
}
return NULL;
}
int node_add_slave_node(redis_node_t *node, redis_node_t *slave) {
if(!node_find_slave_node(node, slave)) {

int node_set_master_slave_relationship(redis_node_t *master, redis_node_t *slave) {

//set the slave's master
if(slave->peers.master && slave->peers.master != master) {
node_remove_slave_node(master, slave);
}
slave->peers.master = master;

//add slave to master's list of slaves. idempotently, of course
if(!node_find_slave_node(master, slave)) {
redis_node_t **slaveref;
slaveref = nchan_list_append(&node->peers.slaves);
slaveref = nchan_list_append(&master->peers.slaves);
*slaveref = slave;
return 1;
}

return 1;
}

int node_remove_slave_node(redis_node_t *node, redis_node_t *slave) {
if(!node_find_slave_node(node, slave)) {
nchan_list_remove(&node->peers.slaves, slave);
Expand Down Expand Up @@ -2174,7 +2155,7 @@ static int node_discover_slaves_from_info_reply(redis_node_t *node, redisReply *
nodeset_log_notice(node->nodeset, "Skipping slave node %V blacklisted by %V", &rcp->hostname, &matched->str);
}
else {
node_discover_slave(node, &rcp[i]);
node_discover(node, &rcp[i], REDIS_NODE_ROLE_SLAVE);
}
}
return 1;
Expand Down Expand Up @@ -2610,7 +2591,7 @@ static void node_connector_callback(redisAsyncContext *ac, void *rep, void *priv
return node_connector_fail(node, "failed parsing master from INFO");
}
if(!node->cluster.enabled) {
node_discover_master(node, rcp);
node_discover(node, rcp, REDIS_NODE_ROLE_MASTER);
}
}
else {
Expand Down
4 changes: 2 additions & 2 deletions src/store/redis/redis_nodeset.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -337,9 +337,9 @@ int node_disconnect(redis_node_t *node, int disconnected_state);
int node_connect(redis_node_t *node);
redisContext *node_connect_sync_context(redis_node_t *node);
void node_set_role(redis_node_t *node, redis_node_role_t role);
int node_set_master_node(redis_node_t *node, redis_node_t *master);

int node_set_master_slave_relationship(redis_node_t *master, redis_node_t *slave);
redis_node_t *node_find_slave_node(redis_node_t *node, redis_node_t *slave);
int node_add_slave_node(redis_node_t *node, redis_node_t *slave);
int node_remove_slave_node(redis_node_t *node, redis_node_t *slave);

void node_command_sent(redis_node_t *node);
Expand Down

0 comments on commit b4d6b42

Please sign in to comment.