static la_storage_object_put_result bdb_la_storage_replace(la_storage_object_store *store, la_storage_object *obj)
{
DB_TXN *txn;
la_storage_object_header header;
DBT db_key;
DBT db_value;
int result;
memset(&db_key, 0, sizeof(DBT));
memset(&db_value, 0, sizeof(DBT));
db_key.data = obj->key;
db_key.size = db_key.ulen = (uint32_t) strlen(obj->key);
db_key.flags = DB_DBT_USERMEM;
db_value.data = obj->header;
db_value.size = db_value.ulen = la_storage_object_total_size(obj);
db_value.flags = DB_DBT_USERMEM;
if (txn_begin(store->env->env, NULL, &txn, DB_TXN_NOSYNC | DB_TXN_NOWAIT) != 0)
return LA_STORAGE_OBJECT_PUT_ERROR;
db_seq_t seq;
store->seq->get(store->seq, txn, 1, &seq, 0);
obj->header->seq = seq;
if (store->db->put(store->db, txn, &db_key, &db_value, 0) != 0)
{
txn_abort(txn);
return LA_STORAGE_OBJECT_PUT_ERROR;
}
txn_commit(txn, DB_TXN_NOSYNC);
return LA_STORAGE_OBJECT_PUT_SUCCESS;
}
int
edb_txn_commit(edb *db) {
LOG_HERE;
int err = 0;
CHECK_CODE(db->readonly == 0, EDB_ERROR_READ_ONLY);
CHECK(txn_commit(db));
err:
return err;
}
bool
engine::inc_opcount(void)
{
if (++m_opcount>=m_config->txn_group) {
if (!txn_commit())
return (false);
if (!txn_begin())
return (false);
m_opcount=0;
}
return (true);
}
static int bdb_la_storage_stat(la_storage_object_store *store, la_storage_stat_t *stat)
{
DB_TXN *txn;
DB_BTREE_STAT *mainStat, *seqStat;
if (txn_begin(store->env->env, NULL, &txn, DB_READ_COMMITTED | DB_TXN_NOSYNC) != 0)
return -1;
if (store->db->stat(store->db, txn, &mainStat, DB_FAST_STAT | DB_READ_COMMITTED) != 0)
{
txn_abort(txn);
return -1;
}
if (store->db->stat(store->seq_db, txn, &seqStat, DB_FAST_STAT | DB_READ_COMMITTED) != 0)
{
txn_abort(txn);
return -1;
}
stat->numkeys = mainStat->bt_nkeys;
stat->size = ((uint64_t) mainStat->bt_pagecnt * (uint64_t) mainStat->bt_pagesize)
+ ((uint64_t) seqStat->bt_pagecnt * (uint64_t) seqStat->bt_pagesize);
free(mainStat);
free(seqStat);
txn_commit(txn, DB_TXN_NOSYNC);
return 0;
}
/*
* This is a generic message handling loop that is used both by the
* master to accept messages from a client and vice versa.
*/
static void * msg_mng_loop(void *args) {
msg_mng_loop_args *mma;
int eid;
int ret = 0,
retr = 0; /*Number of connection retries*/
int fd,
m_index; /*Index in machtab list*/
char *buffer, * cmd, * cookie, * metric, *cmd_t;
struct node_struct * nd;
long long ballot = -1, instance_proposed = -1, round = -1;
char mes[BUF_SIZE], log_rec[BUF_SIZE];
char id[5];
pthread_t cnt_thr;
nd = &node;
mma = (msg_mng_loop_args *) args;
fd = mma->fd;
eid = mma->eid;
m_index = mma ->m_index;
buffer = (char *) malloc(sizeof (char) * MTR_BUF);
if (buffer == NULL) {
pax_log(LOG_ERR,"msg_mng_loop: malloc: %s\n", strerror(errno));
exit(-1);
}
if (_PAXOS_DEBUG>2)pax_log(LOG_DEBUG,"Message loop for %d\n", m_index);
for (ret = 0; ret == 0;) {
memset(buffer, 0, MTR_BUF);
if (_PAXOS_DEBUG)pax_log(LOG_DEBUG,"Ready for next mesg\n");
ret = get_next_message(fd, buffer, BTRUE);
if (_PAXOS_DEBUG>2)pax_log(LOG_DEBUG,"Get next message ret %d\n", ret);
if (ret == -1 || retr > NRETR) {/*Connection lost*/
if(fd)close(fd);
if (_PAXOS_DEBUG) pax_log(LOG_DEBUG,"Connection with %d lost.\n", nd->machtab[eid].id);
if ((ret = machtab_rem(&node, eid, 1)) != 0)
break;
if (_PAXOS_DEBUG>2) machtab_print();
sleep(rand()%3);
/*Triing to reestablish the connection*/
if ((ret = pthread_create(&cnt_thr, NULL, contact_group, NULL)) != 0) {
pax_log(LOG_ERR,"can't create connection thread: %s\n", strerror(errno));
goto err;
}
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(m_index == nd->updater_id){
nd->updating = BFALSE;
}
if (nd->machtab[m_index].id == nd->master_id
|| ((nd->current)) < QUORUM(nd)) {
pax_log(LOG_ERR, "Connection with master or majority lost.\n");
nd->master_id = -1;
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
sleep(1); /*Sleep some time to wait for others to notice the same event*/
election(nd);
} else if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
break;
}
if (ret == -2) {/*Connection timeouted*/
if (retr <= NRETR) ret = send_mes("PNG;", fd); /*Ping message*/
else {
pax_log(LOG_ERR, "Ping retried %d times. Node probably dead, closing connection.\n", NRETR);
goto err;
}
retr++;
continue;
}
if (buffer != NULL || strlen(buffer) != 0) {
strncpy(log_rec, buffer, BUF_SIZE);
if (_PAXOS_DEBUG>2) pax_log(LOG_DEBUG,"Message %s received %d\n", buffer, nd->machtab[eid].id);
if ((cmd = strtok_r(buffer, ";", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: Command not found\n");
continue;
}
if (strncmp(cmd, "SHU", 3) == 0) {
if(_PAXOS_DEBUG)pax_log(LOG_DEBUG, "Shutting down\n");
exit(0);
}
/*Upon log - the remote node asked for log*/
if (strncmp(cmd, "LOG", 3) == 0) {
if ((cmd_t = strtok_r(cmd, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: LOG: Command not found:\n");
continue;
}
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(nd->non_voting==BTRUE){
continue;
}
if (update_remote_node(m_index, node)==-1) {
nd->master_id = -1;
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
pax_log(LOG_DEBUG>2, "Updating remote node failed, remote node connection lost, election starting\n");
election(nd);
}else if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
pax_log(LOG_DEBUG>2, "Updating started\n");
continue;
}
/*Upon outdated message*/
if (strncmp(cmd, "OUT", 3) == 0) {
if ((cmd_t = strtok_r(cmd, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: OUT: Command not found:\n");
continue;
}
if (strncmp(cookie, "BEG", 3) == 0) {/*The transfer started*/
nd->updater_id = m_index;
clear_logs();
lock_snapshotting();
pax_log(LOG_ERR, "Logs cleared:\n");
} else if (strncmp(cookie, "SSM", 3) == 0) {
if ((cmd = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: OUT: Command not found:\n");
continue;
}
write_snapshot_mark(cookie);
} else
if (strncmp(cookie, "SST", 3) == 0) {/*Snapshot*/
char * met_name;
if ((cmd = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: OUT: Command not found:\n");
continue;
}
if ((met_name = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: OUT: Command not found:\n");
continue;
}
write_metric_snap(met_name, cookie);
}else
if (strncmp(cookie, "FIN", 3) == 0) { /*The transfer finnished*/
int rt = 0;
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
rt = write_log_out_hash();
rt+= out_hash();
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
rt += process_logs(&node);
unlock_snapshotting();
if (rt==0) {
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(_PAXOS_DEBUG) pax_log(LOG_DEBUG, "Voting allowed\n");
nd->updating = BFALSE;
nd->non_voting = BFALSE; /*The node can vote again*/
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
}else {
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(_PAXOS_DEBUG) pax_log(LOG_DEBUG, "Wrong update\n");
send_mes("LOG;", fd);
nd->updater_id = m_index;
nd->updating = BTRUE;
nd->non_voting = BTRUE; /*The node can vote again*/
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
}
} else write_log_out_record(cookie);
continue;
}
/*UPON NextBallot(ballot, instance proposed)*/
/*NXB:%lld:%lld;*/
if (strncmp(cmd, "NXB", 3) == 0) {
if ((cmd_t = strtok_r(cmd, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: NXB: Command not found:\n");
continue;
}
if ((cmd_t = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: NXB: Command not found:\n");
continue;
}
ballot = atoll(cmd_t);
if ((cmd_t = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: NXB: Command not found:\n");
continue;
}
instance_proposed = atoll(cmd_t);
round = atoll(cookie);
sprintf(mes, "%lld:%lld", ballot, paxos.last_instance);
if (ballot >= paxos.nextBallot) {
paxos.nextBallot = ballot;
if (instance_proposed == (paxos.last_instance + 1) && round == (paxos.previous_round+1)) {
char * ack_mes;
ack_mes = malloc((4 + sizeof (char)) * strlen(mes));
if (!ack_mes) {
pax_log(LOG_ERR,"NXB response message creation: %s\n", strerror(errno));
exit(EX_OSERR);
}
sprintf(ack_mes, "N_A:%s;", mes); /*Acknowledge the message*/
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(!nd->non_voting) {
send_mes(ack_mes, fd);
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
free(ack_mes);
} else if (instance_proposed <= paxos.last_instance) {
/*Remote node is outdated*/
char * nack_mes;
nack_mes = malloc((4 + sizeof (char)) * strlen(mes));
if (!nack_mes) {
pax_log(LOG_ERR,"NXB response message creation: %s\n", strerror(errno));
exit(EX_OSERR);
}
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
sprintf(nack_mes, "N_N:%s;", mes); /*Nack the message*/
if(!nd->non_voting) {
send_mes(nack_mes, fd);
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
free(nack_mes);
} else if(instance_proposed > (paxos.last_instance + 1) || round > (paxos.previous_round+1)){
/*Local node is outdated*/
/*char * ack_mes;*/
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
nd->non_voting = BTRUE; /*The local node cannot vote*/
if (!nd->updating) {
if (_PAXOS_DEBUG) pax_log(LOG_DEBUG, "NXB\n");
send_mes("LOG;", fd);
nd->updater_id = m_index;
nd->updating = BTRUE;
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
}
} else {
char * nack_mes;
nack_mes = malloc((4 + sizeof (char)) * strlen(mes));
if (!nack_mes) {
pax_log(LOG_ERR,"NXB response message creation: %s\n", strerror(errno));
exit(EX_OSERR);
}
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
sprintf(nack_mes, "N_N:%s;", mes); /*Nack the message*/
if(!nd->non_voting) {
send_mes(nack_mes, fd);
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
free(nack_mes);
}
continue;
}
/*UPON BeginBallot(ballot, instance,round, previous_instances, metric)*/
if (strncmp(cmd, "BEB", 3) == 0) {
if ((cmd_t = strtok_r(cmd, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: BEB: Command not found:\n");
continue;
}
if ((cmd_t = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: BEB: Command not found:\n");
continue;
}
ballot = atoll(cmd_t);
if ((cmd_t = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: BEB: Command not found:\n");
continue;
}
instance_proposed = atoll(cmd_t);
if ((cmd_t = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: BEB: Command not found:\n");
continue;
}
round = atoll(cmd_t);
metric = strdup(cookie);
sprintf(mes, "%lld:%lld:%d:", instance_proposed, ballot, m_index);
if (ballot >= paxos.nextBallot) {
if ((instance_proposed >= paxos.last_instance && round > paxos.previous_round)) {
if (instance_proposed > (paxos.last_instance + 1) || round > (paxos.previous_round + 1)) {
/*Local node is out-dated*/
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
nd->non_voting = BTRUE; /*Local node cannot vote*/
if(_PAXOS_DEBUG) pax_log(LOG_DEBUG, "BEB received - voting forbidden\n");
if (!nd->updating) {
send_mes("LOG;", fd);
nd->updater_id = m_index;
nd->updating = BTRUE;
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
}
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
write_log_record(log_rec, BFALSE, BFALSE);
/*Begin transaction*/
if (txn_begin(nd->machtab[m_index].id - 1, instance_proposed, round, metric) != 0) {
/*In the case of failure*/
sprintf(mes, "B_N:%lld:%lld:%lld:%d;", paxos.last_instance,
paxos.previous_round, paxos.nextBallot, m_index); /*Nack the message*/
send_mes(mes, fd);
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
continue;
}
pax_log(LOG_DEBUG>2, "BEB txn done\n");
if(!nd->non_voting) {
sprintf(mes, "B_A:%lld:0:%lld:%d;", instance_proposed, ballot, m_index); /*Acknowledge the message*/
send_mes(mes, fd);
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
}
} else {
/*remote node is outdated*/
/*Nack the message*/
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(!nd->non_voting) {
sprintf(mes, "B_N:%lld:%lld:%lld:%d;", paxos.last_instance, paxos.previous_round, paxos.nextBallot, m_index);
send_mes(mes, fd);
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
}
continue;
}
/*Ping message*/
if (strncmp(cmd, "PNG", 3) == 0) {
retr = 0;
}
//UPON Success(round , instance, previous_instances)
//SUC:%lld:%lld:%s;
if (strncmp(cmd, "SUC", 3) == 0) {
if ((cmd_t = strtok_r(cmd, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: SUC: Command not found:\n");
continue;
}
if ((cmd_t = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: SUC: Command not found:\n");
continue;
}
round = atoll(cmd_t);
if ((cmd_t = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: SUC: Command not found:\n");
continue;
}
instance_proposed = atoll(cmd_t);
if (instance_proposed >= paxos.last_instance && round > paxos.previous_round) {
char mtc[MTR_BUF];
if (instance_proposed > (paxos.last_instance + 1) || round > (paxos.previous_round + 1)) {
/*Local node is out-dated*/
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(_PAXOS_DEBUG>2) pax_log(LOG_DEBUG, "SUC received - voting forbidden\n");
nd->non_voting = BTRUE; /*Local node cannot vote*/
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
}
if (pthread_mutex_lock(&nd->mtmutex) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
paxos.last_instance = instance_proposed;
paxos.previous_round = round;
nd->master_id = nd->machtab[m_index].id;
nd->paxos_state = 0;
write_log_record(log_rec, BFALSE, BTRUE);
if (txn_commit(
nd->machtab[m_index].id - 1,
instance_proposed, round) == NULL) {
pax_log(LOG_ERR, "Local value cannot be changed to requested value. (null) value commited.\n");
pax_log(LOG_ERR, "Maybe something lost, voting forbidden.\n");
if(_PAXOS_DEBUG>2) pax_log(LOG_DEBUG, "SUC received - voting forbidden\n");
nd->non_voting = BTRUE; /*Local node cannot vote*/
} else {
strcpy(mtc, txn_commit(
nd->machtab[m_index].id - 1,
instance_proposed, round));
if (strncmp(mtc, "NA", 2) != 0) {/*If not voting round*/
if (strncmp(mtc, "REM:", 4) == 0) {/*If not removing*/
if (memory_remove_local(mtc) != 0) {
pax_log(LOG_ERR, "Local value cannot be changed to requested value.\n");
}
} else if (memory_update_local(mtc) != 0) {
pax_log(LOG_ERR, "Local metric cannot be removed.\n");
if (_PAXOS_DEBUG>2) pax_log(LOG_DEBUG,"Value updated %s\n", mtc);
}
}
if(_PAXOS_DEBUG>2)print_db_state();
if (nd->non_voting)
if (nd->master_id == nd->machtab[m_index].id && !nd->updating) {
send_mes("LOG;", fd);
nd->updater_id = m_index;
nd->updating = BTRUE;
}
if (_PAXOS_DEBUG>1) pax_log(LOG_DEBUG,"Commited %s\n", txn_commit(nd->machtab[m_index].id - 1, instance_proposed, round));
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
}else{
if (_PAXOS_DEBUG>1) pax_log(LOG_DEBUG,"SUC ignoring. Should be inst: %lld >= %lld, round: %lld > %lld\n", instance_proposed, paxos.last_instance, round, paxos.previous_round);
}
if (_PAXOS_DEBUG>1) pax_log(LOG_DEBUG,"New master is %d\n", nd->master_id);
}
/*B_A, B_N, N_A, N_N*/
/*BEB acknowlegdes and NACKs*/
if ((strncmp(cmd, "B_A", 3) == 0) || (strncmp(cmd, "B_N", 3) == 0)){
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(nd->paxos_state != 4) {
if(_PAXOS_DEBUG>2) pax_log(LOG_DEBUG, "Not allowed BA/BN\n");
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
continue;
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
sprintf(mes, "%s:%d;", cmd, m_index);
/*Inform the initiate consensus thread*/
write(paxpipe[m_index][1], mes, strlen(mes) * sizeof (char));
}
if ((strncmp(cmd, "N_A", 3) == 0) || (strncmp(cmd, "N_N", 3) == 0)) {
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(nd->paxos_state != 2) {
if(_PAXOS_DEBUG>2) pax_log(LOG_DEBUG, "Not allowed NA/NN, state %d\n", nd->paxos_state);
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
continue;
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
sprintf(mes, "%s:%d;", cmd, m_index);
/*Inform the initiate consensus thread*/
write(paxpipe[m_index][1], mes, strlen(mes) * sizeof (char));
}
/*Who is the master?*/
if (strncmp(cmd, "WIM", 3) == 0) {
if (pthread_mutex_lock(&nd->mtmutex) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if (nd->machtab[m_index].id == nd->master_id) {
nd->master_id = -1;
nd->updating = BFALSE;
}
sprintf(id, "%d", node.master_id);
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
sprintf(mes, "MIS:%s:%lld:%lld;", id, paxos.last_instance, paxos.previous_round);
send_mes(mes, fd);
}
/*master is id*/
/*MIS:id:inst:round;*/
if (strncmp(cmd, "MIS", 3) == 0) {
long long rd, inst;
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(nd->paxos_state != 1) {
if(_PAXOS_DEBUG>2) pax_log(LOG_DEBUG, "Not allowed MIS\n");
if (_PAXOS_DEBUG>2) pax_log(LOG_DEBUG,"State is %d.\n", (int) nd->paxos_state);
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
continue;
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
if ((cmd = strtok_r(cmd, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: MIS: Command not found:\n");
continue;
}
if ((cmd = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: MIS: Command not found:\n");
continue;
}
sprintf(mes, "ID:%d;", atoi(cmd));
if ((cmd = strtok_r(cookie, ":", &cookie)) == NULL) {
pax_log(LOG_ERR, "Receiver: MIS: Command not found:\n");
continue;
}
inst = atoll(cmd);
rd = atoll(cookie);
if ((inst > (paxos.last_instance) && rd > (paxos.previous_round))
|| (inst == (paxos.last_instance) && rd > (paxos.previous_round))) {
/*Local node is out-dated*/
if ((ret = pthread_mutex_lock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't lock mutex\n");
exit(EX_OSERR);
}
if(_PAXOS_DEBUG>2) pax_log(LOG_DEBUG, "MIS - voting forbidden\n");
nd->non_voting = BTRUE; /*Local node cannot vote*/
if (!nd->updating) {
send_mes("LOG;", fd);
nd->updater_id = m_index;
nd->updating = BTRUE;
}
if ((ret = pthread_mutex_unlock(&nd->mtmutex)) != 0) {
pax_log(LOG_ERR, "can't unlock mutex\n");
exit(EX_OSERR);
}
}
/*Inform ask_for_master*/
write(wimpipe[m_index][1], mes, strlen(mes) * sizeof (char));
}
}
}
err:
if (_PAXOS_DEBUG>1) pax_log(LOG_DEBUG,"Connection thread exiting %d\n", m_index);
if (buffer != NULL) free(buffer);
free(mma);
return ((void *) (uintptr_t) ret);
}
int
b_txn(int argc, char *argv[])
{
extern char *optarg;
extern int optind;
DB_ENV *dbenv;
DB_TXN *txn;
int tabort, ch, i, count;
count = 1000;
tabort = 0;
while ((ch = getopt(argc, argv, "ac:")) != EOF)
switch (ch) {
case 'a':
tabort = 1;
break;
case 'c':
count = atoi(optarg);
break;
case '?':
default:
return (usage());
}
argc -= optind;
argv += optind;
if (argc != 0)
return (usage());
/* Create the environment. */
DB_BENCH_ASSERT(db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR < 1
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR,
NULL, DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG |
DB_INIT_MPOOL | DB_INIT_TXN | DB_PRIVATE, 0666) == 0);
#else
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR,
DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG |
DB_INIT_MPOOL | DB_INIT_TXN | DB_PRIVATE, 0666) == 0);
#endif
/* Start and commit/abort a transaction count times. */
TIMER_START;
if (tabort)
for (i = 0; i < count; ++i) {
#if DB_VERSION_MAJOR < 4
DB_BENCH_ASSERT(txn_begin(dbenv, NULL, &txn, 0) == 0);
DB_BENCH_ASSERT(txn_abort(txn) == 0);
#else
DB_BENCH_ASSERT(
dbenv->txn_begin(dbenv, NULL, &txn, 0) == 0);
DB_BENCH_ASSERT(txn->abort(txn) == 0);
#endif
}
else
for (i = 0; i < count; ++i) {
#if DB_VERSION_MAJOR < 4
DB_BENCH_ASSERT(txn_begin(dbenv, NULL, &txn, 0) == 0);
DB_BENCH_ASSERT(txn_commit(txn, 0) == 0);
#else
DB_BENCH_ASSERT(
dbenv->txn_begin(dbenv, NULL, &txn, 0) == 0);
DB_BENCH_ASSERT(txn->commit(txn, 0) == 0);
#endif
}
TIMER_STOP;
printf("# %d empty transaction start/%s pairs\n",
count, tabort ? "abort" : "commit");
TIMER_DISPLAY(count);
DB_BENCH_ASSERT(dbenv->close(dbenv, 0) == 0);
return (0);
}
int
b_recover(int argc, char *argv[])
{
extern char *optarg;
extern int optind;
DB *dbp;
DBT key, data;
DB_ENV *dbenv;
DB_TXN *txn;
u_int32_t cachesize;
int ch, i, count;
/*
* Recover was too slow before release 4.0 that it's not worth
* running the test.
*/
#if DB_VERSION_MAJOR < 4
return (0);
#endif
cachesize = MEGABYTE;
count = 1000;
while ((ch = getopt(argc, argv, "C:c:")) != EOF)
switch (ch) {
case 'C':
cachesize = (u_int32_t)atoi(optarg);
break;
case 'c':
count = atoi(optarg);
break;
case '?':
default:
return (usage());
}
argc -= optind;
argv += optind;
if (argc != 0)
return (usage());
/* Create the environment. */
DB_BENCH_ASSERT(db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
DB_BENCH_ASSERT(dbenv->set_cachesize(dbenv, 0, cachesize, 0) == 0);
#define OFLAGS \
(DB_CREATE | DB_INIT_LOCK | \
DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN | DB_PRIVATE)
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 0
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR, NULL, OFLAGS, 0666) == 0);
#endif
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR, OFLAGS, 0666) == 0);
#endif
#if DB_VERSION_MAJOR > 3 || DB_VERSION_MINOR > 1
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR, OFLAGS, 0666) == 0);
#endif
/* Create the database. */
DB_BENCH_ASSERT(db_create(&dbp, dbenv, 0) == 0);
#if DB_VERSION_MAJOR >= 4 && DB_VERSION_MINOR >= 1
DB_BENCH_ASSERT(dbp->open(dbp, NULL,
TESTFILE, NULL, DB_BTREE, DB_CREATE | DB_AUTO_COMMIT, 0666) == 0);
#else
DB_BENCH_ASSERT(
dbp->open(dbp, TESTFILE, NULL, DB_BTREE, DB_CREATE, 0666) == 0);
#endif
/* Initialize the data. */
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
key.size = data.size = 20;
key.data = data.data = "01234567890123456789";
/* Start/commit a transaction count times. */
for (i = 0; i < count; ++i) {
#if DB_VERSION_MAJOR < 4
DB_BENCH_ASSERT(
txn_begin(dbenv, NULL, &txn, DB_TXN_NOSYNC) == 0);
DB_BENCH_ASSERT(dbp->put(dbp, txn, &key, &data, 0) == 0);
DB_BENCH_ASSERT(txn_commit(txn, 0) == 0);
#else
DB_BENCH_ASSERT(
dbenv->txn_begin(dbenv, NULL, &txn, DB_TXN_NOSYNC) == 0);
DB_BENCH_ASSERT(dbp->put(dbp, txn, &key, &data, 0) == 0);
DB_BENCH_ASSERT(txn->commit(txn, 0) == 0);
#endif
}
DB_BENCH_ASSERT(dbp->close(dbp, 0) == 0);
DB_BENCH_ASSERT(dbenv->close(dbenv, 0) == 0);
/* Create a new DB_ENV handle. */
DB_BENCH_ASSERT(db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
DB_BENCH_ASSERT(
dbenv->set_cachesize(dbenv, 0, 1048576 /* 1MB */, 0) == 0);
/* Now run recovery. */
TIMER_START;
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 0
DB_BENCH_ASSERT(dbenv->open(
dbenv, TESTDIR, NULL, OFLAGS | DB_RECOVER, 0666) == 0);
#endif
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1
DB_BENCH_ASSERT(
dbenv->open(dbenv, TESTDIR, OFLAGS | DB_RECOVER, 0666) == 0);
#endif
#if DB_VERSION_MAJOR > 3 || DB_VERSION_MINOR > 1
DB_BENCH_ASSERT(
dbenv->open(dbenv, TESTDIR, OFLAGS | DB_RECOVER, 0666) == 0);
#endif
TIMER_STOP;
/*
* We divide the time by the number of transactions, so an "operation"
* is the recovery of a single transaction.
*/
printf("# recovery after %d transactions\n", count);
TIMER_DISPLAY(count);
DB_BENCH_ASSERT(dbenv->close(dbenv, 0) == 0);
return (0);
}
int
ofcds_copyconfig(void *UNUSED(data), NC_DATASTORE target,
NC_DATASTORE source, char *config, struct nc_err **error)
{
int ret = EXIT_FAILURE;
char *s;
xmlDocPtr src_doc = NULL;
xmlDocPtr dst_doc = NULL;
xmlNodePtr root;
static const char *ds[] = {"error", "<config>", "URL", "running",
"startup", "candidate"};
nc_verb_verbose("OFC COPY-CONFIG (from %s to %s)", ds[source], ds[target]);
switch (source) {
case NC_DATASTORE_RUNNING:
s = ofcds_getconfig(NULL, NC_DATASTORE_RUNNING, error);
if (!s) {
nc_verb_error
("copy-config: unable to get running source repository");
return EXIT_FAILURE;
}
src_doc = xmlReadMemory(s, strlen(s), NULL, NULL, XML_READ_OPT);
free(s);
if (!src_doc) {
nc_verb_error("copy-config: invalid running source data");
*error = nc_err_new(NC_ERR_OP_FAILED);
nc_err_set(*error, NC_ERR_PARAM_INFO_BADELEM,
"invalid running source data");
return EXIT_FAILURE;
}
break;
case NC_DATASTORE_STARTUP:
src_doc = xmlCopyDoc(gds_startup, 1);
break;
case NC_DATASTORE_CANDIDATE:
src_doc = xmlCopyDoc(gds_cand, 1);
break;
case NC_DATASTORE_CONFIG:
if (config && strlen(config) > 0) {
src_doc = xmlReadMemory(config, strlen(config), NULL, NULL,
XML_READ_OPT);
}
if (!config || (strlen(config) > 0 && !src_doc)) {
nc_verb_error("Invalid source configuration data.");
*error = nc_err_new(NC_ERR_BAD_ELEM);
nc_err_set(*error, NC_ERR_PARAM_INFO_BADELEM, "config");
return EXIT_FAILURE;
}
break;
default:
nc_verb_error("Invalid <get-config> source.");
*error = nc_err_new(NC_ERR_BAD_ELEM);
nc_err_set(*error, NC_ERR_PARAM_INFO_BADELEM, "source");
return EXIT_FAILURE;
}
switch (target) {
case NC_DATASTORE_RUNNING:
/* apply source to OVSDB */
s = ofcds_getconfig(NULL, NC_DATASTORE_RUNNING, error);
if (!s) {
nc_verb_error("copy-config: unable to get running source data");
goto cleanup;
}
dst_doc = xmlReadMemory(s, strlen(s), NULL, NULL, XML_READ_OPT);
free(s);
root = xmlDocGetRootElement(src_doc);
if (!dst_doc) {
/* create envelope */
dst_doc = xmlNewDoc(BAD_CAST "1.0");
}
if (!rollbacking) {
store_rollback(xmlCopyDoc(dst_doc, 1), target);
}
txn_init();
if (edit_replace(dst_doc, root, 1, error)) {
txn_abort();
} else {
ret = txn_commit(error);
}
xmlFreeDoc(dst_doc);
goto cleanup;
break;
case NC_DATASTORE_STARTUP:
case NC_DATASTORE_CANDIDATE:
/* create copy */
if (src_doc) {
dst_doc = src_doc;
src_doc = NULL;
}
/* store the copy */
if (target == NC_DATASTORE_STARTUP) {
if (!rollbacking) {
store_rollback(gds_startup, target);
} else {
xmlFreeDoc(gds_startup);
}
gds_startup = dst_doc;
} else { /* NC_DATASTORE_CANDIDATE */
if (!rollbacking) {
store_rollback(gds_cand, target);
} else {
xmlFreeDoc(gds_cand);
}
gds_cand = dst_doc;
}
break;
default:
nc_verb_error("Invalid <get-config> source.");
*error = nc_err_new(NC_ERR_BAD_ELEM);
nc_err_set(*error, NC_ERR_PARAM_INFO_BADELEM, "source");
goto cleanup;
}
ret = EXIT_SUCCESS;
cleanup:
xmlFreeDoc(src_doc);
return ret;
}
int
ofcds_editconfig(void *UNUSED(data), const nc_rpc * UNUSED(rpc),
NC_DATASTORE target, const char *config,
NC_EDIT_DEFOP_TYPE defop,
NC_EDIT_ERROPT_TYPE UNUSED(errop), struct nc_err **error)
{
int ret = EXIT_FAILURE, running = 0;
char *aux;
int cfgds_new = 0;
xmlDocPtr cfgds = NULL, cfg = NULL, cfg_clone = NULL;
xmlNodePtr rootcfg;
if (defop == NC_EDIT_DEFOP_NOTSET) {
defop = NC_EDIT_DEFOP_MERGE;
}
cfg = xmlReadMemory(config, strlen(config), NULL, NULL, XML_READ_OPT);
rootcfg = xmlDocGetRootElement(cfg);
if (!cfg
|| (rootcfg
&& !xmlStrEqual(rootcfg->name, BAD_CAST "capable-switch"))) {
nc_verb_error("Invalid <edit-config> configuration data.");
*error = nc_err_new(NC_ERR_BAD_ELEM);
nc_err_set(*error, NC_ERR_PARAM_INFO_BADELEM, "config");
return EXIT_FAILURE;
}
switch (target) {
case NC_DATASTORE_RUNNING:
/* Make a copy of parsed config - we will find port/configuration in
* it. It is used after txn_commit(). */
cfg_clone = xmlCopyDoc(cfg, 1);
aux = ofc_get_config_data();
if (!aux) {
*error = nc_err_new(NC_ERR_OP_FAILED);
goto error_cleanup;
}
cfgds = xmlReadMemory(aux, strlen(aux), NULL, NULL, XML_READ_OPT);
free(aux);
running = 1;
break;
case NC_DATASTORE_STARTUP:
cfgds = gds_startup;
break;
case NC_DATASTORE_CANDIDATE:
cfgds = gds_cand;
break;
default:
nc_verb_error("Invalid <edit-config> target.");
*error = nc_err_new(NC_ERR_BAD_ELEM);
nc_err_set(*error, NC_ERR_PARAM_INFO_BADELEM, "target");
goto error_cleanup;
}
store_rollback(xmlCopyDoc(cfgds, 1), target);
/* check keys in config's lists */
ret = check_keys(cfg, error);
if (ret != EXIT_SUCCESS) {
goto error_cleanup;
}
/* check operations */
ret = check_edit_ops(NC_EDIT_OP_DELETE, defop, cfgds, cfg, error);
if (ret != EXIT_SUCCESS) {
goto error_cleanup;
}
ret = check_edit_ops(NC_EDIT_OP_CREATE, defop, cfgds, cfg, error);
if (ret != EXIT_SUCCESS) {
goto error_cleanup;
}
if (target == NC_DATASTORE_RUNNING) {
txn_init();
}
ret = compact_edit_operations(cfg, defop);
if (ret != EXIT_SUCCESS) {
nc_verb_error("Compacting edit-config operations failed.");
if (error != NULL) {
*error = nc_err_new(NC_ERR_OP_FAILED);
}
goto error_cleanup;
}
/* perform operations */
if (!cfgds) {
cfgds_new = 1;
cfgds = xmlNewDoc(BAD_CAST "1.0");
}
ret = edit_operations(cfgds, cfg, defop, running, error);
if (ret != EXIT_SUCCESS) {
goto error_cleanup;
}
/* with defaults capability */
if (ncdflt_get_basic_mode() == NCWD_MODE_TRIM) {
/* server work in trim basic mode and therefore all default values
* must be removed from the datastore. */
/* TODO */
}
if (target == NC_DATASTORE_RUNNING) {
ret = txn_commit(error);
if (ret == EXIT_SUCCESS) {
/* modify port/configuration of ports that were created */
ret = of_post_ports(xmlDocGetRootElement(cfg_clone), error);
}
/* config clone was used and it is not needed by now */
xmlFreeDoc(cfg_clone);
xmlFreeDoc(cfgds);
} else if (cfgds_new){
if (cfgds->children) {
/* document changed, because we started with empty document */
if (target == NC_DATASTORE_STARTUP) {
gds_startup = cfgds;
cfgds = NULL;
} else if (target == NC_DATASTORE_CANDIDATE) {
gds_cand = cfgds;
cfgds = NULL;
}
}
xmlFreeDoc(cfgds);
}
xmlFreeDoc(cfg);
return ret;
error_cleanup:
if (target == NC_DATASTORE_RUNNING) {
txn_abort();
xmlFreeDoc(cfg_clone);
xmlFreeDoc(cfgds);
}
xmlFreeDoc(cfg);
return ret;
}
db_t db_init(const size_t size, const char * const path, const int flags, const int mode, int mdb_flags, int ndbi, dbi_t *dbis, size_t padsize){
int fd = -1, err = 0xdeadbeef;
struct stat st;
db_t db;
db = malloc(size < sizeof(*db) ? sizeof(*db) : size);
assert(db);
// always do this
mdb_flags |= MDB_NOSUBDIR;
int r;
// ignore MDB_RDONLY - key off of OS flags
// see docs for open() - O_RDONLY is not a bit!
if((flags & 0x3) == O_RDONLY){
mdb_flags |= MDB_RDONLY;
// disable NOSYNC/NOMETASYNC for readonly, as that burns another file descriptor
mdb_flags &= ~(MDB_NOSYNC|MDB_NOMETASYNC);
}else{
mdb_flags &= ~MDB_RDONLY;
}
// default to 100mb minimum pad
db->padsize = padsize ? padsize : (1<<27);
db->env = NULL;
db->txns = 0;
db->handles = NULL;
db->updated = 0;
r = pthread_mutex_init(&db->mutex, NULL);
FAIL(r, err, errno, fail);
r = pthread_cond_init(&db->cond, NULL);
FAIL(r, err, errno, fail);
// unless MDB_RDONLY is specified, lmdb will automatically create non-existant databases,
// which is not what I want. Try to emulate standard unix open() flags:
fd = open(path, flags, mode);
FAIL(-1 == fd, err, errno, fail);
r = mdb_env_create(&db->env);
FAIL(r, err, r, fail);
r = mdb_env_set_maxdbs(db->env, ndbi);
FAIL(r, err, r, fail);
size_t mapsize;
do{
r = fstat(fd, &st);
FAIL(r, err, errno, fail);
if(!st.st_size &&( flags & O_CREAT))
db->updated = 1;
// pad out such that we have at least 1gb of map overhead
mapsize = (1 + st.st_size / db->padsize) * db->padsize;
r = mdb_env_set_mapsize(db->env, mapsize);
}while(MDB_SUCCESS != r);
close(fd);
fd = -1;
r = mdb_env_open(db->env, path, mdb_flags, mode);
// mdb_env_open can return EAGAIN somehow, but I think it really means:
if(EAGAIN == r)
r = EMFILE;
FAIL(r, err, r, fail);
r = mdb_env_get_fd(db->env, &db->fd);
FAIL(r, err, r, fail);
if(dbis && ndbi){
db->handles = malloc(sizeof(db->handles[0]) * ndbi);
FAIL(!db->handles, err, errno, fail);
// open the indexes - try read-only first
unsigned int txn_flags = MDB_RDONLY;
txn_t txn = db_txn_new(db, NULL, txn_flags);
int i;
for(i = 0; i < ndbi; i++){
int dbflags = dbis[i].flags;
retry:
dbflags = (txn_flags & MDB_RDONLY) ? (dbflags & ~MDB_CREATE) : (dbflags | MDB_CREATE);
r = mdb_dbi_open(txn->txn, dbis[i].name, dbflags, &db->handles[i]);
if(MDB_SUCCESS != r){
if(MDB_NOTFOUND == r && (txn_flags & MDB_RDONLY)){
// we were in read-only and a sub-db was missing
// end txn
txn_commit(txn);
// switch to read-write
txn_flags &= ~MDB_RDONLY;
txn = db_txn_new(db, NULL, txn_flags);
// and pick up where we left off
goto retry;
}else{
txn_abort(txn);
}
FAIL(r, err, r, fail);
}
}
r = txn_commit(txn);
FAIL(r, err, r, fail);
}
return db;
fail:
db_close(db);
if(fd != -1){
if((flags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))
unlink(path);
close(fd);
}
errno = err;
return NULL;
}
/**
* Put an object into the store.
*/
static la_storage_object_put_result bdb_la_storage_put(la_storage_object_store *store, const la_storage_rev_t *rev, la_storage_object *obj)
{
DB_TXN *txn;
la_storage_object_header header;
DBT db_key;
DBT db_value_read, db_value_write;
int result;
#if DEBUG
printf("putting %u bytes:\n", obj->data_length);
la_hexdump(la_storage_object_get_data(obj), obj->data_length);
#endif
memset(&db_key, 0, sizeof(DBT));
memset(&db_value_read, 0, sizeof(DBT));
memset(&db_value_write, 0, sizeof(DBT));
db_key.data = obj->key;
db_key.size = (u_int32_t) strlen(obj->key);
db_key.ulen = (u_int32_t) strlen(obj->key);
db_key.flags = DB_DBT_USERMEM;
db_value_read.data = &header;
db_value_read.ulen = sizeof(la_storage_object_header);
db_value_read.dlen = sizeof(la_storage_object_header);
db_value_read.doff = 0;
db_value_read.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
if (txn_begin(store->env->env, NULL, &txn, DB_TXN_NOSYNC | DB_TXN_NOWAIT) != 0)
return LA_STORAGE_OBJECT_PUT_ERROR;
result = store->db->get(store->db, txn, &db_key, &db_value_read, DB_RMW);
if (result != 0 && result != DB_NOTFOUND)
{
txn_abort(txn);
if (result == DB_LOCK_NOTGRANTED)
return LA_STORAGE_OBJECT_PUT_CONFLICT;
return LA_STORAGE_OBJECT_PUT_ERROR;
}
if (result != DB_NOTFOUND)
{
debug("data size: %d, data: %s\n", db_value_read.size, db_value_read.data);
if (rev == NULL || memcmp(rev, &header.rev, sizeof(la_storage_rev_t)) != 0)
{
txn_abort(txn);
return LA_STORAGE_OBJECT_PUT_CONFLICT;
}
obj->header->doc_seq = header.doc_seq + 1;
if (header.rev_count < LA_OBJECT_MAX_REVISION_COUNT)
{
obj->header = realloc(obj->header, la_storage_object_total_size(obj) + sizeof(la_storage_rev_t));
// If we added a revision, move the object data up to make room.
memmove(la_storage_object_get_data(obj) + sizeof(la_storage_rev_t), la_storage_object_get_data(obj), obj->data_length);
obj->header->rev_count = header.rev_count + 1;
}
// Move the rev_count-1 previous revisons over...
memmove(obj->header->revs_data + sizeof(la_storage_rev_t), obj->header->revs_data, sizeof(la_storage_rev_t) * (obj->header->rev_count - 1));
// Copy the previous revision in.
memcpy(obj->header->revs_data, &header.rev, sizeof(la_storage_rev_t));
#if DEBUG
printf("After moving data and revisions:\nOld revisions:\n");
la_hexdump(obj->header->revs_data, obj->header->rev_count * sizeof(la_storage_rev_t));
printf("data:\n");
la_hexdump(la_storage_object_get_data(obj), obj->data_length);
#endif
}
else
{
obj->header->doc_seq = 1;
obj->header->rev_count = 0;
}
db_seq_t seq;
store->seq->get(store->seq, txn, 1, &seq, 0);
obj->header->seq = seq;
db_value_write.size = (u_int32_t) la_storage_object_total_size(obj);
db_value_write.ulen = (u_int32_t) la_storage_object_total_size(obj);
db_value_write.data = obj->header;
db_value_write.flags = DB_DBT_USERMEM;
debug("putting { size: %u, ulen: %u, data: %s, flags: %x }\n", db_value_write.size,
db_value_write.ulen, db_value_write.data, db_value_write.flags);
result = store->db->put(store->db, txn, &db_key, &db_value_write, 0);
if (result != 0)
{
txn_abort(txn);
return LA_STORAGE_OBJECT_PUT_ERROR;
}
txn_commit(txn, DB_TXN_NOSYNC);
return LA_STORAGE_OBJECT_PUT_SUCCESS;
}
static la_storage_object_put_result bdb_la_storage_set_revs(la_storage_object_store *store, const char *key, la_storage_rev_t *revs, size_t revcount)
{
DB_TXN *txn;
DBT db_key;
DBT db_value;
int result;
la_storage_object object;
int shift;
revcount = la_min(revcount, LA_OBJECT_MAX_REVISION_COUNT);
memset(&db_key, 0, sizeof(DBT));
memset(&db_value, 0, sizeof(DBT));
db_key.data = key;
db_key.size = strlen(key);
db_key.ulen = strlen(key);
db_key.flags = DB_DBT_USERMEM;
db_value.data = NULL;
db_value.ulen = 0;
db_value.flags = DB_DBT_MALLOC;
if (txn_begin(store->env->env, NULL, &txn, DB_TXN_NOSYNC | DB_TXN_NOWAIT) != 0)
return LA_STORAGE_OBJECT_PUT_ERROR;
result = store->db->get(store->db, txn, &db_key, &db_value, DB_RMW);
if (result != 0)
{
txn_abort(txn);
if (result == DB_LOCK_NOTGRANTED)
return LA_STORAGE_OBJECT_PUT_CONFLICT;
return LA_STORAGE_OBJECT_PUT_ERROR;
}
object.header = (la_storage_object_header *) db_value.data;
object.data_length = db_value.size - sizeof(la_storage_object_header) - (object.header->rev_count * sizeof(la_storage_rev_t));
shift = revcount - object.header->rev_count;
if (shift > 0)
{
object.header = realloc(object.header, db_value.size + shift);
if (object.header == NULL)
{
free(object.header);
return LA_STORAGE_OBJECT_PUT_ERROR;
}
}
memmove(la_storage_object_get_data(&object) + shift, la_storage_object_get_data(&object), object.data_length);
memcpy(object.header->revs_data, revs, revcount * sizeof(la_storage_rev_t));
db_value.data = object.header;
db_value.size = db_value.size + shift;
db_value.ulen = db_value.size;
db_value.flags = DB_DBT_USERMEM;
result = store->db->put(store->db, txn, &db_key, &db_value, 0);
free(db_value.data);
if (result != 0)
{
txn_abort(txn);
return LA_STORAGE_OBJECT_PUT_ERROR;
}
txn_commit(txn, DB_TXN_NOSYNC);
return 0;
}
static int bdb_la_storage_object_store_delete(la_storage_object_store *store)
{
const char *dbname;
const char *seqdbname;
const char *home;
const char *parts[2];
DB_TXN *txn;
DB_ENV *env = store->env->env;
int ret;
if ((ret = store->db->get_dbname(store->db, &dbname, NULL)) != 0)
{
syslog(LOG_NOTICE, "could not get main db name: %d", ret);
return -1;
}
if ((ret = store->db->get_dbname(store->seq_db, &seqdbname, NULL)) != 0)
{
syslog(LOG_NOTICE, "could not get sequence db name: %d", ret);
return -1;
}
if ((ret = env->get_home(env, &home)) != 0)
{
syslog(LOG_NOTICE, "could not get db home %d", ret);
return -1;
}
parts[0] = home;
parts[1] = dbname;
dbname = string_join("/", parts, 2);
parts[1] = seqdbname;
seqdbname = string_join("/", parts, 2);
syslog(LOG_NOTICE, "deleting db %s and sequence db %s", dbname, seqdbname);
la_storage_close(store);
if ((ret = txn_begin(env, NULL, &txn, DB_TXN_NOWAIT | DB_TXN_WRITE_NOSYNC)) != 0)
{
syslog(LOG_NOTICE, "delete db begin transaction %d", ret);
free(dbname);
free(seqdbname);
return -1;
}
syslog(LOG_NOTICE, "env %p txn %p home %s name %s", env, txn, home, dbname);
if ((ret = env->dbremove(env, txn, dbname, NULL, 0)) != 0)
{
syslog(LOG_NOTICE, "deleting main DB: %d", ret);
txn_abort(txn);
return -1;
}
syslog(LOG_NOTICE, "env %p txn %p home %s name %s", env, txn, home, seqdbname);
if ((ret = env->dbremove(env, txn, seqdbname, NULL, 0)) != 0)
{
syslog(LOG_NOTICE, "deleting sequence DB: %d", ret);
txn_abort(txn);
return -1;
}
txn_commit(txn, DB_TXN_NOSYNC);
return 0;
}
static la_storage_open_result_t bdb_la_storage_open(la_storage_env *env, const char *path, int flags, la_storage_object_store **_store)
{
la_storage_object_store *store = (la_storage_object_store *) malloc(sizeof(struct la_storage_object_store));
DB_TXN *txn;
char *seqpath;
DBT seq_key;
char seq_name[4];
int dbflags;
int ret;
if (store == NULL)
return LA_STORAGE_OPEN_ERROR;
store->env = env;
if (txn_begin(env->env, NULL, &txn, DB_TXN_WRITE_NOSYNC) != 0)
{
free(store);
return LA_STORAGE_OPEN_ERROR;
}
if (db_create(&store->db, env->env, 0) != 0)
{
txn_abort(txn);
free(store);
return LA_STORAGE_OPEN_ERROR;
}
if (db_create(&store->seq_db, env->env, 0) != 0)
{
txn_abort(txn);
free(store);
return LA_STORAGE_OPEN_ERROR;
}
dbflags = 0;
if (flags & LA_STORAGE_OPEN_FLAG_CREATE)
dbflags = DB_CREATE;
if (flags & LA_STORAGE_OPEN_FLAG_EXCL)
dbflags |= DB_EXCL;
if ((ret = store->db->open(store->db, txn, path, NULL, DB_BTREE, dbflags | DB_MULTIVERSION | DB_THREAD, 0)) != 0)
{
txn_abort(txn);
free(store);
if (ret == EEXIST)
return LA_STORAGE_OPEN_EXISTS;
if (ret == ENOENT)
return LA_STORAGE_OPEN_NOT_FOUND;
return LA_STORAGE_OPEN_ERROR;
}
seqpath = string_append(path, ".seq");
if (seqpath == NULL)
{
store->db->close(store->db, 0);
txn_abort(txn);
free(store);
return LA_STORAGE_OPEN_ERROR;
}
if (store->seq_db->set_bt_compare(store->seq_db, compare_seq) != 0)
{
store->db->close(store->db, 0);
txn_abort(txn);
free(store);
return LA_STORAGE_OPEN_ERROR;
}
if (store->seq_db->open(store->seq_db, txn, seqpath, NULL, DB_BTREE, DB_CREATE | DB_THREAD, 0) != 0)
{
free(seqpath);
store->db->close(store->db, 0);
txn_abort(txn);
free(store);
return LA_STORAGE_OPEN_ERROR;
}
free(seqpath);
store->db->associate(store->db, txn, store->seq_db, seqindex, 0);
if (db_sequence_create(&store->seq, store->db, 0) != 0)
{
store->seq_db->close(store->seq_db, 0);
store->db->close(store->db, 0);
txn_abort(txn);
free(store);
return LA_STORAGE_OPEN_ERROR;
}
store->seq->initial_value(store->seq, 1);
seq_name[0] = '\0';
seq_name[1] = 'S';
seq_name[2] = 'E';
seq_name[3] = 'Q';
seq_key.data = seq_name;
seq_key.size = 4;
seq_key.ulen = 4;
seq_key.flags = DB_DBT_USERMEM;
if (store->seq->open(store->seq, txn, &seq_key, DB_CREATE | DB_THREAD) != 0)
{
store->seq_db->close(store->seq_db, 0);
store->db->close(store->db, 0);
txn_abort(txn);
free(store);
return LA_STORAGE_OPEN_ERROR;
}
txn_commit(txn, DB_TXN_NOSYNC);
*_store = store;
if ((flags & (LA_STORAGE_OPEN_FLAG_CREATE|LA_STORAGE_OPEN_FLAG_EXCL)) == (LA_STORAGE_OPEN_FLAG_CREATE|LA_STORAGE_OPEN_FLAG_EXCL))
return LA_STORAGE_OPEN_CREATED;
return LA_STORAGE_OPEN_OK;
}
