bool redis_builder::load(const char* conf, size_t replicas)
{
acl::string buf;
// load xml information from local file
if (acl::ifstream::load(conf, &buf) == false)
{
printf("%s: load configure error: %s, file: %s\r\n",
__FUNCTION__, acl::last_serror(), conf);
return false;
}
/* <xml>
* <node addr="ip:port">
* <node addr="ip:port" />
* <node addr="ip:port" />
* ...
* </node>
* <node addr="ip:port">
* <node addr="ip:port" />
* <node addr="ip:port" />
* ...
* </node>
* ...
* </xml>
*/
// parse the xml data
acl::xml xml(buf.c_str());
if (replicas > 0)
return create_cluster(xml, replicas);
else
return create_cluster(xml);
}
int main(int argc, char** argv) {
int LCS_threshold=0,n=0,i=0,j=0;
char clustername[10];
create_cluster();
display_clusters();
printf("NC_LCS=%d",((int)large_cluster(cnode)));
printf("\nEnter the LCS threshold:");
scanf("%d",&LCS_threshold);
printf("\nEnter the cluster name:");
scanf("%s",clustername);
n=num_of_clusters;
for(i=0;i<n;i++)
{
if((strcmp((cnode+i)->cname,clustername)==0))
{
for(j=0;j<((cnode+i)->num_of_pages);j++)
{
printf("\n%s",(((cnode+i)->pagelink)+j)->pname);
}
}
}
free_clusters();
return (EXIT_SUCCESS);
}
int main() {
CassCluster* cluster = create_cluster();
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
const Pair items[] = { { "apple", 1 }, { "orange", 2 }, { "banana", 3 }, { "mango", 4 }, { NULL, 0 } };
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
execute_query(session,
"CREATE TABLE examples.maps (key text, \
items map<text, int>, \
PRIMARY KEY (key))");
insert_into_maps(session, "test", items);
select_from_maps(session, "test");
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
void
cluster(point ps[], int n, int k, int cs[])
{
ld **distances; // all the edge weights
void *clusters[n]; // array of pointers to clusters.
// note that the indexes of the array are
// the same as the indexes of the points
int point1, point2; // temporary variables that should store
// the next pair of closest points
// allocate memory for the arrays
distances = (ld **) smalloc(sizeof(ld *) * n);
// pre-calculate all the edge weights (distances
// between every point and every other point)
get_distances(distances, ps, n);
// initialize each cluster to have just 1 point
for(int i = 0; i < n; i++) {
clusters[i] = create_cluster(i);
}
// keep merging clusters until we're down to k clusters
for(int num_clusters = n; num_clusters > k; num_clusters--) {
// find the 2 closest clusters that aren't connected
next_shortest_edge(&point1, &point2, distances, n, clusters);
// merge them
merge_clusters(clusters[point1], clusters[point2]);
}
// convert the crazy cluster numbers to normal ones
normalize_clusters(cs, n, clusters);
}
int main(int argc, char* argv[]) {
CassCluster* cluster = NULL;
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
Basic input = { cass_true, 0.001f, 0.0002, 1, 2 };
Basic output;
const CassPrepared* prepared = NULL;
char* hosts = "127.0.0.1";
if (argc > 1) {
hosts = argv[1];
}
cluster = create_cluster(hosts);
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
execute_query(session,
"CREATE TABLE examples.basic (key text, \
bln boolean, \
flt float, dbl double,\
i32 int, i64 bigint, \
PRIMARY KEY (key));");
insert_into_basic(session, "prepared_test", &input);
if (prepare_select_from_basic(session, &prepared) == CASS_OK) {
select_from_basic(session, prepared, "prepared_test", &output);
assert(input.bln == output.bln);
assert(input.flt == output.flt);
assert(input.dbl == output.dbl);
assert(input.i32 == output.i32);
assert(input.i64 == output.i64);
cass_prepared_free(prepared);
}
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
/*
** COMMAND: test-create-clusters
**
** Create clusters for all unclustered artifacts if the number of unclustered
** artifacts exceeds the current clustering threshold.
*/
void test_createcluster_cmd(void){
if( g.argc==3 ){
db_open_repository(g.argv[2]);
}else{
db_find_and_open_repository(0, 0);
if( g.argc!=2 ){
usage("?REPOSITORY-FILENAME?");
}
db_close(1);
db_open_repository(g.zRepositoryName);
}
db_begin_transaction();
create_cluster();
db_end_transaction(0);
}
redis_commands::redis_commands(const char* addr, const char* passwd,
int conn_timeout, int rw_timeout, bool prefer_master,
const char* cmds_file)
: conn_timeout_(conn_timeout)
, rw_timeout_(rw_timeout)
, prefer_master_(prefer_master)
, all_cmds_perm_("yes")
{
if (passwd && *passwd)
passwd_ = passwd;
set_addr(addr, addr_);
conns_ = NULL;
init(cmds_file);
create_cluster();
}
int main() {
CassCluster* cluster = create_cluster();
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
uuid_gen = cass_uuid_gen_new();
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
schema_meta = cass_session_get_schema_meta(session);
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' }");
int main() {
CassCluster* cluster = create_cluster();
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
Basic input = { cass_true, 0.001f, 0.0002, 1, 2 };
Basic output;
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
execute_query(session,
"CREATE TABLE examples.basic (key text, \
bln boolean, \
flt float, dbl double,\
i32 int, i64 bigint, \
PRIMARY KEY (key));");
insert_into_basic(session, "test", &input);
select_from_basic(session, "test", &output);
assert(input.bln == output.bln);
assert(input.flt == output.flt);
assert(input.dbl == output.dbl);
assert(input.i32 == output.i32);
assert(input.i64 == output.i64);
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
int main(int argc, char* argv[]) {
CassCluster* cluster = NULL;
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
char* hosts = "127.0.0.1";
const char* items[] = { "apple", "orange", "banana", "mango", NULL };
cass_cluster_set_protocol_version(cluster, 2);
if (argc > 1) {
hosts = argv[1];
}
cluster = create_cluster(hosts);
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '1' };");
execute_query(session,
"CREATE TABLE examples.collections (key text, \
items set<text>, \
PRIMARY KEY (key))");
insert_into_collections(session, "test", items);
select_from_collections(session, "test");
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
int main() {
CassCluster* cluster = create_cluster();
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
const CassPrepared* prepared = NULL;
Pair pairs[] = { {"a", "1"}, {"b", "2"}, { NULL, NULL} };
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
execute_query(session,
"CREATE TABLE examples.pairs (key text, \
value text, \
PRIMARY KEY (key));");
if (prepare_insert_into_batch(session, &prepared) == CASS_OK) {
insert_into_batch_with_prepared(session, prepared, pairs);
}
cass_prepared_free(prepared);
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
int main(int argc, char* argv[]) {
CassCluster* cluster = NULL;
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
char* hosts = "127.0.0.1";
if (argc > 1) {
hosts = argv[1];
}
cluster = create_cluster(hosts);
uuid_gen = cass_uuid_gen_new();
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
schema_meta = cass_session_get_schema_meta(session);
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' }");
int main(int argc, char* argv[]) {
CassCluster* cluster = NULL;
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
char* hosts = "127.0.0.1";
if (argc > 1) {
hosts = argv[1];
}
cluster = create_cluster(hosts);
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
execute_query(session,
"CREATE TABLE examples.date_time (key text PRIMARY KEY, d date, t time)");
insert_into(session, "test");
select_from(session, "test");
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
int main() {
CassCluster* cluster = create_cluster();
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
execute_query(session,
"CREATE TABLE examples.async (key text, \
bln boolean, \
flt float, dbl double,\
i32 int, i64 bigint, \
PRIMARY KEY (key));");
execute_query(session, "USE examples");
insert_into_async(session, "test");
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
int main() {
CassCluster* cluster = create_cluster();
CassSession* session = cass_session_new();
uuid_gen = cass_uuid_gen_new();
uv_mutex_init(&mutex);
uv_cond_init(&cond);
connect_session(session, cluster, on_session_connect);
/* Code running in parallel with queries */
wait_exit();
uv_cond_destroy(&cond);
uv_mutex_destroy(&mutex);
cass_cluster_free(cluster);
cass_uuid_gen_free(uuid_gen);
cass_session_free(session);
return 0;
}
int main() {
char sql[1024];
time_t start, stop;
FILE *fp = fopen("/Users/carybourgeois/flights_exercise/flights_from_pg.csv", "r") ;
CassError rc = CASS_OK;
CassCluster* cluster = create_cluster();
CassSession* session = NULL;
CassFuture* close_future = NULL;
rc = connect_session(cluster, &session);
if(rc != CASS_OK) {
return -1;
}
execute_stmt(session,
"CREATE KEYSPACE IF NOT EXISTS exercise WITH \
replication = {'class': 'SimpleStrategy','replication_factor': '1'};");
execute_stmt(session,
"USE exercise;");
execute_stmt(session,
"DROP TABLE IF EXISTS flights;");
execute_stmt(session,
"CREATE TABLE flights ( \
id int, year int, day_of_month int, fl_date varchar, \
airline_id int, carrier varchar, fl_num int, origin_airport_id int, \
origin varchar, origin_city_name varchar, origin_state_abr varchar, dest varchar, \
dest_city_name varchar, dest_state_abr varchar, dep_time int, arr_time int, \
actual_elapsed_time int, air_time int, distance int, air_time_grp int, \
PRIMARY KEY (carrier, origin, air_time_grp, id));");
time(&start);
if ( fp != NULL ) {
int i = 0;
while(!feof(fp)) {
i++;
fscanf(fp, "%d, %d, %d, %[^,], %d, %[^,], %d, %d, %[^,], %[^,], %[^,], %[^,], %[^,], %[^,], %d, %d, %d, %d, %d \n",
&Flight.id, &Flight.year, &Flight.day_of_month, Flight.fl_date,
&Flight.airline_id, Flight.carrier, &Flight.fl_num, &Flight.origin_airport_id,
Flight.origin, Flight.origin_city_name, Flight.origin_state_abr, Flight.dest,
Flight.dest_city_name, Flight.dest_state_abr, &Flight.dep_time, &Flight.arr_time,
&Flight.actual_elapsed_time, &Flight.air_time, &Flight.distance);
sprintf(sql, "INSERT INTO flights (id, year, day_of_month, fl_date, airline_id, carrier, fl_num, origin_airport_id, origin, origin_city_name, origin_state_abr, dest, dest_city_name, dest_state_abr, dep_time, arr_time, actual_elapsed_time, air_time, distance, air_time_grp) VALUES (%d, %d, %d, \'%s\', %d, \'%s\', %d, %d, \'%s\', \'%s\', \'%s\', \'%s\', \'%s\', \'%s\', %d, %d, %d, %d, %d, %d);\n",
Flight.id, Flight.year, Flight.day_of_month, Flight.fl_date,
Flight.airline_id, Flight.carrier, Flight.fl_num, Flight.origin_airport_id,
Flight.origin, Flight.origin_city_name, Flight.origin_state_abr, Flight.dest,
Flight.dest_city_name, Flight.dest_state_abr, Flight.dep_time, Flight.arr_time,
Flight.actual_elapsed_time, Flight.air_time, Flight.distance, Flight.air_time/10 );
/* printf("%s", sql); */
execute_stmt(session, sql);
/* if (i > 999) break; */
} /* EOF */
printf("%d Records loaded.\n", i);
} /* File exists */
time(&stop);
printf("%.f Seconds total load time.\n", difftime(start, stop));
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
fclose( fp );
return 0;
}
int main() {
int i;
CassMetrics metrics;
uv_thread_t threads[NUM_THREADS];
CassCluster* cluster = NULL;
CassSession* session = NULL;
CassFuture* close_future = NULL;
status_init(&status, NUM_THREADS);
cass_log_set_level(CASS_LOG_INFO);
cluster = create_cluster();
uuid_gen = cass_uuid_gen_new();
session = cass_session_new();
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"INSERT INTO songs (id, title, album, artist, tags) VALUES "
"(a98d21b2-1900-11e4-b97b-e5e358e71e0d, "
"'La Petite Tonkinoise', 'Bye Bye Blackbird', 'Joséphine Baker', { 'jazz', '2013' });");
for (i = 0; i < NUM_THREADS; ++i) {
#if DO_SELECTS
uv_thread_create(&threads[i], run_select_queries, (void*)session);
#else
uv_thread_create(&threads[i], run_insert_queries, (void*)session);
#endif
}
while (status_wait(&status, 5) > 0) {
cass_session_get_metrics(session, &metrics);
printf("rate stats (requests/second): mean %f 1m %f 5m %f 10m %f\n",
metrics.requests.mean_rate,
metrics.requests.one_minute_rate,
metrics.requests.five_minute_rate,
metrics.requests.fifteen_minute_rate);
}
cass_session_get_metrics(session, &metrics);
printf("final stats (microseconds): min %llu max %llu median %llu 75th %llu 95th %llu 98th %llu 99th %llu 99.9th %llu\n",
(unsigned long long int)metrics.requests.min, (unsigned long long int)metrics.requests.max,
(unsigned long long int)metrics.requests.median, (unsigned long long int)metrics.requests.percentile_75th,
(unsigned long long int)metrics.requests.percentile_95th, (unsigned long long int)metrics.requests.percentile_98th,
(unsigned long long int)metrics.requests.percentile_99th, (unsigned long long int)metrics.requests.percentile_999th);
for (i = 0; i < NUM_THREADS; ++i) {
uv_thread_join(&threads[i]);
}
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_uuid_gen_free(uuid_gen);
status_destroy(&status);
return 0;
}
/*
** Core function to rebuild the information in the derived tables of a
** fossil repository from the blobs. This function is shared between
** 'rebuild_database' ('rebuild') and 'reconstruct_cmd'
** ('reconstruct'), both of which have to regenerate this information
** from scratch.
**
** If the randomize parameter is true, then the BLOBs are deliberately
** extracted in a random order. This feature is used to test the
** ability of fossil to accept records in any order and still
** construct a sane repository.
*/
int rebuild_db(int randomize, int doOut, int doClustering){
Stmt s;
int errCnt = 0;
char *zTable;
int incrSize;
bag_init(&bagDone);
ttyOutput = doOut;
processCnt = 0;
if (ttyOutput && !g.fQuiet) {
percent_complete(0);
}
rebuild_update_schema();
for(;;){
zTable = db_text(0,
"SELECT name FROM sqlite_master /*scan*/"
" WHERE type='table'"
" AND name NOT IN ('blob','delta','rcvfrom','user',"
"'config','shun','private','reportfmt',"
"'concealed','accesslog','modreq')"
" AND name NOT GLOB 'sqlite_*'"
" AND name NOT GLOB 'fx_*'"
);
if( zTable==0 ) break;
db_multi_exec("DROP TABLE %Q", zTable);
free(zTable);
}
db_multi_exec(zRepositorySchema2);
ticket_create_table(0);
shun_artifacts();
db_multi_exec(
"INSERT INTO unclustered"
" SELECT rid FROM blob EXCEPT SELECT rid FROM private"
);
db_multi_exec(
"DELETE FROM unclustered"
" WHERE rid IN (SELECT rid FROM shun JOIN blob USING(uuid))"
);
db_multi_exec(
"DELETE FROM config WHERE name IN ('remote-code', 'remote-maxid')"
);
/* The following should be count(*) instead of max(rid). max(rid) is
** an adequate approximation, however, and is much faster for large
** repositories. */
totalSize = db_int(0, "SELECT max(rid) FROM blob");
incrSize = totalSize/100;
totalSize += incrSize*2;
db_prepare(&s,
"SELECT rid, size FROM blob /*scan*/"
" WHERE NOT EXISTS(SELECT 1 FROM shun WHERE uuid=blob.uuid)"
" AND NOT EXISTS(SELECT 1 FROM delta WHERE rid=blob.rid)"
);
manifest_crosslink_begin();
while( db_step(&s)==SQLITE_ROW ){
int rid = db_column_int(&s, 0);
int size = db_column_int(&s, 1);
if( size>=0 ){
Blob content;
content_get(rid, &content);
rebuild_step(rid, size, &content);
}
}
db_finalize(&s);
db_prepare(&s,
"SELECT rid, size FROM blob"
" WHERE NOT EXISTS(SELECT 1 FROM shun WHERE uuid=blob.uuid)"
);
while( db_step(&s)==SQLITE_ROW ){
int rid = db_column_int(&s, 0);
int size = db_column_int(&s, 1);
if( size>=0 ){
if( !bag_find(&bagDone, rid) ){
Blob content;
content_get(rid, &content);
rebuild_step(rid, size, &content);
}
}else{
db_multi_exec("INSERT OR IGNORE INTO phantom VALUES(%d)", rid);
rebuild_step_done(rid);
}
}
db_finalize(&s);
manifest_crosslink_end(MC_NONE);
rebuild_tag_trunk();
if( ttyOutput && !g.fQuiet && totalSize>0 ){
processCnt += incrSize;
percent_complete((processCnt*1000)/totalSize);
}
if( doClustering ) create_cluster();
if( ttyOutput && !g.fQuiet && totalSize>0 ){
processCnt += incrSize;
percent_complete((processCnt*1000)/totalSize);
}
if(!g.fQuiet && ttyOutput ){
percent_complete(1000);
fossil_print("\n");
}
return errCnt;
}
/*
* Testing distribute_work_2_gp_segments
*/
static void test__distribute_work_to_gp_segments(TestInputData *input)
{
List **segs_allocated_data = NULL;
List * input_fragments_list = NIL;
char** array_of_segs = NULL;
bool *array_of_primaries;
int total_segs;
bool cluster_size_not_exceeded = input->m_num_hosts_in_cluster <= 65025;
assert_true(cluster_size_not_exceeded);
/*
* 1. Initialize the test input parameters
* We are testing an N hosts cluster. The size of the cluster is set in this section - section 1.
* Basic test assumptions:
* a. There is one datanode on each host in the cluster
* b. There are Hawq segments on each host in the cluster.
* c. There is an equal number of Hawq segments on each host - hardcoded in this section
*/
int num_hosts_in_cluster = input->m_num_hosts_in_cluster; /* cluster size musn't exceed 65025 - see function create_cluster() */
int num_data_fragments = input->m_num_data_fragments; /* number of fragments in the data we intend to allocate between the hawq segments */
int num_active_data_nodes = input->m_num_active_data_nodes; /* number of datanodes that hold the 'querried' data - there one datanode om each cluster host - so there are <num_hosts_in_cluster> datanodes */
int num_of_fragment_replicas = input->m_num_of_fragment_replicas;
int num_segments_on_host = input->m_num_segments_on_host;/* number of Hawq segments on each cluster host - we assume all cluster hosts have Hawq segments installed */
int num_working_segs = input->m_num_working_segs; /* the subset of Hawq segments that will do the processing - not all the Hawqs segments in the cluster are involved */
bool enable_print_input_cluster = input->m_enable_print_input_cluster;
bool enable_print_input_fragments = input->m_enable_print_input_fragments;
bool enable_print_input_segments = input->m_enable_print_input_segments;
bool enable_print_allocated_fragments = input->m_enable_print_allocated_fragments;
/* 2. Create the cluster */
char **cluster = create_cluster(num_hosts_in_cluster);
if (enable_print_input_cluster)
print_cluster(cluster, num_hosts_in_cluster);
/* 3. Input - data fragments */
input_fragments_list = spread_fragments_in_cluster(num_data_fragments, /* number of fragments in the data we are about to allocate */
num_active_data_nodes, /* hosts */
num_of_fragment_replicas, /* replicas */
cluster, /* the whole cluster*/
num_hosts_in_cluster/* the number of hosts in the cluster */);
if (enable_print_input_fragments)
print_fragment_list(input_fragments_list);
/* 4. Input - hawq segments */
total_segs = num_hosts_in_cluster * num_segments_on_host;
array_of_segs = create_array_of_segs(cluster, num_hosts_in_cluster, num_segments_on_host);
array_of_primaries = create_array_of_primaries(total_segs);
buildCdbComponentDatabases(total_segs, array_of_segs, array_of_primaries);
if (enable_print_input_segments)
print_segments_list();
/* 5. The actual unitest of distribute_work_2_gp_segments() */
segs_allocated_data = distribute_work_2_gp_segments(input_fragments_list, total_segs, num_working_segs);
if (enable_print_allocated_fragments)
print_allocated_fragments(segs_allocated_data, total_segs);
/* 6. The validations - verifying that the expected output was obtained */
validate_total_fragments_allocated(segs_allocated_data, total_segs, num_data_fragments);
validate_max_load_per_segment(segs_allocated_data, total_segs, num_working_segs, num_data_fragments);
validate_all_working_segments_engagement(segs_allocated_data, total_segs, num_working_segs, num_data_fragments, num_hosts_in_cluster);
/* 7. Cleanup */
restoreCdbComponentDatabases();
clean_cluster(cluster, num_hosts_in_cluster);
clean_array_of_segs(array_of_segs, total_segs);
clean_allocated_fragments(segs_allocated_data, total_segs);
pfree(array_of_primaries);
}
