static void handle_mget(tcp_client* c, struct evbuffer* buffer) {
int i, n, ksize;
char k[MAX_TRANSACTION_SIZE];
val* values[64];
struct evbuffer* b = evbuffer_copy(buffer);
for (i = 0; i < 64; i++) values[i] = NULL;
transaction_set_get_cb(c->t, on_mget, c);
evbuffer_remove(b, &n, sizeof(int));
for (i = 0; i < n; i++) {
evbuffer_remove(b, &ksize, sizeof(int));
evbuffer_remove(b, k, ksize);
values[i] = execute_get(c->t, k, ksize);
if (values[i] == NULL)
goto cleanup;
}
// assert(transaction_read_only(c->t));
int rv = transaction_remote_count(c->t);
send_mget_result(c, rv, n, values);
//transaction_clear(c->t);
evbuffer_drain(buffer, evbuffer_get_length(buffer));
cleanup:
evbuffer_free(b);
for (i = 0; i < 64; i++)
if (values[i] != NULL)
val_free(values[i]);
}
static void handle_mget_put(tcp_client* c, struct evbuffer* buffer) {
int rv, i, n;
int ksize, vsize;
char k[MAX_TRANSACTION_SIZE];
char v[MAX_TRANSACTION_SIZE];
val* tmp;
struct evbuffer* b = evbuffer_copy(buffer);
transaction_set_get_cb(c->t, on_mget_put, c);
evbuffer_remove(b, &n, sizeof(int));
for (i = 0; i < n; i++) {
evbuffer_remove(b, &ksize, sizeof(int));
evbuffer_remove(b, k, ksize);
evbuffer_remove(b, &vsize, sizeof(int));
evbuffer_remove(b, v, vsize);
tmp = execute_get(c->t, k, ksize);
if (tmp == NULL) {
evbuffer_free(b);
return;
}
val_free(tmp);
execute_put(c->t, k, ksize, v, vsize);
}
evbuffer_free(b);
evbuffer_drain(buffer, evbuffer_get_length(buffer));
rv = transaction_commit(c->t, c->id, on_commit);
if (rv < 0) {
transaction_clear(c->t);
send_result(c->buffer_ev, -1);
return;
}
evtimer_add(&c->timeout_ev, &commit_timeout);
}
/**
* Get a random item that has expired or has low priority.
* Call 'proc' with all values ZERO or NULL if the datastore is empty.
*
* @param cls closure
* @param proc function to call the value (once only).
* @param proc_cls closure for proc
*/
static void
sqlite_plugin_get_expiration (void *cls, PluginDatumProcessor proc,
void *proc_cls)
{
struct Plugin *plugin = cls;
sqlite3_stmt *stmt;
struct GNUNET_TIME_Absolute now;
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"Getting random block based on expiration and priority order.\n");
now = GNUNET_TIME_absolute_get ();
stmt = plugin->selExpi;
if (SQLITE_OK != sqlite3_bind_int64 (stmt, 1, now.abs_value))
{
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_bind_XXXX");
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
execute_get (plugin, stmt, proc, proc_cls);
}
static void handle_get(tcp_client* c, struct evbuffer* buffer) {
int ksize;
char k[MAX_TRANSACTION_SIZE];
val* v;
struct evbuffer* b = evbuffer_copy(buffer);
evbuffer_remove(b, &ksize, sizeof(int));
evbuffer_remove(b, k, ksize);
transaction_set_get_cb(c->t, on_get, c);
v = execute_get(c->t, k, ksize);
if (v != NULL) {
evbuffer_drain(buffer, evbuffer_get_length(buffer));
send_get_result(c, v);
val_free(v);
}
evbuffer_free(b);
}
void *run_task(void *p)
{
thread_context_st *context= (thread_context_st *)p;
memcached_st *memc;
memc= context->memc;
pthread_mutex_lock(&sleeper_mutex);
while (master_wakeup)
{
pthread_cond_wait(&sleep_threshhold, &sleeper_mutex);
}
pthread_mutex_unlock(&sleeper_mutex);
/* Do Stuff */
switch (context->test)
{
case SET_TEST:
execute_set(memc, context->execute_pairs, context->execute_number);
break;
case GET_TEST:
execute_get(memc, context->initial_pairs, context->initial_number);
break;
}
memcached_free(memc);
if (context->execute_pairs)
pairs_free(context->execute_pairs);
free(context);
pthread_mutex_lock(&counter_mutex);
thread_counter--;
pthread_cond_signal(&count_threshhold);
pthread_mutex_unlock(&counter_mutex);
return NULL;
}
int32_t execute_command( dfu_device_t *device,
struct programmer_arguments *args )
{
device->type = args->device_type;
switch( args->command ) {
case com_erase:
return execute_erase( device, args );
case com_flash:
return execute_flash_normal( device, args );
case com_eflash:
return execute_flash_eeprom( device, args );
case com_user:
return execute_flash_user_page( device, args );
case com_reset:
return atmel_reset( device );
case com_start_app:
return atmel_start_app( device );
case com_get:
return execute_get( device, args );
case com_getfuse:
return execute_getfuse( device, args );
case com_dump:
return execute_dump_normal( device, args );
case com_edump:
return execute_dump_eeprom( device, args );
case com_udump:
return execute_dump_user_page( device, args );
case com_configure:
return execute_configure( device, args );
case com_setfuse:
return execute_setfuse( device, args );
default:
fprintf( stderr, "Not supported at this time.\n" );
}
return -1;
}
/**
* Select a subset of the items in the datastore and call
* the given processor for the item.
*
* @param cls our plugin context
* @param offset offset of the result (modulo num-results);
* specific ordering does not matter for the offset
* @param type entries of which type should be considered?
* Use 0 for any type.
* @param proc function to call on each matching value;
* will be called once with a NULL value at the end
* @param proc_cls closure for proc
*/
static void
sqlite_plugin_get_zero_anonymity (void *cls, uint64_t offset,
enum GNUNET_BLOCK_Type type,
PluginDatumProcessor proc, void *proc_cls)
{
struct Plugin *plugin = cls;
sqlite3_stmt *stmt;
GNUNET_assert (type != GNUNET_BLOCK_TYPE_ANY);
stmt = plugin->selZeroAnon;
if ((SQLITE_OK != sqlite3_bind_int (stmt, 1, type)) ||
(SQLITE_OK != sqlite3_bind_int64 (stmt, 2, offset)))
{
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_bind_XXXX");
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
execute_get (plugin, stmt, proc, proc_cls);
}
/**
* Get a random item for replication. Returns a single random item
* from those with the highest replication counters. The item's
* replication counter is decremented by one IF it was positive before.
* Call 'proc' with all values ZERO or NULL if the datastore is empty.
*
* @param cls closure
* @param proc function to call the value (once only).
* @param proc_cls closure for proc
*/
static void
sqlite_plugin_get_replication (void *cls, PluginDatumProcessor proc,
void *proc_cls)
{
struct Plugin *plugin = cls;
struct ReplCtx rc;
uint64_t rvalue;
uint32_t repl;
sqlite3_stmt *stmt;
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"Getting random block based on replication order.\n");
rc.have_uid = GNUNET_NO;
rc.proc = proc;
rc.proc_cls = proc_cls;
stmt = plugin->maxRepl;
if (SQLITE_ROW != sqlite3_step (stmt))
{
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
/* DB empty */
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
repl = sqlite3_column_int (stmt, 0);
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
stmt = plugin->selRepl;
rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
if (SQLITE_OK != sqlite3_bind_int64 (stmt, 1, rvalue))
{
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_bind_XXXX");
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
if (SQLITE_OK != sqlite3_bind_int (stmt, 2, repl))
{
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_bind_XXXX");
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
execute_get (plugin, stmt, &repl_proc, &rc);
if (GNUNET_YES == rc.have_uid)
{
if (SQLITE_OK != sqlite3_bind_int64 (plugin->updRepl, 1, rc.uid))
{
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_bind_XXXX");
if (SQLITE_OK != sqlite3_reset (plugin->updRepl))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
return;
}
if (SQLITE_DONE != sqlite3_step (plugin->updRepl))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_step");
if (SQLITE_OK != sqlite3_reset (plugin->updRepl))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
}
}
/**
* Get results for a particular key in the datastore.
*
* @param cls closure
* @param offset offset (mod count).
* @param key key to match, never NULL
* @param vhash hash of the value, maybe NULL (to
* match all values that have the right key).
* Note that for DBlocks there is no difference
* betwen key and vhash, but for other blocks
* there may be!
* @param type entries of which type are relevant?
* Use 0 for any type.
* @param proc function to call on each matching value;
* will be called once with a NULL value at the end
* @param proc_cls closure for proc
*/
static void
sqlite_plugin_get_key (void *cls, uint64_t offset, const GNUNET_HashCode * key,
const GNUNET_HashCode * vhash,
enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc,
void *proc_cls)
{
struct Plugin *plugin = cls;
int ret;
int total;
int limit_off;
unsigned int sqoff;
sqlite3_stmt *stmt;
char scratch[256];
GNUNET_assert (proc != NULL);
GNUNET_assert (key != NULL);
GNUNET_snprintf (scratch, sizeof (scratch),
"SELECT count(*) FROM gn090 WHERE hash=?%s%s",
vhash == NULL ? "" : " AND vhash=?",
type == 0 ? "" : " AND type=?");
if (sq_prepare (plugin->dbh, scratch, &stmt) != SQLITE_OK)
{
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite_prepare");
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
sqoff = 1;
ret =
sqlite3_bind_blob (stmt, sqoff++, key, sizeof (GNUNET_HashCode),
SQLITE_TRANSIENT);
if ((vhash != NULL) && (ret == SQLITE_OK))
ret =
sqlite3_bind_blob (stmt, sqoff++, vhash, sizeof (GNUNET_HashCode),
SQLITE_TRANSIENT);
if ((type != 0) && (ret == SQLITE_OK))
ret = sqlite3_bind_int (stmt, sqoff++, type);
if (SQLITE_OK != ret)
{
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite_bind");
sqlite3_finalize (stmt);
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
ret = sqlite3_step (stmt);
if (ret != SQLITE_ROW)
{
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite_step");
sqlite3_finalize (stmt);
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
total = sqlite3_column_int (stmt, 0);
sqlite3_finalize (stmt);
if (0 == total)
{
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
limit_off = (int) (offset % total);
if (limit_off < 0)
limit_off += total;
GNUNET_snprintf (scratch, sizeof (scratch),
"SELECT type, prio, anonLevel, expire, hash, value, _ROWID_ "
"FROM gn090 WHERE hash=?%s%s "
"ORDER BY _ROWID_ ASC LIMIT 1 OFFSET ?",
vhash == NULL ? "" : " AND vhash=?",
type == 0 ? "" : " AND type=?");
if (sq_prepare (plugin->dbh, scratch, &stmt) != SQLITE_OK)
{
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite_prepare");
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
sqoff = 1;
ret =
sqlite3_bind_blob (stmt, sqoff++, key, sizeof (GNUNET_HashCode),
SQLITE_TRANSIENT);
if ((vhash != NULL) && (ret == SQLITE_OK))
ret =
sqlite3_bind_blob (stmt, sqoff++, vhash, sizeof (GNUNET_HashCode),
SQLITE_TRANSIENT);
if ((type != 0) && (ret == SQLITE_OK))
ret = sqlite3_bind_int (stmt, sqoff++, type);
if (ret == SQLITE_OK)
ret = sqlite3_bind_int64 (stmt, sqoff++, limit_off);
if (ret != SQLITE_OK)
{
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite_bind");
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
return;
}
execute_get (plugin, stmt, proc, proc_cls);
sqlite3_finalize (stmt);
}
