void meta_server_failure_detector::on_ping(const fd::beacon_msg& beacon, ::dsn::service::rpc_replier<fd::beacon_ack>& reply)
{
fd::beacon_ack ack;
ack.this_node = beacon.to;
if (!is_primary())
{
end_point master;
if (_state->get_meta_server_primary(master))
{
ack.time = beacon.time;
ack.is_master = false;
ack.primary_node = master;
}
else
{
ack.time = beacon.time;
ack.is_master = false;
ack.primary_node = end_point::INVALID;
}
}
else
{
failure_detector::on_ping_internal(beacon, ack);
ack.primary_node = primary_address();
}
reply(ack);
}
//send final abort messages to other servers
void send_final_abort_messages(state_type *state, event_content_type * event_content, time_type now) {
int s;
// Get the server configuration from simulation state
SERVER_lp_state_type *pointer = &state->type.server_state;
transaction_metadata *transaction = get_transaction_metadata(event_content->applicative_content.tx_id, pointer);
if (transaction == NULL) {
printf("ERROR: no transaction found with id %d (from client id %d)\n", event_content->applicative_content.tx_id, event_content->applicative_content.client_id);
exit(-1);
}
for (s = state->num_clients; s < state->num_clients + state->num_servers; s++) {
// send a message to other servers containing at least an entry of the transaction write set
int an_entry_founded = 0;
data_set_entry *entry = transaction->write_set;
while (entry != NULL && !an_entry_founded) {
if (pointer->configuration.concurrency_control_type == PRIMARY_OWNER_CTL_2PL) {
if (is_primary(entry->object_key_id, s, state->num_servers, state->num_clients))
an_entry_founded = 1;
} else {
if (is_owner(entry->object_key_id, s, state->num_servers, state->num_clients, state->object_replication_degree))
an_entry_founded = 1;
}
entry = entry->next;
}
if (s != event_content->applicative_content.server_id && an_entry_founded) {
event_content->applicative_content.op_type = TX_REMOTE_ABORT;
event_content->destination_object_id = s;
event_content->applicative_content.write_set = transaction->write_set;
transaction->expected_prepare_response_counter++;
server_send_message(state, event_content, now);
if (pointer->configuration.server_verbose)
printf("S%d - function Server_ProcessEvent: TX_REMOTE_ABORT sent at time %f to server %i\n", event_content->applicative_content.server_id, now, s);
}
}
}
//send prepare messages to other servers
void send_final_commit_messages(state_type *state, event_content_type * event_content, time_type now) {
int s;
// Get the server configuration from simulation state
SERVER_lp_state_type *pointer = &state->type.server_state;
transaction_metadata *transaction = get_transaction_metadata(event_content->applicative_content.tx_id, pointer);
if (transaction == NULL) {
printf("ERROR: no transaction fouded with id %d (from cliendt %d)\n", event_content->applicative_content.tx_id, event_content->applicative_content.client_id);
exit(-1);
}
for (s = state->num_clients; s < state->num_clients + state->num_servers; s++) {
int a_server_founded = 0;
data_set_entry *entry = transaction->write_set;
while (entry != NULL && !a_server_founded) {
if (pointer->configuration.concurrency_control_type == PRIMARY_OWNER_CTL_2PL) {
if (is_primary(entry->object_key_id, s, state->num_servers, state->num_clients))
a_server_founded = 1;
} else {
if (is_owner(entry->object_key_id, s, state->num_servers, state->num_clients, state->object_replication_degree))
a_server_founded = 1;
}
entry = entry->next;
}
if (s != event_content->applicative_content.server_id && a_server_founded) {
event_content_type new_event_content;
memcpy(&new_event_content, event_content, sizeof(event_content_type));
new_event_content.applicative_content.op_type = TX_DISTRIBUTED_FINAL_COMMIT;
new_event_content.destination_object_id = s;
new_event_content.applicative_content.write_set = transaction->write_set;
transaction->expected_prepare_response_counter++;
server_send_final_commit_message(state, &new_event_content, now);
if (pointer->configuration.server_verbose)
printf("S%d - function Server_ProcessEvent: TX_DISTRIBUTED_FINAL_COMMIT sent at time %f to server %i\n", event_content->applicative_content.server_id, now, s);
}
}
}
int print_hash_chain(FILE *list,struct fcb *f, int ix)
{int next,cnt=0;
next = f->buffer_pool.buf_hash_table[ix];
while ( next>=0 ) {
if ( is_primary(f,next) ) fprintf(list,"**");
fprintf(list," %d(",next);
print_leveln_pntr(list,"",&(f->buffer_pool.buffer[next].contents));
fprintf(list,")(%d)",f->buffer_pool.buffer[next].b.level);
if ( is_primary(f,next) ) fprintf(list,"**");
cnt++;
next = f->buffer_pool.buffer[next].hash_next;
}
fprintf(list,"\n");
return(cnt);
}
void meta_server_failure_detector::on_worker_disconnected(const std::vector< ::dsn::rpc_address>& nodes)
{
if (!is_primary())
{
return;
}
if (!_svc->_started)
{
return;
}
node_states states;
for (auto& n : nodes)
{
states.push_back(std::make_pair(n, false));
dwarn("client expired: %s", n.to_string());
}
machine_fail_updates pris;
_state->set_node_state(states, &pris);
for (auto& pri : pris)
{
dinfo("%d.%d primary node for %s is gone, update configuration on meta server",
pri.first.app_id,
pri.first.pidx,
pri.second->node.to_string()
);
_svc->update_configuration_on_machine_failure(pri.second);
}
}
static void remove_tx_locks(int tx_id, data_set_entry *data_set, state_type *state, double now) {
SERVER_lp_state_type *pointer = &state->type.server_state;
data_set_entry *entry = data_set;
while (entry != NULL) {
int need_to_unlock = 0;
if (pointer->configuration.concurrency_control_type == ETL_2PL || pointer->configuration.concurrency_control_type == CTL_2PL)
need_to_unlock = is_owner(entry->object_key_id, pointer->server_id, state->num_servers, state->num_clients, state->object_replication_degree);
else if (pointer->configuration.concurrency_control_type == PRIMARY_OWNER_CTL_2PL)
need_to_unlock = is_primary(entry->object_key_id, pointer->server_id, state->num_servers, state->num_clients);
if (need_to_unlock) {
if ((pointer->cc_metadata->locks[entry->object_key_id] != tx_id)) {
if (pointer->configuration.cc_verbose)
printf("cc%d - lock sull'oggetto %i della tx %d non trovato\n", pointer->server_id, entry->object_key_id, tx_id);
} else {
pointer->cc_metadata->locks[entry->object_key_id] = -1;
if (pointer->configuration.cc_verbose)
printf("cc%d - oggetto %d per la transizione %i unlockato al tempo %f \n", pointer->server_id, entry->object_key_id, tx_id, now);
//Wake up waiting event for key 'object_key_id';
reschedule_event(state, now, entry->object_key_id);
}
}
entry = entry->next;
}
}
void meta_server_failure_detector::on_worker_disconnected(const std::vector<end_point>& nodes)
{
if (!is_primary())
{
return;
}
node_states states;
for (auto& n : nodes)
{
states.push_back(std::make_pair(n, false));
dwarn("client expired: %s:%hu", n.name.c_str(), n.port);
}
machine_fail_updates pris;
_state->set_node_state(states, &pris);
for (auto& pri : pris)
{
dinfo("%d.%d primary node for %s:%hu is gone, update configuration on meta server",
pri.first.app_id,
pri.first.pidx,
pri.second->node.name.c_str(),
pri.second->node.port
);
_svc->update_configuration(pri.second);
}
}
ADDRESS_MAP_END
WRITE_LINE_MEMBER(isa16_ide_device::ide_interrupt)
{
if (is_primary())
{
m_isa->irq14_w(state);
}
else
{
m_isa->irq15_w(state);
}
}
void meta_server_failure_detector::on_worker_connected(const end_point& node)
{
if (!is_primary())
{
return;
}
node_states states;
states.push_back(std::make_pair(node, true));
dwarn("Client reconnected",
"Client %s:%hu", node.name.c_str(), node.port);
_state->set_node_state(states, nullptr);
}
void meta_server_failure_detector::on_worker_connected(::dsn::rpc_address node)
{
if (!is_primary())
{
return;
}
node_states states;
states.push_back(std::make_pair(node, true));
dwarn("Client reconnected",
"Client %s", node.to_string());
_state->set_node_state(states, nullptr);
}
void print_buffer_caption(FILE *list, struct fcb *f, int ix)
{int index_type,level;
index_type = f->buffer_pool.buffer[ix].b.index_type;
level = f->buffer_pool.buffer[ix].b.level;
fprintf(list,"%4d(%2d/" UINT64_formatf(-6),
ix,f->buffer_pool.buffer[ix].contents.segment,f->buffer_pool.buffer[ix].contents.block);
if (index_type==user_ix) {
if ( is_primary(f,ix) ) fprintf(list,"X%2d",level);
else fprintf(list,"x%2d",level);
}
else if (index_type==free_lc_ix) {
if ( is_primary(f,ix) ) fprintf(list,"L%2d",level);
else fprintf(list,"l%2d",level);
}
else if (index_type==free_rec_ix) {
if ( is_primary(f,ix) ) fprintf(list,"R%2d",level);
else fprintf(list,"r%2d",level);
}
if ( f->buffer_pool.buffer[ix].modified ) fprintf(list,"*");
else fprintf(list," ");
if ( f->buffer_pool.buffer[ix].lock_cnt>0 ) fprintf(list,"!)");
else fprintf(list," )");
}
void meta_server_failure_detector::on_ping(const fd::beacon_msg& beacon, ::dsn::rpc_replier<fd::beacon_ack>& reply)
{
fd::beacon_ack ack;
ack.this_node = beacon.to;
if (!is_primary())
{
ack.time = beacon.time;
ack.is_master = false;
ack.primary_node = _primary_address;
}
else
{
failure_detector::on_ping_internal(beacon, ack);
ack.primary_node = primary_address();
}
reply(ack);
}
MailBox::MailBox(MailDatabase* maildb, string name): name(name), maildb(maildb)
{
inbox = is_inbox(name);
primary = is_primary(name);
if (inbox) {
path = maildb->get_maildir();
}
else {
path = "." + name;
// Generate directorypath
size_t index = 0;
while((index = path.find("/", index)) != string::npos)
path.replace(index, 1, ".");
path = maildb->get_maildir() + path + "/";
}
}
void meta_server_failure_detector::on_ping(const fd::beacon_msg& beacon, ::dsn::rpc_replier<fd::beacon_ack>& reply)
{
fd::beacon_ack ack;
ack.time = beacon.time;
ack.this_node = beacon.to;
ack.allowed = true;
if ( !is_primary() )
{
ack.is_master = false;
ack.primary_node = get_primary();
}
else
{
ack.is_master = true;
ack.primary_node = beacon.to;
failure_detector::on_ping_internal(beacon, ack);
}
dinfo("on_ping, is_master(%s), this_node(%s), primary_node(%s)", ack.is_master?"true":"false",
ack.this_node.to_string(), ack.primary_node.to_string());
reply(ack);
}
//send prepare messages to other servers
int send_prepare_messages(state_type *state, transaction_metadata *transaction, event_content_type * event_content, time_type now) {
int s;
int involved_servers=0;
// Get the server configuration from simulation state
SERVER_lp_state_type *pointer = &state->type.server_state;
for (s = state->num_clients; s < state->num_clients + state->num_servers; s++) {
int has_an_object = 0;
data_set_entry *entry = transaction->write_set;
while (entry != NULL && !has_an_object) {
if (pointer->configuration.concurrency_control_type == PRIMARY_OWNER_CTL_2PL) {
if (is_primary(entry->object_key_id, s, state->num_servers, state->num_clients)) {
has_an_object = 1;
break;
}
} else {
if (is_owner(entry->object_key_id, s, state->num_servers, state->num_clients, state->object_replication_degree)) {
has_an_object = 1;
break;
}
}
entry = entry->next;
}
if (s != event_content->applicative_content.server_id && has_an_object) {
event_content_type new_event_content;
memcpy(&new_event_content, event_content, sizeof(event_content_type));
new_event_content.applicative_content.op_type = TX_PREPARE;
new_event_content.destination_object_id = s;
new_event_content.applicative_content.write_set = transaction->write_set;
transaction->expected_prepare_response_counter++;
server_send_prepare_message(state, &new_event_content, now);
involved_servers++;
if (pointer->configuration.server_verbose)
printf("S%d - function Server_ProcessEvent: TX_PREPARE sent at time %f to server %i\n", event_content->applicative_content.server_id, now, s);
}
}
return involved_servers;
}
static gboolean
accelerator_parse (const gchar *accelerator,
MetaKeyCombo *combo)
{
guint keyval, keycode;
MetaVirtualModifier mods;
gint len;
combo->keysym = 0;
combo->keycode = 0;
combo->modifiers = 0;
if (accelerator == NULL)
return FALSE;
keyval = 0;
keycode = 0;
mods = 0;
len = strlen (accelerator);
while (len)
{
if (*accelerator == '<')
{
if (len >= 9 && is_primary (accelerator))
{
/* Primary is treated the same as Control */
accelerator += 9;
len -= 9;
mods |= META_VIRTUAL_CONTROL_MASK;
}
else if (len >= 9 && is_control (accelerator))
{
accelerator += 9;
len -= 9;
mods |= META_VIRTUAL_CONTROL_MASK;
}
else if (len >= 7 && is_shift (accelerator))
{
accelerator += 7;
len -= 7;
mods |= META_VIRTUAL_SHIFT_MASK;
}
else if (len >= 6 && is_shft (accelerator))
{
accelerator += 6;
len -= 6;
mods |= META_VIRTUAL_SHIFT_MASK;
}
else if (len >= 6 && is_ctrl (accelerator))
{
accelerator += 6;
len -= 6;
mods |= META_VIRTUAL_CONTROL_MASK;
}
else if (len >= 6 && is_modx (accelerator))
{
static const guint mod_vals[] = {
META_VIRTUAL_ALT_MASK,
META_VIRTUAL_MOD2_MASK,
META_VIRTUAL_MOD3_MASK,
META_VIRTUAL_MOD4_MASK,
META_VIRTUAL_MOD5_MASK,
};
len -= 6;
accelerator += 4;
mods |= mod_vals[*accelerator - '1'];
accelerator += 2;
}
else if (len >= 5 && is_ctl (accelerator))
{
accelerator += 5;
len -= 5;
mods |= META_VIRTUAL_CONTROL_MASK;
}
else if (len >= 5 && is_alt (accelerator))
{
accelerator += 5;
len -= 5;
mods |= META_VIRTUAL_ALT_MASK;
}
else if (len >= 6 && is_meta (accelerator))
{
accelerator += 6;
len -= 6;
mods |= META_VIRTUAL_META_MASK;
}
else if (len >= 7 && is_hyper (accelerator))
{
accelerator += 7;
len -= 7;
mods |= META_VIRTUAL_HYPER_MASK;
}
else if (len >= 7 && is_super (accelerator))
{
accelerator += 7;
len -= 7;
mods |= META_VIRTUAL_SUPER_MASK;
}
else
{
gchar last_ch;
last_ch = *accelerator;
while (last_ch && last_ch != '>')
{
last_ch = *accelerator;
accelerator += 1;
len -= 1;
}
}
}
else
{
if (len >= 4 && is_keycode (accelerator))
{
keycode = strtoul (accelerator, NULL, 16);
goto out;
}
else if (strcmp (accelerator, "Above_Tab") == 0)
{
keyval = META_KEY_ABOVE_TAB;
goto out;
}
else
{
keyval = xkb_keysym_from_name (accelerator, XKB_KEYSYM_CASE_INSENSITIVE);
if (keyval == XKB_KEY_NoSymbol)
{
char *with_xf86 = g_strconcat ("XF86", accelerator, NULL);
keyval = xkb_keysym_from_name (with_xf86, XKB_KEYSYM_CASE_INSENSITIVE);
g_free (with_xf86);
if (keyval == XKB_KEY_NoSymbol)
return FALSE;
}
}
accelerator += len;
len -= len;
}
}
out:
combo->keysym = keyval;
combo->keycode = keycode;
combo->modifiers = mods;
return TRUE;
}
/**
* egg_accelerator_parse_virtual:
* @accelerator: string representing an accelerator
* @accelerator_key: return location for accelerator keyval
* @accelerator_mods: return location for accelerator modifier mask
*
* Parses a string representing a virtual accelerator. The format
* looks like "<Control>a" or "<Shift><Alt>F1" or
* "<Release>z" (the last one is for key release). The parser
* is fairly liberal and allows lower or upper case, and also
* abbreviations such as "<Ctl>" and "<Ctrl>".
*
* If the parse fails, @accelerator_key and @accelerator_mods will
* be set to 0 (zero) and %FALSE will be returned. If the string contains
* only modifiers, @accelerator_key will be set to 0 but %TRUE will be
* returned.
*
* The virtual vs. concrete accelerator distinction is a relic of
* how the X Window System works; there are modifiers Mod2-Mod5 that
* can represent various keyboard keys (numlock, meta, hyper, etc.),
* the virtual modifier represents the keyboard key, the concrete
* modifier the actual Mod2-Mod5 bits in the key press event.
*
* Returns: %TRUE on success.
*/
gboolean
egg_accelerator_parse_virtual (const gchar *accelerator,
guint *accelerator_key,
EggVirtualModifierType *accelerator_mods)
{
guint keyval;
GdkModifierType mods;
gint len;
gboolean bad_keyval;
if (accelerator_key)
*accelerator_key = 0;
if (accelerator_mods)
*accelerator_mods = 0;
g_return_val_if_fail (accelerator != NULL, FALSE);
bad_keyval = FALSE;
keyval = 0;
mods = 0;
len = strlen (accelerator);
while (len)
{
if (*accelerator == '<')
{
if (len >= 9 && is_release (accelerator))
{
accelerator += 9;
len -= 9;
mods |= EGG_VIRTUAL_RELEASE_MASK;
}
else if (len >= 9 && is_control (accelerator))
{
accelerator += 9;
len -= 9;
mods |= EGG_VIRTUAL_CONTROL_MASK;
}
else if (len >= 7 && is_shift (accelerator))
{
accelerator += 7;
len -= 7;
mods |= EGG_VIRTUAL_SHIFT_MASK;
}
else if (len >= 6 && is_shft (accelerator))
{
accelerator += 6;
len -= 6;
mods |= EGG_VIRTUAL_SHIFT_MASK;
}
else if (len >= 6 && is_ctrl (accelerator))
{
accelerator += 6;
len -= 6;
mods |= EGG_VIRTUAL_CONTROL_MASK;
}
else if (len >= 6 && is_modx (accelerator))
{
static const guint mod_vals[] = {
EGG_VIRTUAL_ALT_MASK, EGG_VIRTUAL_MOD2_MASK, EGG_VIRTUAL_MOD3_MASK,
EGG_VIRTUAL_MOD4_MASK, EGG_VIRTUAL_MOD5_MASK
};
len -= 6;
accelerator += 4;
mods |= mod_vals[*accelerator - '1'];
accelerator += 2;
}
else if (len >= 5 && is_ctl (accelerator))
{
accelerator += 5;
len -= 5;
mods |= EGG_VIRTUAL_CONTROL_MASK;
}
else if (len >= 5 && is_alt (accelerator))
{
accelerator += 5;
len -= 5;
mods |= EGG_VIRTUAL_ALT_MASK;
}
else if (len >= 6 && is_meta (accelerator))
{
accelerator += 6;
len -= 6;
mods |= EGG_VIRTUAL_META_MASK;
}
else if (len >= 7 && is_hyper (accelerator))
{
accelerator += 7;
len -= 7;
mods |= EGG_VIRTUAL_HYPER_MASK;
}
else if (len >= 7 && is_super (accelerator))
{
accelerator += 7;
len -= 7;
mods |= EGG_VIRTUAL_SUPER_MASK;
}
else if (len >= 9 && is_primary (accelerator))
{
accelerator += 9;
len -= 9;
mods |= EGG_VIRTUAL_CONTROL_MASK;
}
else
{
gchar last_ch;
last_ch = *accelerator;
while (last_ch && last_ch != '>')
{
last_ch = *accelerator;
accelerator += 1;
len -= 1;
}
}
}
else
{
keyval = gdk_keyval_from_name (accelerator);
if (keyval == 0)
bad_keyval = TRUE;
accelerator += len;
len -= len;
}
}
if (accelerator_key)
*accelerator_key = gdk_keyval_to_lower (keyval);
if (accelerator_mods)
*accelerator_mods = mods;
return !bad_keyval;
}
int acquire_local_locks(state_type *state, data_set_entry *data_set, time_type timeout, int timeout_event_type, event_content_type *event_content, double now) {
SERVER_lp_state_type *pointer = &state->type.server_state;
data_set_entry *entry = data_set;
if (entry == NULL) {
if (pointer->configuration.cc_verbose)
printf("cc%d - write set of transaction %d is empty\n", pointer->server_id, event_content->applicative_content.tx_id);
return 1;
}
while (entry != NULL) {
int need_to_lock = 0;
if (pointer->configuration.concurrency_control_type == ETL_2PL || pointer->configuration.concurrency_control_type == CTL_2PL)
need_to_lock = is_owner(entry->object_key_id, pointer->server_id, state->num_servers, state->num_clients, state->object_replication_degree);
else if (pointer->configuration.concurrency_control_type == PRIMARY_OWNER_CTL_2PL)
need_to_lock = is_primary(entry->object_key_id, pointer->server_id, state->num_servers, state->num_clients);
if (need_to_lock) {
if (pointer->configuration.cc_verbose)
printf("cc%d - object %d for transaction %i to be locked\n", pointer->server_id, entry->object_key_id, event_content->applicative_content.tx_id);
//check lock...
if (pointer->cc_metadata->locks[entry->object_key_id] == -1) {
//not locked
pointer->cc_metadata->lock_retry_num = 0;
//acquire lock
pointer->cc_metadata->locks[entry->object_key_id] = event_content->applicative_content.tx_id;
if (pointer->configuration.cc_verbose)
printf("cc%d - pbject %d for transaction %i locked at time %f \n", pointer->server_id, entry->object_key_id, event_content->applicative_content.tx_id, now);
} else if (pointer->cc_metadata->locks[entry->object_key_id] == event_content->applicative_content.tx_id) {
// already locked by me
// go to the next entry
} else {
//already locked by another transaction
pointer->cc_metadata->lock_retry_num++;
//check deadlock (if enabled)
if (pointer->configuration.deadlock_detection_enabled && check_deadlock(event_content, pointer)) {
return -1;
}
//add the timeout event
event_content_type new_event_content;
memcpy(&new_event_content, event_content, sizeof(event_content_type));
ScheduleNewEvent(pointer->server_id, now + timeout, timeout_event_type, &new_event_content, sizeof(event_content_type));
//enqueue transaction
memcpy(&new_event_content, event_content, sizeof(event_content_type));
new_event_content.applicative_content.object_key_id = entry->object_key_id;
enqueue_event(pointer, &new_event_content);
transaction_metadata *transaction = get_transaction_metadata(event_content->applicative_content.tx_id, pointer);
if (transaction == NULL) {
if (pointer->configuration.cc_verbose) {
printf("cc%d - transaction %i is not local\n", pointer->server_id, event_content->applicative_content.tx_id);
printf("cc%d - prepare of tx %i added in the waiting event queue %f due to a lock on object %d tx:%i\n", pointer->server_id, event_content->applicative_content.tx_id, now,
entry->object_key_id, new_event_content.applicative_content.tx_id);
}
return 0;
} else {
transaction->is_blocked = 1;
if (pointer->configuration.cc_verbose)
printf("cc%d - transaction %i is waiting at time %f due to a lock on object%d tx:%i\n", pointer->server_id, event_content->applicative_content.tx_id, now, entry->object_key_id,
new_event_content.applicative_content.tx_id);
return 0;
}
}
}
entry = entry->next;
}
return 1;
}
// Returns true if the edge is linear (segment, ray, line).
// Returns false if the edge is curved (parabolic arc).
bool is_linear() const {
if (!is_primary())
return true;
return !(cell()->contains_segment() ^ twin()->cell()->contains_segment());
}
// Returns true if the edge is curved (parabolic arc).
// Returns false if the edge is linear (segment, ray, line).
bool is_curved() const {
if (!is_primary())
return false;
return (cell()->contains_segment() ^ twin()->cell()->contains_segment());
}
// The edge is labelled "secondary" if it is not adjacent
// to a primary face. This means "polyline" edges are
// also considered secondary.
bool is_secondary() const { return !is_primary(); }
