int PNode_metaAt_put_(PNode *self, Datum *key, Datum *value)
{
Datum *slot = PNode_metaSlotFor_(self, key);
if(!PDB_at_put_(self->pdb, Datum_data(slot), (int)Datum_size(slot), Datum_data(value), (int)Datum_size(value)))
{
return -1;
}
return 0;
}
int File_create(File *self)
{
FILE *fp = fopen(Datum_data(self->path), "w");
if(!fp)
{
Log_Printf_("File: unable to create file '%s'\n", Datum_data(self->path));
return -1;
}
fclose(fp);
return 0;
}
void VertexServer_requestHandler(void *arg)
{
VertexServer *self = (VertexServer *)arg;
VertexServer_setupYajl(self);
HttpResponse_setContentType_(self->httpResponse, "application/json;charset=utf-8");
int result = VertexServer_process(self);
Datum *content = HttpResponse_content(self->httpResponse);
if (result == 0)
{
if (!Datum_size(content))
{
Datum_setCString_(content, "null");
}
Datum_nullTerminate(content);
}
else
{
if (!Datum_size(content))
{
Datum_setCString_(content, "\"unknown error\"");
}
Datum_nullTerminate(content);
yajl_gen_clear(self->yajl);
yajl_gen_datum(self->yajl, content);
Datum_setYajl_(content, self->yajl);
if(self->debug) { Log_Printf_("REQUEST ERROR: %s\n", Datum_data(content)); }
}
}
Datum *Datum_asUriEncoded(Datum *self)
{
char *k = evhttp_encode_uri(Datum_data(self));
Datum *d = Datum_poolNewWithCString_(k);
free(k);
return d;
}
int PNode_atCat_(PNode *self, Datum *k, Datum *v)
{
int hasKey = PNode_at_(self, k) != NULL;
if (!PDB_at_cat_(self->pdb,
Datum_data(self->keyPath), (int)Datum_size(self->keyPath),
Datum_data(v), (int)Datum_size(v)))
{
printf("PNode_atCat_ error\n");
return -1;
}
if (!hasKey) return PNode_incrementSize(self);
return 0;
}
int VertexServer_api_log(VertexServer *self)
{
Log_Printf("LOG -----------------------------\n\n");
printf("%s\n", Datum_data(HttpRequest_postData(self->httpRequest)));
printf("\n---------------------------------\n");
return 0;
}
void PNode_show(PNode *self)
{
Datum *k;
printf("PNode pid %s\n",
Datum_data(PNode_pid(self)));
PNode_first(self);
while ((k = PNode_key(self)))
{
printf(" '%s' '%s'\n",
Datum_data(PNode_key(self)),
Datum_data(PNode_value(self)));
PNode_next(self);
}
}
void PNode_first(PNode *self) // returns 0 when at end
{
StoreCursor_jump(self->storeCursor, Datum_data(self->pidPath), (int)Datum_size(self->pidPath));
if(!PNode_key(self))
{
StoreCursor_next(self->storeCursor);
}
}
void PNode_create(PNode *self)
{
int size;
int tryCount = 0;
char *k = 0x0;
do
{
if(k) free(k);
Datum_makePid32(self->pid);
//Datum_makePid64(self->pid);
PNode_setPathsFromPid(self);
tryCount ++;
} while (k = PDB_at_(self->pdb, Datum_data(self->sizePath), (int)Datum_size(self->sizePath), &size));
if(tryCount > 3)
{
printf("WARNING: pid creation tryCount: %i %s\n", tryCount, Datum_data(self->pid));
}
PDB_at_put_(self->pdb, Datum_data(self->sizePath), (int)Datum_size(self->sizePath), "", 0);
}
IoObject *IoTagDB_symbolForId(IoTagDB *self, IoObject *locals, IoMessage *m)
{
/*doc TagDB symbolForId(aNumber)
Returns the TagDB symbol for aNumber.
*/
symbolid_t id = IoMessage_locals_sizetArgAt_(m, locals, 0);
Datum *d = TagDB_symbolForId_(DATA(self), id);
IoSeq *s = IoSeq_newWithData_length_(IOSTATE, Datum_data(d), Datum_size(d));
Datum_free(d);
return s;
}
int PNode_decrementSize(PNode *self)
{
if (PNode_size(self))
{
return PNode_setSize_(self, PNode_size(self) - 1);
}
else
{
printf("PNode warning: attempt to decrement pnode size of zero at pid path: %s\n", Datum_data(self->pidPath));
}
return 0;
}
int PNode_removeAt_(PNode *self, Datum *k)
{
if ((!Datum_isEmpty(k)) && (PNode_at_(self, k) != 0x0))
{
if(!PDB_removeAt_(self->pdb, Datum_data(self->keyPath), (int)Datum_size(self->keyPath)))
{
printf("PNode_removeAt_ error\n");
return -1;
}
return PNode_decrementSize(self);
}
return 0;
}
long PNode_size(PNode *self)
{
int size;
void *value;
value = PDB_at_(self->pdb, Datum_data(self->sizePath), (int)Datum_size(self->sizePath), &size);
if (value)
{
long sizeValue = atoi(value);
free(value);
return sizeValue;
}
return 0;
}
int VertexServer_api_collectGarbage(VertexServer *self)
{
time_t t1 = time(NULL);
long savedCount = PDB_collectGarbage(self->pdb);
double dt = difftime(time(NULL), t1);
yajl_gen_map_open(self->yajl);
yajl_gen_cstring(self->yajl, "saved");
yajl_gen_integer(self->yajl, savedCount);
yajl_gen_cstring(self->yajl, "seconds");
yajl_gen_integer(self->yajl, (int)dt);
yajl_gen_map_close(self->yajl);
Datum_appendYajl_(self->result, self->yajl);
Log_Printf_("gc: %s\n", Datum_data(self->result));
return 0;
}
Datum *PNode_metaAt_(PNode *self, Datum *d)
{
Datum *slot = PNode_metaSlotFor_(self, d);
{
int vSize;
void *v = PDB_at_(self->pdb, Datum_data(slot), (int)Datum_size(slot), &vSize);
if (v)
{
Datum *value = Datum_poolNewWithData_size_(v, vSize);
free(v);
return value;
}
}
return 0x0;
}
int PNode_remove(PNode *self)
{
Datum *k;
long removeCount = 0;
while ((k = PNode_key(self)))
{
PDB_willWrite(self->pdb);
if(!StoreCursor_remove(self->storeCursor)) break;
removeCount ++;
}
Datum_copy_(self->sizePath, self->pid);
Datum_appendCString_(self->sizePath, "/m/size");
PDB_removeAt_(self->pdb, Datum_data(self->sizePath), Datum_size(self->sizePath));
return removeCount;
}
int PNode_setSize_(PNode *self, long s)
{
Datum_copy_(self->sizePath, self->pid);
Datum_appendCString_(self->sizePath, "/m/size");
{
char ns[128];
snprintf(ns, 127, "%u", (unsigned int)s);
//printf("%s <- %s\n", Datum_data(self->sizePath), ns);
if(!PDB_at_put_(self->pdb, Datum_data(self->sizePath), (int)Datum_size(self->sizePath), (const void *)ns, (int)strlen(ns)))
{
return -1;
}
}
return 0;
}
Datum *PNode_atCString_(PNode *self, const char *k)
{
int size;
void *v;
Datum_copy_(self->keyPath, self->pidPath);
Datum_appendCString_(self->keyPath, k);
v = PDB_at_(self->pdb, Datum_data(self->keyPath), (int)Datum_size(self->keyPath), &size);
if (v != 0x0)
{
Datum *value = Datum_poolNewWithData_size_(v, size);
free(v);
return value;
}
return 0x0;
}
int VertexServer_api_transaction(VertexServer *self)
{
Datum *uri = Datum_new();
Datum *post = Datum_new();
int error = 0;
int r, result;
PDB_commit(self->pdb);
Datum_copy_(post, HttpRequest_postData(self->httpRequest));
do
{
Datum_copy_(uri, post);
r = Datum_sepOnChars_with_(uri, "\n", post);
if (Datum_size(uri) == 0)
{
VertexServer_setErrorCString_(self, "empty line in transaction");
error = 1;
break;
}
HttpRequest_parseUri_(self->httpRequest, Datum_data(uri));
error = VertexServer_process(self);
Pool_globalPoolFreeRefs();
} while ((r != -1) && (!error));
if (error)
{
PDB_abort(self->pdb);
result = -1;
}
else
{
PDB_commit(self->pdb);
result = 0;
}
Datum_free(uri);
return result;
}
const char *File_pathCString(File *self)
{
return Datum_data(self->path);
}
int File_System(Datum *cmd)
{
//Log_Printf_("system: %s\n", Datum_data(cmd));
int result = system(Datum_data(cmd));
return result;
}
void PNode_jumpToCurrentKey(PNode *self)
{
StoreCursor_jump(self->storeCursor, Datum_data(self->keyPath), (int)Datum_size(self->keyPath));
}
int PNode_doesExist(PNode *self)
{
StoreCursor_jump(self->storeCursor, Datum_data(self->pid), (int)Datum_size(self->pid));
return PNode_key(self) != 0x0;
}
void PNode_jump_(PNode *self, Datum *k)
{
Datum_copy_(self->keyPath, self->pidPath);
Datum_append_(self->keyPath, k);
StoreCursor_jump(self->storeCursor, Datum_data(self->keyPath), (int)Datum_size(self->keyPath));
}
int File_exists(File *self)
{
FILE *fp = fopen(Datum_data(self->path), "r");
if (fp) { fclose(fp); return 1; }
return 0;
}
void PNode_setPid_(PNode *self, Datum *pid)
{
PNode_setPidCString_(self, Datum_data(pid));
}
Datum *PNode_at_(PNode *self, Datum *k)
{
return PNode_atCString_(self, Datum_data(k));
}
void yajl_gen_datum(yajl_gen self, Datum *d)
{
yajl_gen_string(self, (const unsigned char *)Datum_data(d), Datum_size(d));
}
void Datum_encodeUri(Datum *self)
{
char *k = evhttp_encode_uri(Datum_data(self));
Datum_setCString_(self, k);
free(k);
}
