{
const BlueSkyStoreImplementation *impl;
- impl = g_hash_table_lookup(store_implementations, type);
- if (impl == NULL)
+ gchar *scheme, *path;
+ scheme = g_strdup(type);
+ path = strchr(scheme, ':');
+ if (path != NULL) {
+ *path = '\0';
+ path++;
+ }
+
+ impl = g_hash_table_lookup(store_implementations, scheme);
+ if (impl == NULL) {
+ g_free(scheme);
return NULL;
+ }
- gpointer handle = impl->create();
- if (handle == NULL)
+ gpointer handle = impl->create(path);
+ if (handle == NULL) {
+ g_free(scheme);
return NULL;
+ }
BlueSkyStore *store = g_new(BlueSkyStore, 1);
store->impl = impl;
store->lock = g_mutex_new();
store->cond_idle = g_cond_new();
store->pending = 0;
+ g_free(scheme);
return store;
}
return async;
}
+gpointer bluesky_store_async_get_handle(BlueSkyStoreAsync *async)
+{
+ return async->store->handle;
+}
+
void bluesky_store_async_ref(BlueSkyStoreAsync *async)
{
if (async == NULL)
g_free(async->key);
bluesky_string_unref(async->data);
g_free(async);
- g_print("Freed async\n");
}
}
{
g_return_if_fail(async->status != ASYNC_COMPLETE);
+ bluesky_time_hires elapsed = bluesky_now_hires() - async->start_time;
+
g_mutex_lock(async->store->lock);
async->store->pending--;
if (async->store->pending == 0)
async->notifiers = nl->next;
g_thread_pool_push(notifier_thread_pool, nl, NULL);
}
-}
-static void test_notifier(gpointer a, gpointer u)
-{
- g_print("Notifier called!\n");
+ g_log("bluesky/store", G_LOG_LEVEL_DEBUG,
+ "[%p] complete: elapsed = %"PRIi64" ns",
+ async, elapsed);
}
void bluesky_store_async_submit(BlueSkyStoreAsync *async)
{
BlueSkyStore *store = async->store;
+ async->start_time = bluesky_now_hires();
+
+ g_log("bluesky/store", G_LOG_LEVEL_DEBUG, "[%p] submit: %s %s",
+ async,
+ async->op == STORE_OP_GET ? "GET"
+ : async->op == STORE_OP_PUT ? "PUT"
+ : async->op == STORE_OP_DELETE ? "DELETE"
+ : async->op == STORE_OP_BARRIER ? "BARRIER" : "???",
+ async->key);
+
/* Barriers are handled specially, and not handed down the storage
* implementation layer. */
- if (async->op = STORE_OP_BARRIER) {
+ if (async->op == STORE_OP_BARRIER) {
async->status = ASYNC_RUNNING;
if (GPOINTER_TO_INT(async->store_private) == 0)
bluesky_store_async_mark_complete(async);
async->store->pending++;
g_mutex_unlock(async->store->lock);
- bluesky_store_async_add_notifier(async, test_notifier, NULL);
store->impl->submit(store->handle, async);
if (bluesky_options.synchronous_stores)
static void op_complete(gpointer a, gpointer b)
{
- BlueSkyStoreAsync *async = (BlueSkyStoreAsync *)a;
BlueSkyStoreAsync *barrier = (BlueSkyStoreAsync *)b;
+ bluesky_store_async_ref(barrier);
g_mutex_lock(barrier->lock);
barrier->store_private
= GINT_TO_POINTER(GPOINTER_TO_INT(barrier->store_private) - 1);
bluesky_store_async_mark_complete(barrier);
}
g_mutex_unlock(barrier->lock);
+ bluesky_store_async_unref(barrier);
}
/* Add the given operation to the barrier. The barrier will not complete until
g_return_if_fail(barrier->op == STORE_OP_BARRIER);
barrier->store_private
= GINT_TO_POINTER(GPOINTER_TO_INT(barrier->store_private) + 1);
- bluesky_store_async_add_notifier(async, op_complete, NULL);
+ bluesky_store_async_add_notifier(async, op_complete, barrier);
}
static void notifier_task(gpointer n, gpointer s)
bluesky_store_async_unref(async);
}
-#if 0
/* Simple in-memory data store for test purposes. */
typedef struct {
GMutex *lock;
GHashTable *store;
} MemStore;
-static gpointer memstore_create()
+static gpointer memstore_create(const gchar *path)
{
MemStore *store = g_new(MemStore, 1);
store->lock = g_mutex_new();
g_hash_table_insert(store->store, g_strdup(key), val);
}
+static void memstore_submit(gpointer s, BlueSkyStoreAsync *async)
+{
+ g_return_if_fail(async->status == ASYNC_NEW);
+ g_return_if_fail(async->op != STORE_OP_NONE);
+
+ switch (async->op) {
+ case STORE_OP_GET:
+ async->data = memstore_get(s, async->key);
+ break;
+
+ case STORE_OP_PUT:
+ memstore_put(s, async->key, async->data);
+ break;
+
+ default:
+ g_warning("Uknown operation type for MemStore: %d\n", async->op);
+ return;
+ }
+
+ bluesky_store_async_mark_complete(async);
+}
+
+static void memstore_cleanup(gpointer store, BlueSkyStoreAsync *async)
+{
+}
+
static BlueSkyStoreImplementation memstore_impl = {
.create = memstore_create,
.destroy = memstore_destroy,
- .get = memstore_get,
- .put = memstore_put,
+ .submit = memstore_submit,
+ .cleanup = memstore_cleanup,
};
/* Store implementation which writes data as files to disk. */
-static gpointer filestore_create()
+static gpointer filestore_create(const gchar *path)
{
return GINT_TO_POINTER(1);
}
{
}
-static BlueSkyRCStr *filestore_get(gpointer s, const gchar *key)
+static BlueSkyRCStr *filestore_get(const gchar *key)
{
gchar *contents = NULL;
gsize length;
return bluesky_string_new(contents, length);
}
-static void filestore_put(gpointer s, const gchar *key, BlueSkyRCStr *val)
+static void filestore_put(const gchar *key, BlueSkyRCStr *val)
{
g_file_set_contents(key, val->data, val->len, NULL);
}
+static void filestore_submit(gpointer s, BlueSkyStoreAsync *async)
+{
+ g_return_if_fail(async->status == ASYNC_NEW);
+ g_return_if_fail(async->op != STORE_OP_NONE);
+
+ switch (async->op) {
+ case STORE_OP_GET:
+ async->data = filestore_get(async->key);
+ async->result = 0;
+ break;
+
+ case STORE_OP_PUT:
+ filestore_put(async->key, async->data);
+ async->result = 0;
+ break;
+
+ default:
+ g_warning("Uknown operation type for FileStore: %d\n", async->op);
+ return;
+ }
+
+ bluesky_store_async_mark_complete(async);
+}
+
+static void filestore_cleanup(gpointer store, BlueSkyStoreAsync *async)
+{
+}
+
static BlueSkyStoreImplementation filestore_impl = {
.create = filestore_create,
.destroy = filestore_destroy,
- .get = filestore_get,
- .put = filestore_put,
+ .submit = filestore_submit,
+ .cleanup = filestore_cleanup,
};
-#endif
void bluesky_store_init()
{
store_implementations = g_hash_table_new(g_str_hash, g_str_equal);
notifier_thread_pool = g_thread_pool_new(notifier_task, NULL, -1, FALSE,
NULL);
- //bluesky_store_register(&memstore_impl, "mem");
- //bluesky_store_register(&filestore_impl, "file");
+ bluesky_store_register(&memstore_impl, "mem");
+ bluesky_store_register(&filestore_impl, "file");
}