int sick_transaction(sick_t *s, uint8_t *request, uint8_t responsetype, uint8_t *response, int timeoutms)
{
pthread_mutex_lock(&s->writelock);
int res = 0;
int trials = 0;
int requestlen;
retry:
requestlen = packet_length(request);
if (s->log_packets_file) {
for (int i = 0; i < requestlen; i++) {
if (i%16 == 0)
fprintf(s->log_packets_file, "TX %04x : ", i);
fprintf(s->log_packets_file, "%02x ", request[i]);
if ((i%16) == 15 || i+1 == requestlen)
fprintf(s->log_packets_file, "\n");
}
}
// send the request
res = write_fully(s->serialfd, request, requestlen);
if (res < 0) {
printf("write failed\n");
goto exit;
}
// wait for response
s->writereqid = responsetype;
s->writedata = response;
s->writevalid = 0;
struct timespec ts;
timespec_now(&ts);
timespec_addms(&ts, timeoutms);
pthread_cond_timedwait(&s->writecond, &s->writelock, &ts);
if (!s->writevalid) {
trials++;
if (trials > SICK_OP_MAX_RETRIES) {
res = -2;
goto exit;
}
goto retry;
}
exit:
s->writedata = NULL;
s->writereqid = 0;
pthread_mutex_unlock(&s->writelock);
return res;
}
gf_timer_t *
gf_timer_call_after (glusterfs_ctx_t *ctx,
struct timespec delta,
gf_timer_cbk_t callbk,
void *data)
{
gf_timer_registry_t *reg = NULL;
gf_timer_t *event = NULL;
gf_timer_t *trav = NULL;
uint64_t at = 0;
if (ctx == NULL)
{
gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
LG_MSG_INVALID_ARG, "invalid argument");
return NULL;
}
reg = gf_timer_registry_init (ctx);
if (!reg) {
gf_msg_callingfn ("timer", GF_LOG_ERROR, 0,
LG_MSG_TIMER_REGISTER_ERROR, "!reg");
return NULL;
}
event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t);
if (!event) {
return NULL;
}
timespec_now (&event->at);
timespec_adjust_delta (&event->at, delta);
at = TS (event->at);
event->callbk = callbk;
event->data = data;
event->xl = THIS;
LOCK (®->lock);
{
trav = reg->active.prev;
while (trav != ®->active) {
if (TS (trav->at) < at)
break;
trav = trav->prev;
}
event->prev = trav;
event->next = event->prev->next;
event->prev->next = event;
event->next->prev = event;
}
UNLOCK (®->lock);
return event;
}
// 插入一个事件到定时器链表中
gf_timer_t *
gf_timer_call_after (glusterfs_ctx_t *ctx,
struct timespec delta,
gf_timer_cbk_t callbk,
void *data)
{
gf_timer_registry_t *reg = NULL;
gf_timer_t *event = NULL;
gf_timer_t *trav = NULL;
uint64_t at = 0;
if (ctx == NULL)
{
gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument");
return NULL;
}
reg = gf_timer_registry_init (ctx);
if (!reg) {
gf_log_callingfn ("timer", GF_LOG_ERROR, "!reg");
return NULL;
}
event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t);
if (!event) {
return NULL;
}
timespec_now (&event->at);
timespec_adjust_delta (&event->at, delta);
at = TS (event->at);
event->callbk = callbk;
event->data = data;
event->xl = THIS;
pthread_mutex_lock (®->lock);
{
//列表最后一个
trav = reg->active.prev;
//找最后一个时间比我早的(链表是按时间排序的)
while (trav != ®->active) {
if (TS (trav->at) < at)
break;
trav = trav->prev;
}
event->prev = trav;
event->next = event->prev->next;
event->prev->next = event;
event->next->prev = event;
}
pthread_mutex_unlock (®->lock);
return event;
}
int orc_transaction_once(orc_t *orc, uint8_t *request, uint8_t *response)
{
while (orc->fd <= 0) {
usleep(1000);
}
// grab an id
int id = alloc_transaction_id(orc);
// fix up the packet.
request[0] = PACKET_MARKER;
request[PACKET_ID] = id;
packet_fill_checksum(request);
// fill out the transaction record
transaction_t *t = &orc->transactions[id];
pthread_mutex_lock(&t->mutex);
t->response = response;
// send the packet
pthread_mutex_lock(&orc->writeLock);
write_fully(orc->fd, request, request[PACKET_DATALEN] + 4);
pthread_mutex_unlock(&orc->writeLock);
// compute our timeout time
struct timespec ts;
timespec_now(&ts);
timespec_addms(&ts, 100);
// wait!
int res = pthread_cond_timedwait(&t->cond, &t->mutex, &ts);
t->response = garbage;
// cleanup
pthread_mutex_unlock(&t->mutex);
free_transaction_id(orc, id);
if (res == ETIMEDOUT) {
LOG_VERBOSE("Timeout packet, id = %02X", id);
return -1;
}
return 0;
}
static void
test_invoice_post ( Fixture *fixture, gconstpointer pData )
{
GncInvoice *invoice = gncInvoiceCreate(fixture->book);
Timespec ts1 = timespec_now(), ts2 = ts1;
g_assert(invoice);
g_assert(!gncInvoiceGetIsCreditNote(invoice));
g_assert(gncInvoiceGetActive(invoice));
g_assert(gncInvoiceGetPostedAcc(invoice) == NULL);
gncInvoiceSetCurrency(invoice, fixture->commodity);
gncInvoiceSetOwner(invoice, &fixture->owner);
g_test_message( "Will now post the invoice" );
g_assert(!gncInvoiceIsPosted(invoice));
gncInvoicePostToAccount(invoice, fixture->account, &ts1, &ts2, "memo", TRUE);
g_assert(gncInvoiceIsPosted(invoice));
gncInvoiceUnpost(invoice, TRUE);
g_assert(!gncInvoiceIsPosted(invoice));
}
void
test_qofsession_aqb_kvp( void )
{
/* load the accounts from the users datafile */
/* but first, check to make sure we've got a session going. */
QofBackendError io_err;
char *file1 = get_filepath("file-book.gnucash");
char *file2 = get_filepath("file-book-hbcislot.gnucash");
if (1)
{
// A file with no content at all, but a valid XML file
QofSession *new_session = qof_session_new ();
char *newfile = g_strdup_printf("file://%s", file1);
qof_session_begin (new_session, newfile, TRUE, FALSE, FALSE);
io_err = qof_session_get_error (new_session);
//printf("io_err1 = %d\n", io_err);
g_assert(io_err != ERR_BACKEND_NO_HANDLER); // Do not have no handler
g_assert(io_err != ERR_BACKEND_NO_SUCH_DB); // DB must exist
g_assert(io_err != ERR_BACKEND_LOCKED);
g_assert(io_err == 0);
qof_session_load (new_session, NULL);
io_err = qof_session_get_error (new_session);
//printf("io_err2 = %d\n", io_err);
g_assert(io_err == 0);
g_free(newfile);
g_free(file1);
gnc_hook_run(HOOK_BOOK_CLOSED, new_session);
//qof_session_destroy(new_session); // tries to delete the LCK file but it wasn't created in the first place
}
if (1)
{
// A file with no content except for the book_template_list kvp
// slot
QofSession *new_session = qof_session_new ();
char *newfile = g_strdup_printf("file://%s", file2);
qof_session_begin (new_session, newfile, TRUE, FALSE, FALSE);
io_err = qof_session_get_error (new_session);
//printf("io_err1 = %d\n", io_err);
g_assert(io_err != ERR_BACKEND_NO_HANDLER); // Do not have no handler
g_assert(io_err != ERR_BACKEND_NO_SUCH_DB); // DB must exist
g_assert(io_err != ERR_BACKEND_LOCKED);
g_assert(io_err == 0);
qof_session_load (new_session, NULL);
io_err = qof_session_get_error (new_session);
//printf("io_err2 = %d\n", io_err);
g_assert(io_err == 0);
{
GList *templ_list;
GncABTransTempl *templ;
QofBook *book = qof_session_get_book(new_session);
const char* ORIGINAL_NAME = "Some Name";
const char* CHANGED_NAME = "Some Changed Name";
templ_list = gnc_ab_trans_templ_list_new_from_book (book);
g_assert_cmpint(g_list_length(templ_list), ==, 1);
templ = templ_list->data;
//Raise the edit level so that we can check that it's marked dirty.
qof_instance_increase_editlevel(QOF_INSTANCE(book));
g_assert_cmpstr(gnc_ab_trans_templ_get_name(templ), ==, ORIGINAL_NAME); // ok, name from file is here
// Now we change the name into something else and verify it can be saved
gnc_ab_trans_templ_set_name(templ, CHANGED_NAME);
{
g_assert(!qof_instance_get_dirty(QOF_INSTANCE(book))); // not yet dirty
// Here we save the changed kvp
gnc_ab_set_book_template_list(book, templ_list);
g_assert(qof_instance_get_dirty(QOF_INSTANCE(book))); // yup, now dirty
gnc_ab_trans_templ_list_free(templ_list);
}
{
templ_list = gnc_ab_trans_templ_list_new_from_book (book);
g_assert_cmpint(g_list_length(templ_list), ==, 1);
templ = templ_list->data;
g_assert_cmpstr(gnc_ab_trans_templ_get_name(templ), ==, CHANGED_NAME); // ok, the change has been saved!
gnc_ab_trans_templ_list_free(templ_list);
}
}
{
// Check the kvp slots of a aqbanking-enabled account
QofBook *book = qof_session_get_book(new_session);
Account* account = gnc_book_get_root_account(book);
GDate retrieved_date, original_date;
gchar buff[MAX_DATE_LENGTH];
g_assert(account);
// The interesting test case here: Can we read the correct date
// from the xml file?
if (1)
{
Timespec retrieved_ts = gnc_ab_get_account_trans_retrieval(account);
g_test_message("retrieved_ts=%s\n", gnc_print_date(retrieved_ts));
//printf("Time=%s\n", gnc_print_date(retrieved_ts));
retrieved_date = timespec_to_gdate(retrieved_ts);
g_date_set_dmy(&original_date, 29, 8, 2014);
g_assert_cmpint(g_date_compare(&retrieved_date, &original_date), ==, 0);
}
// A lower-level test here: Can we write and read again the
// trans_retrieval date? This wouldn't need this particular
// Account, just a general Account object.
if (0)
{
Timespec original_ts = timespec_now(), retrieved_ts;
// Check whether the "ab-trans-retrieval" property of Account
// is written and read again correctly.
gnc_ab_set_account_trans_retrieval(account, original_ts);
retrieved_ts = gnc_ab_get_account_trans_retrieval(account);
// printf("original_ts=%s = %d retrieved_ts=%s = %d\n",
// gnc_print_date(original_ts), original_ts.tv_sec,
// gnc_print_date(retrieved_ts), retrieved_ts.tv_sec);
original_date = timespec_to_gdate(original_ts);
retrieved_date = timespec_to_gdate(retrieved_ts);
qof_print_gdate (buff, sizeof (buff), &original_date);
//printf("original_date=%s\n", buff);
qof_print_gdate (buff, sizeof (buff), &retrieved_date);
//printf("retrieved_date=%s\n", buff);
// Is the retrieved date identical to the one written
g_assert_cmpint(g_date_compare(&retrieved_date, &original_date), ==, 0);
}
gf_timer_t *
gf_timer_call_after (glusterfs_ctx_t *ctx,
struct timespec delta,
gf_timer_cbk_t callbk,
void *data)
{
gf_timer_registry_t *reg = NULL;
gf_timer_t *event = NULL;
gf_timer_t *trav = NULL;
uint64_t at = 0;
if (ctx == NULL)
{
gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
LG_MSG_INVALID_ARG, "invalid argument");
return NULL;
}
/* ctx and its fields are not accessed inside mutex!?
* TODO: Even with this there is a possiblity of race
* when cleanup_started is set after checking for it
*/
if (ctx->cleanup_started) {
gf_msg_callingfn ("timer", GF_LOG_INFO, 0,
LG_MSG_CTX_CLEANUP_STARTED, "ctx cleanup "
"started");
return NULL;
}
reg = gf_timer_registry_init (ctx);
if (!reg) {
gf_msg_callingfn ("timer", GF_LOG_ERROR, 0,
LG_MSG_TIMER_REGISTER_ERROR, "!reg");
return NULL;
}
event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t);
if (!event) {
return NULL;
}
timespec_now (&event->at);
timespec_adjust_delta (&event->at, delta);
at = TS (event->at);
event->callbk = callbk;
event->data = data;
event->xl = THIS;
pthread_mutex_lock (®->lock);
{
trav = reg->active.prev;
while (trav != ®->active) {
if (TS (trav->at) < at)
break;
trav = trav->prev;
}
event->prev = trav;
event->next = event->prev->next;
event->prev->next = event;
event->next->prev = event;
}
pthread_mutex_unlock (®->lock);
return event;
}
void *
gf_timer_proc (void *ctx)
{
gf_timer_registry_t *reg = NULL;
const struct timespec sleepts = {.tv_sec = 1, .tv_nsec = 0, };
gf_timer_t *event = NULL;
xlator_t *old_THIS = NULL;
if (ctx == NULL)
{
gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
LG_MSG_INVALID_ARG, "invalid argument");
return NULL;
}
reg = gf_timer_registry_init (ctx);
if (!reg) {
gf_msg ("timer", GF_LOG_ERROR, 0, LG_MSG_INIT_TIMER_FAILED,
"!reg");
return NULL;
}
while (!reg->fin) {
uint64_t now;
struct timespec now_ts;
timespec_now (&now_ts);
now = TS (now_ts);
while (1) {
uint64_t at;
char need_cbk = 0;
pthread_mutex_lock (®->lock);
{
event = reg->active.next;
at = TS (event->at);
if (event != ®->active && now >= at) {
need_cbk = 1;
event->next->prev = event->prev;
event->prev->next = event->next;
event->fired = _gf_true;
}
}
pthread_mutex_unlock (®->lock);
if (need_cbk) {
old_THIS = NULL;
if (event->xl) {
old_THIS = THIS;
THIS = event->xl;
}
event->callbk (event->data);
GF_FREE (event);
if (old_THIS) {
THIS = old_THIS;
}
} else {
break;
}
}
nanosleep (&sleepts, NULL);
}
pthread_mutex_lock (®->lock);
{
/* Do not call gf_timer_call_cancel(),
* it will lead to deadlock
*/
while (reg->active.next != ®->active) {
event = reg->active.next;
/* cannot call list_del as the event doesnt have
* list_head*/
__delete_entry (event);
}
}
pthread_mutex_unlock (®->lock);
pthread_mutex_destroy (®->lock);
GF_FREE (((glusterfs_ctx_t *)ctx)->timer);
return NULL;
}
gf_timer_registry_t *
gf_timer_registry_init (glusterfs_ctx_t *ctx)
{
if (ctx == NULL) {
gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
LG_MSG_INVALID_ARG, "invalid argument");
return NULL;
}
if (!ctx->timer) {
gf_timer_registry_t *reg = NULL;
reg = GF_CALLOC (1, sizeof (*reg),
gf_common_mt_gf_timer_registry_t);
if (!reg)
goto out;
pthread_mutex_init (®->lock, NULL);
reg->active.next = ®->active;
reg->active.prev = ®->active;
ctx->timer = reg;
gf_thread_create (®->th, NULL, gf_timer_proc, ctx);
}
out:
return ctx->timer;
}
void
gf_timer_registry_destroy (glusterfs_ctx_t *ctx)
{
pthread_t thr_id;
gf_timer_registry_t *reg = NULL;
if (ctx == NULL)
return;
reg = ctx->timer;
thr_id = reg->th;
reg->fin = 1;
pthread_join (thr_id, NULL);
}
static void *
gf_timer_proc (void *data)
{
gf_timer_registry_t *reg = data;
const struct timespec sleepts = {.tv_sec = 1, .tv_nsec = 0, };
gf_timer_t *event = NULL;
xlator_t *old_THIS = NULL;
while (!reg->fin) {
uint64_t now;
struct timespec now_ts;
timespec_now (&now_ts);
now = TS (now_ts);
while (1) {
uint64_t at;
char need_cbk = 0;
LOCK (®->lock);
{
event = reg->active.next;
at = TS (event->at);
if (event != ®->active && now >= at) {
need_cbk = 1;
event->next->prev = event->prev;
event->prev->next = event->next;
event->fired = _gf_true;
}
}
UNLOCK (®->lock);
if (need_cbk) {
old_THIS = NULL;
if (event->xl) {
old_THIS = THIS;
THIS = event->xl;
}
event->callbk (event->data);
GF_FREE (event);
if (old_THIS) {
THIS = old_THIS;
}
} else {
break;
}
}
nanosleep (&sleepts, NULL);
}
LOCK (®->lock);
{
/* Do not call gf_timer_call_cancel(),
* it will lead to deadlock
*/
while (reg->active.next != ®->active) {
event = reg->active.next;
/* cannot call list_del as the event doesnt have
* list_head*/
__delete_entry (event);
}
}
UNLOCK (®->lock);
LOCK_DESTROY (®->lock);
return NULL;
}
static gf_timer_registry_t *
gf_timer_registry_init (glusterfs_ctx_t *ctx)
{
gf_timer_registry_t *reg = NULL;
if (ctx == NULL) {
gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
LG_MSG_INVALID_ARG, "invalid argument");
return NULL;
}
if (ctx->cleanup_started) {
gf_msg_callingfn ("timer", GF_LOG_INFO, 0,
LG_MSG_CTX_CLEANUP_STARTED,
"ctx cleanup started");
return NULL;
}
LOCK (&ctx->lock);
{
reg = ctx->timer;
}
UNLOCK (&ctx->lock);
if (!reg) {
reg = GF_CALLOC (1, sizeof (*reg),
gf_common_mt_gf_timer_registry_t);
if (!reg)
return NULL;
LOCK_INIT (®->lock);
reg->active.next = ®->active;
reg->active.prev = ®->active;
LOCK (&ctx->lock);
{
ctx->timer = reg;
}
UNLOCK (&ctx->lock);
gf_thread_create (®->th, NULL, gf_timer_proc, reg);
}
return reg;
}
//计时器线程
void *
gf_timer_proc (void *ctx)
{
gf_timer_registry_t *reg = NULL;
const struct timespec sleepts = {.tv_sec = 1, .tv_nsec = 0, };
if (ctx == NULL)
{
gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument");
return NULL;
}
reg = gf_timer_registry_init (ctx);
if (!reg) {
gf_log ("timer", GF_LOG_ERROR, "!reg");
return NULL;
}
while (!reg->fin) {
uint64_t now;
struct timespec now_ts;
gf_timer_t *event = NULL;
timespec_now (&now_ts);
//现在的时间
now = TS (now_ts);
while (1) {
uint64_t at;
char need_cbk = 0;
pthread_mutex_lock (®->lock);
{
event = reg->active.next;
at = TS (event->at);
if (event != ®->active && now >= at) {
need_cbk = 1;
gf_timer_call_stale (reg, event);
}
}
pthread_mutex_unlock (®->lock);
if (event->xl)
THIS = event->xl;
if (need_cbk)
event->callbk (event->data);
else
//跳出while(1)
break;
}
// 睡1秒
nanosleep (&sleepts, NULL);
}
pthread_mutex_lock (®->lock);
{
while (reg->active.next != ®->active) {
gf_timer_call_cancel (ctx, reg->active.next);
}
while (reg->stale.next != ®->stale) {
gf_timer_call_cancel (ctx, reg->stale.next);
}
}
pthread_mutex_unlock (®->lock);
pthread_mutex_destroy (®->lock);
GF_FREE (((glusterfs_ctx_t *)ctx)->timer);
return NULL;
}
// 计时器注册初始化
gf_timer_registry_t *
gf_timer_registry_init (glusterfs_ctx_t *ctx)
{
if (ctx == NULL) {
gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument");
return NULL;
}
// 还没初始化过的
if (!ctx->timer) {
gf_timer_registry_t *reg = NULL;
reg = GF_CALLOC (1, sizeof (*reg),
gf_common_mt_gf_timer_registry_t);
if (!reg)
goto out;
pthread_mutex_init (®->lock, NULL);
reg->active.next = ®->active;
reg->active.prev = ®->active;
reg->stale.next = ®->stale;
reg->stale.prev = ®->stale;
ctx->timer = reg;
gf_thread_create (®->th, NULL, gf_timer_proc, ctx);
}
out:
return ctx->timer;
}
