static void testConfigUserPassword(void) {
VBUCKET_CONFIG_HANDLE vb1;
VBUCKET_CONFIG_HANDLE vb2;
VBUCKET_CONFIG_DIFF *diff;
vb1 = vbucket_config_parse_file(configPath("config-user-password1"));
assert(vb1);
assert(strcmp(vbucket_config_get_user(vb1), "theUser") == 0);
assert(strcmp(vbucket_config_get_password(vb1), "thePassword") == 0);
vb2 = vbucket_config_parse_file(configPath("config-user-password2"));
assert(vb2);
assert(strcmp(vbucket_config_get_user(vb2), "theUserIsDifferent") == 0);
assert(strcmp(vbucket_config_get_password(vb2), "thePasswordIsDifferent") == 0);
diff = vbucket_compare(vb1, vb2);
assert(diff);
assert(diff->sequence_changed);
assert(diff->n_vb_changes == 0);
assert(diff->servers_added[0] == NULL);
assert(diff->servers_removed[0] == NULL);
vbucket_free_diff(diff);
diff = vbucket_compare(vb1, vb1);
assert(diff);
assert(diff->sequence_changed == 0);
assert(diff->n_vb_changes == 0);
assert(diff->servers_added[0] == NULL);
assert(diff->servers_removed[0] == NULL);
vbucket_free_diff(diff);
vbucket_config_destroy(vb1);
vbucket_config_destroy(vb2);
}
static void testConfig(const char *fname) {
int whoops = 0;
const struct key_st *k;
int i = 0;
VBUCKET_CONFIG_HANDLE vb = vbucket_config_parse_file(configPath(fname));
if (vb == NULL) {
fprintf(stderr, "vbucket_config_parse_file error: %s\n",
vbucket_get_error());
abort();
}
while ((k = &keys[i++])->key != NULL) {
int id = vbucket_get_vbucket_by_key(vb, k->key, strlen(k->key));
if (id != k->vbucket) {
fprintf(stderr, "Expected vbucket %d for key '%s' but got %d\n",
k->vbucket, k->key, id);
whoops = 1;
}
}
if (whoops) {
abort();
}
assert(vbucket_config_get_num_servers(vb) == 3 || vbucket_config_get_num_servers(vb) == 4);
assert(vbucket_config_get_num_replicas(vb) == 2);
for (i = 0; i < 3; ++i) {
assert(strcmp(vbucket_config_get_server(vb, i), servers[i]) == 0);
}
for (i = 0; i < 4; ++i) {
assert(vbucket_get_master(vb, i) == vbuckets[i].master);
assert(vbucket_get_replica(vb, i, 0) == vbuckets[i].replicas[0]);
assert(vbucket_get_replica(vb, i, 1) == vbuckets[i].replicas[1]);
}
assert(vbucket_config_get_user(vb) == NULL);
assert(vbucket_config_get_password(vb) == NULL);
vbucket_config_destroy(vb);
}
mcs_st *lvb_create(mcs_st *ptr, const char *config) {
assert(ptr);
memset(ptr, 0, sizeof(*ptr));
ptr->kind = MCS_KIND_LIBVBUCKET;
VBUCKET_CONFIG_HANDLE vch = vbucket_config_parse_string(config);
if (vch != NULL) {
ptr->data = vch;
ptr->nservers = vbucket_config_get_num_servers(vch);
if (ptr->nservers > 0) {
ptr->servers = calloc(sizeof(mcs_server_st), ptr->nservers);
if (ptr->servers != NULL) {
for (int i = 0; i < ptr->nservers; i++) {
ptr->servers[i].fd = -1;
}
int j = 0;
for (; j < ptr->nservers; j++) {
const char *hostport = vbucket_config_get_server(vch, j);
if (hostport != NULL &&
strlen(hostport) > 0 &&
strlen(hostport) < sizeof(ptr->servers[j].hostname) - 1) {
strncpy(ptr->servers[j].hostname,
hostport,
sizeof(ptr->servers[j].hostname) - 1);
char *colon = strchr(ptr->servers[j].hostname, ':');
if (colon != NULL) {
*colon = '\0';
ptr->servers[j].port = atoi(colon + 1);
if (ptr->servers[j].port <= 0) {
moxi_log_write("mcs_create failed, could not parse port: %s\n",
config);
break;
}
} else {
moxi_log_write("mcs_create failed, missing port: %s\n",
config);
break;
}
} else {
moxi_log_write("mcs_create failed, unknown server: %s\n",
config);
break;
}
const char *user = vbucket_config_get_user(vch);
if (user != NULL) {
ptr->servers[j].usr = strdup(user);
}
const char *password = vbucket_config_get_password(vch);
if (password != NULL) {
ptr->servers[j].pwd = strdup(password);
}
}
if (j >= ptr->nservers) {
return ptr;
}
}
}
} else {
moxi_log_write("mcs_create failed, vbucket_config_parse_string: %s\n",
config);
}
mcs_free(ptr);
return NULL;
}
instance->backup_nodes[ii] = NULL;
} else {
instance->backup_nodes[ii] = instance->servers[ii].rest_api_server;
}
/* swap with random position < ii */
if (ii > 0) {
libcouchbase_size_t nn = (libcouchbase_size_t)(gethrtime() >> 10) % ii;
char *pp = instance->backup_nodes[ii];
instance->backup_nodes[ii] = instance->backup_nodes[nn];
instance->backup_nodes[nn] = pp;
}
}
instance->sasl.name = vbucket_config_get_user(instance->vbucket_config);
memset(instance->sasl.password.buffer, 0,
sizeof(instance->sasl.password.buffer));
passwd = vbucket_config_get_password(instance->vbucket_config);
if (passwd) {
instance->sasl.password.secret.len = strlen(passwd);
strcpy((char *)(instance->sasl.password.buffer + sizeof(instance->sasl.password.secret.len)), passwd);
}
memcpy(instance->sasl.callbacks, sasl_callbacks, sizeof(sasl_callbacks));
/*
* Run through all of the vbuckets and build a map of what they need.
* It would have been nice if I could query libvbucket for the number
* of vbuckets a server got, but there isn't at the moment..
*/
max = (libcouchbase_uint16_t)vbucket_config_get_num_vbuckets(instance->vbucket_config);
instance->nvbuckets = max;
free(instance->vb_server_map);
instance->vb_server_map = calloc(max, sizeof(libcouchbase_vbucket_t));
