extern "C" void node_up_handler_func (uint32_t node_number) {
printf ("Handling node coming online...\n");
auto itW = writeRequests.begin();
while (itW!=writeRequests.end()) {
if(itW->node_id == node_number) {
uint32_t req_id = get_new_request_id();
replace_request_lookups.insert(std::pair<uint32_t, uint32_t>(req_id, req_id));
process_write_chunk (req_id, itW->fd, itW->file_id,
itW->node_id, itW->stripe_id, itW->chunk_num,
itW->offset, itW->buf, itW->count);
printf("Write Request:\n file_id:%d \t node_id:%d\t stripe_id:%d\t chunk_num:%d\n",
itW->file_id, itW->node_id, itW->stripe_id, itW->chunk_num);
writeRequests.erase(itW);
break;
}
itW++;
}
printf("finished restarting teh node :)\n");
}
void IO_Manager::process_write_stripe (uint32_t request_id,
uint32_t replica_request_id,
uint32_t *chunks_written,
uint32_t *replica_chunks_written,
uint32_t file_id, char *pathname,
uint32_t stripe_id, uint32_t stripe_size,
uint32_t chunk_size, const void *buf,
int offset, size_t count) {
uint32_t chunk_id, bytes_written = 0, write_size = 0;
int chunk_offset, node_id, replica_node_id, write_result;
assert (((int)count - offset) <= (int)stripe_size);
printf ("\n(BARISTA) Process Write Stripe\n");
get_first_chunk (&chunk_id, chunk_size, &chunk_offset, offset);
while (bytes_written < count) {
struct file_chunk cur_chunk = {file_id, stripe_id, chunk_id};
// If the chunk does not exists, create it
if (!chunk_exists (cur_chunk)) {
node_id = put_chunk (file_id, pathname, stripe_id, chunk_id);
printf ("\tchunk doesn't exist. Preparing to send chunk to node %d\n", node_id);
chunk_to_node[cur_chunk] = node_id;
}
// If the replica does not exist, create it
if (!chunk_replica_exists (cur_chunk)) {
replica_node_id = put_replica (file_id, pathname, stripe_id,
chunk_id);
printf ("\tchunk replica doesn't exist. Preparing to send chunk replica to node %d\n",
replica_node_id);
chunk_to_replica_node[cur_chunk] = replica_node_id;
}
// Ensure that we have the proper node and replica id's to send data to
node_id = chunk_to_node[cur_chunk];
replica_node_id = chunk_to_replica_node[cur_chunk];
// Determine the size of the write
if (count - bytes_written > chunk_size - chunk_offset) {
write_size = chunk_size - chunk_offset;
}
else {
write_size = count - bytes_written;
}
// Send the write to the node
// ADD FD HERE
printf ("\tprocessing chunk %d (sending to node %d)\n", chunk_id, node_id);
write_result = process_write_chunk (request_id, 0, file_id, node_id, stripe_id,
chunk_id, chunk_offset, (uint8_t *)buf
+ bytes_written, write_size);
printf ("\t\treceived %d from network call.\n", write_result);
// If the write failed
if (write_result == NODE_FAILURE) {
// Set the node to "down" and try again
set_node_down (node_id);
}
else {
// Send the write to the replica node
// ADD FD HERE
printf ("\tprocessing chunk replica %d (sending to node %d)\n", chunk_id,
replica_node_id);
write_result = process_write_chunk (replica_request_id, 0, file_id, replica_node_id, stripe_id,
chunk_id, chunk_offset, (uint8_t *)buf
+ bytes_written, write_size);
// if the replica write failed
if (write_result == NODE_FAILURE) {
// Set the node to "down"
set_node_down (replica_node_id);
// Choose a different replica
replica_node_id = put_replica (file_id, pathname, stripe_id,
chunk_id);
// Re-write the data
process_write_chunk (replica_request_id, 0, file_id, replica_node_id, stripe_id,
chunk_id, chunk_offset, (uint8_t *)buf
+ bytes_written, write_size);
}
// update counters
chunk_offset = 0;
bytes_written += write_size;
chunk_id++;
(*chunks_written)++;
(*replica_chunks_written)++;
}
}
}
