/// Remove the specified PTX from the DB via its index.
/// @param[in] key the key associated with a given PTX
/// return zero iff the node was found and successfully removed
static int
_shop_ptx_invalidate(shopping_state_s *ssp, CCS key, CCS msg, int ignored)
{
dnode_t *dnp;
CCS id;
dnp = dict_lookup(ssp->ptx_dict, key);
if (ignored && dnp) {
id = (CCS)dnode_get(dnp);
vb_printf(VB_WHY, "WOULD INVALIDATE %s (%s) due to '%s'", id, key, msg);
return 0;
}
if (dnp) {
id = (CCS)dnode_get(dnp);
key = (CCS)dnode_getkey(dnp);
vb_printf(VB_WHY, "PTX %s invalidated due to '%s'", id, msg);
dict_delete_free(ssp->ptx_dict, dnp);
putil_free(id);
putil_free(key);
return 0;
} else {
putil_warn("invalidated PTX %s twice", key);
return 1;
}
}
void *TA_DictGetValue_S2( TA_Dict *dict, const char *key1, const char *key2 )
{
TA_PrivDictInfo *theDict;
dnode_t *node;
TA_PrivDictInfo *subDict;
TA_Libc *libHandle;
theDict = (TA_PrivDictInfo *)dict;
if( (theDict == NULL) || (key1 == NULL) || (key2 == NULL))
return NULL;
libHandle = theDict->libHandle;
/* Find the dictionary for key1. */
node = dict_lookup( libHandle, &theDict->d, key1 );
if( !node )
return NULL;
subDict = dnode_get(node);
/* Find the key-value pair using key2. */
node = dict_lookup( libHandle, &subDict->d, key2 );
if( !node )
return NULL;
return dnode_get(node);
}
/*
void cxml_node_free(CLOG_INFO* info, void * data) {
CXMLNODE *node = (CXMLNODE*) data;
*/
void cxml_node_free(CLOG_INFO* info, CXMLNODE **node) {
dnode_t *dn = NULL;
if(NULL==node || NULL==*node) {
return;
}
clog( info, CTRACE, "XML: xml_node_free(), free the attributes");
// free the attributes
if(NULL!=(*node)->att) {
if(!dict_isempty((*node)->att)) {
for (dn = dict_first((*node)->att); dn; dn = dict_next((*node)->att, dn)) {
char *key=(char*)dnode_getkey(dn);
char *data=(char*)dnode_get(dn);
if(NULL!=key) free(key); key=NULL;
if(NULL!=data) free(data); data=NULL;
}
}
dict_free_nodes((*node)->att);
dict_destroy((*node)->att);
(*node)->att=NULL;
}
clog( info, CTRACE, "XML: xml_node_free(), free the name");
// free the name
if(NULL!=(*node)->name) cstring_free(&((*node)->name));
clog( info, CTRACE, "XML: xml_node_free(), free the data");
// free the data
if(NULL!=(*node)->data) cstring_free(&((*node)->data));
clog( info, CTRACE, "XML: xml_node_free(), free the subs");
// free the children
if(NULL!=(*node)->sub) {
if(!dict_isempty((*node)->sub)) {
for (dn = dict_first((*node)->sub); dn; dn = dict_next((*node)->sub, dn)) {
char *key=(char*)dnode_getkey(dn);
CXMLNODE *data=(CXMLNODE*)dnode_get(dn);
if(NULL!=key) free(key); key=NULL;
cxml_node_free(info, &data);
}
}
dict_free_nodes((*node)->sub);
dict_destroy((*node)->sub);
(*node)->sub=NULL;
}
free((*node));
(*node)=NULL;
node=NULL;
}
/*
* Add a duplicate block record
*/
static void add_dupe(e2fsck_t ctx, ext2_ino_t ino, blk64_t cluster,
struct ext2_inode *inode)
{
dnode_t *n;
struct dup_cluster *db;
struct dup_inode *di;
struct cluster_el *cluster_el;
struct inode_el *ino_el;
n = dict_lookup(&clstr_dict, INT_TO_VOIDPTR(cluster));
if (n)
db = (struct dup_cluster *) dnode_get(n);
else {
db = (struct dup_cluster *) e2fsck_allocate_memory(ctx,
sizeof(struct dup_cluster), "duplicate cluster header");
db->num_bad = 0;
db->inode_list = 0;
dict_alloc_insert(&clstr_dict, INT_TO_VOIDPTR(cluster), db);
}
ino_el = (struct inode_el *) e2fsck_allocate_memory(ctx,
sizeof(struct inode_el), "inode element");
ino_el->inode = ino;
ino_el->next = db->inode_list;
db->inode_list = ino_el;
db->num_bad++;
n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino));
if (n)
di = (struct dup_inode *) dnode_get(n);
else {
di = (struct dup_inode *) e2fsck_allocate_memory(ctx,
sizeof(struct dup_inode), "duplicate inode header");
if (ino == EXT2_ROOT_INO) {
di->dir = EXT2_ROOT_INO;
dup_inode_founddir++;
} else
di->dir = 0;
di->num_dupblocks = 0;
di->cluster_list = 0;
di->inode = *inode;
dict_alloc_insert(&ino_dict, INT_TO_VOIDPTR(ino), di);
}
cluster_el = (struct cluster_el *) e2fsck_allocate_memory(ctx,
sizeof(struct cluster_el), "cluster element");
cluster_el->cluster = cluster;
cluster_el->next = di->cluster_list;
di->cluster_list = cluster_el;
di->num_dupblocks++;
}
/// Any PTXes which survived shopping are eligible to be winners,
/// as long as they've been seen and evaluated at all. This test is
/// necessary because not all commands are run in all PTXes, so the
/// fact that a PTX has not been invalidated could mean it was not
/// even evaluated.
/// This function returns the first eligible surviving PTX. It does not
/// establish a policy per se; since PTXes are stored in an order set by
/// the server, the policy of which matching PTX is 'best' can be
/// dictated by the server.
/// @return the chosen PTX id
static CCS
_shop_ptx_winner(shopping_state_s *ssp)
{
dnode_t *dnp, *next;
ssp->wix[0] = ssp->winner[0] = '\0';
if (ssp->ptx_dict) {
for (dnp = dict_first(ssp->ptx_dict); dnp;) {
CCS key, id;
next = dict_next(ssp->ptx_dict, dnp);
key = (CCS)dnode_getkey(dnp);
id = (CCS)dnode_get(dnp);
// Remember, only an evaluated PTX can be a winner.
// These are marked with a lower-case index, but
// convert it back to upper case before returning.
if (islower((int)key[0])) {
snprintf(ssp->wix, charlen(ssp->wix), "%c%s",
toupper((int)key[0]), key + 1);
snprintf(ssp->winner, charlen(ssp->winner), "%s", id);
return ssp->winner;
}
dnp = next;
}
}
return NULL;
}
TA_RetCode TA_DictDeletePair_S( TA_Dict *dict, const char *key )
{
TA_PrivDictInfo *theDict;
TA_String *stringToDelete;
void *valueToDelete;
dnode_t *node;
TA_Libc *libHandle;
dict_t *kazlibDict;
theDict = (TA_PrivDictInfo *)dict;
if( (theDict == NULL) || (key == NULL) )
return TA_BAD_PARAM;
kazlibDict = &theDict->d;
libHandle = theDict->libHandle;
/* Find the key-value pair. */
node = dict_lookup( libHandle, kazlibDict, key );
if( node )
{
/* Free the 'node', the 'key' string and the 'value'. */
stringToDelete = TA_StringFromChar( dnode_getkey(node) );
valueToDelete = dnode_get(node);
dict_delete_free( libHandle, kazlibDict, node );
TA_StringFree( TA_GetGlobalStringCache( libHandle ), stringToDelete );
if( theDict->freeValueFunc )
theDict->freeValueFunc( libHandle, valueToDelete );
}
else
return TA_KEY_NOT_FOUND;
return TA_SUCCESS;
}
TA_RetCode TA_DictDeletePair_I( TA_Dict *dict, int key )
{
TA_PrivDictInfo *theDict;
void *valueToDelete;
dnode_t *node;
TA_Libc *libHandle;
dict_t *kazlibDict;
theDict = (TA_PrivDictInfo *)dict;
if( theDict == NULL )
return TA_BAD_PARAM;
kazlibDict = &theDict->d;
libHandle = theDict->libHandle;
/* Find the key-value pair. */
node = dict_lookup( libHandle, kazlibDict, (void *)key );
if( node )
{
/* Free the 'node' and the 'value'. */
valueToDelete = dnode_get(node);
dict_delete_free( libHandle, kazlibDict, node );
if( theDict->freeValueFunc )
theDict->freeValueFunc( libHandle, valueToDelete );
}
else
return TA_KEY_NOT_FOUND;
return TA_SUCCESS;
}
static void free_dict(dnode_t *node, void *notused) {
m2_ws_session_id *keyptr = (m2_ws_session_id*)dnode_getkey(node);
m2_ws_session_data *valptr = (m2_ws_session_data*)dnode_get(node);
printf("Freeing conn_id = %d, seen %d times\n",keyptr->req->conn_id,valptr->times_seen);
free(keyptr);
free(valptr);
free(node);
}
TA_RetCode TA_DictFree( TA_Dict *dict )
{
TA_PrivDictInfo *theDict;
dnode_t *node;
dnode_t *next;
TA_String *stringToDelete;
void *valueToDelete;
dict_t *kazlibDict;
TA_Libc *libHandle;
int flags;
theDict = (TA_PrivDictInfo *)dict;
if( theDict == NULL )
return TA_BAD_PARAM;
kazlibDict = &theDict->d;
libHandle = theDict->libHandle;
/* Delete all the key-value pair sequentially. */
node = dict_first( libHandle, kazlibDict );
while (node != NULL)
{
/* Get the next node. */
next = dict_next( libHandle, kazlibDict, node );
/* Free the 'node, the 'key' string and the 'value'. */
flags = theDict->flags;
valueToDelete = dnode_get(node);
if( flags & (TA_DICT_KEY_TWO_STRING|TA_DICT_KEY_ONE_STRING) )
{
stringToDelete = TA_StringFromChar(dnode_getkey(node));
dict_delete_free( libHandle, kazlibDict, node );
TA_StringFree( TA_GetGlobalStringCache( libHandle ), stringToDelete );
}
else
dict_delete_free( libHandle, kazlibDict, node );
if( flags & TA_DICT_KEY_TWO_STRING )
{
/* The value is a dictionary. Delete it. */
TA_DictFree( (TA_Dict *)valueToDelete );
}
else if( theDict->freeValueFunc )
theDict->freeValueFunc( libHandle, valueToDelete );
node = next;
}
/* Free the TA_PrivDictInfo */
TA_Free( libHandle, theDict );
return TA_SUCCESS;
}
TA_RetCode TA_DictAddPair_S2( TA_Dict *dict,
TA_String *key1,
TA_String *key2,
void *value )
{
TA_PrivDictInfo *theDict;
dnode_t *node;
TA_String *dupKey;
TA_Dict *subDict;
TA_Libc *libHandle;
dict_t *kazlibDict;
theDict = (TA_PrivDictInfo *)dict;
if( (theDict == NULL) ||
(key1 == NULL) || (key2 == NULL) || (value == NULL) )
return TA_BAD_PARAM;
kazlibDict = &theDict->d;
libHandle = theDict->libHandle;
/* Verify if a a dictionary already exist for key1. */
node = dict_lookup( libHandle, kazlibDict, TA_StringToChar(key1) );
if( node )
{
/* A dictionary already exist with the same key1... re-use it. */
subDict = (TA_Dict *)dnode_get( node );
}
else
{
/* Alloc a new directory corresponding to key1. */
subDict = TA_DictAlloc( libHandle, TA_DICT_KEY_ONE_STRING, theDict->freeValueFunc );
if( !subDict )
return TA_ALLOC_ERR;
dupKey = TA_StringDup( TA_GetGlobalStringCache( libHandle ), key1 );
if( !dupKey )
{
TA_DictFree( subDict );
return TA_ALLOC_ERR;
}
if( !dict_alloc_insert( libHandle, kazlibDict, TA_StringToChar(dupKey), subDict ) )
{
TA_DictFree( subDict );
TA_StringFree( TA_GetGlobalStringCache( libHandle ), dupKey );
return TA_ALLOC_ERR;
}
}
/* Insert the string in the subDict using key2 */
return TA_DictAddPair_S( subDict, key2, value );
}
void ledger_close_topic(ledger_ctx *ctx, const char *name) {
ledger_topic *topic = NULL;
dnode_t *dtopic;
dtopic = dict_lookup(&ctx->topics, name);
if(dtopic != NULL) {
topic = dnode_get(dtopic);
ledger_topic_close(topic);
dict_delete_free(&ctx->topics, dtopic);
}
}
ledger_topic *ledger_lookup_topic(ledger_ctx *ctx, const char *name) {
ledger_topic *topic = NULL;
dnode_t *dtopic;
dtopic = dict_lookup(&ctx->topics, name);
if(dtopic != NULL) {
topic = dnode_get(dtopic);
return topic;
}
return NULL;
}
void *TA_DictAccessValue( TA_Dict *dict )
{
TA_PrivDictInfo *theDict;
theDict = (TA_PrivDictInfo *)dict;
if( (theDict == NULL) || (theDict->accessNode == NULL) )
return NULL;
return dnode_get( theDict->accessNode );
}
void
fixIID(sim4polish *q, dict_t *estdict) {
// Fix the IID's
dnode_t *cid = dict_lookup(estdict, q->_estDefLine);
dnode_t *gid = dict_lookup(GENdict, q->_genDefLine);
if ((cid == 0L) || (gid == 0L)) {
const char *msg = "both deflines";
if (cid) msg = "genomic defline";
if (gid) msg = "est defline";
q->s4p_printPolish(stdout);
fprintf(stderr, "ERROR: Couldn't find %s (%p %p) in the dictionary!\n", msg, cid, gid);
exit(1);
}
q->_estID = (uint32)(unsigned long)dnode_get(cid);
q->_genID = (uint32)(unsigned long)dnode_get(gid);
}
static void write_dquots(dict_t *dict, struct quota_handle *qh)
{
dnode_t *n;
struct dquot *dq;
for (n = dict_first(dict); n; n = dict_next(dict, n)) {
dq = dnode_get(n);
if (dq) {
dq->dq_h = qh;
update_grace_times(dq);
qh->qh_ops->commit_dquot(dq);
}
}
}
TA_RetCode TA_DictAddPair_S( TA_Dict *dict,
TA_String *key,
void *value )
{
TA_PrivDictInfo *theDict;
dnode_t *node;
TA_String *dupKey;
TA_Libc *libHandle;
dict_t *kazlibDict;
theDict = (TA_PrivDictInfo *)dict;
if( (theDict == NULL) || (key == NULL) || (value == NULL) )
return TA_BAD_PARAM;
kazlibDict = &theDict->d;
libHandle = theDict->libHandle;
/* Verify if an entry exist already with the same key. */
node = dict_lookup( libHandle, kazlibDict, TA_StringToChar(key) );
if( node )
{
/* An entry already exist with the same key...
* Re-use the existing node. Just replace the
* 'value' part.
* De-allocate the older 'value'.
*/
if( theDict->freeValueFunc )
(*theDict->freeValueFunc)( libHandle, dnode_get( node ) );
dnode_put( node, value );
}
else
{
/* Alloc/insert a new key-value pair in the dictionary. */
dupKey = TA_StringDup( TA_GetGlobalStringCache( libHandle ), key );
if( !dupKey )
return TA_ALLOC_ERR;
if( !dict_alloc_insert( libHandle, kazlibDict, TA_StringToChar(dupKey), value ) )
{
TA_StringFree( TA_GetGlobalStringCache( libHandle ), dupKey );
return TA_ALLOC_ERR;
}
}
return TA_SUCCESS;
}
void ledger_close_context(ledger_ctx *ctx) {
dnode_t *cur;
ledger_topic *topic = NULL;
for(cur = dict_first(&ctx->topics);
cur != NULL;
cur = dict_next(&ctx->topics, cur)) {
topic = dnode_get(cur);
ledger_topic_close(topic);
free(topic);
}
ledger_position_storage_close(&ctx->position_storage);
dict_free_nodes(&ctx->topics);
}
void *TA_DictGetValue_I( TA_Dict *dict, int key )
{
TA_PrivDictInfo *theDict;
dnode_t *node;
theDict = (TA_PrivDictInfo *)dict;
if( theDict == NULL )
return NULL;
/* Find the key-value pair. */
node = dict_lookup( theDict->libHandle, &theDict->d, (void *)key );
if( !node )
return NULL;
return dnode_get(node);
}
void *TA_DictGetValue_S( TA_Dict *dict, const char *key )
{
TA_PrivDictInfo *theDict;
dnode_t *node;
theDict = (TA_PrivDictInfo *)dict;
if( (theDict == NULL) || (key == NULL) )
return NULL;
/* Find the key-value pair. */
node = dict_lookup( theDict->libHandle, &theDict->d, key );
if( !node )
return NULL;
return dnode_get(node);
}
void
process_from_founded_sig(dict_t *dict)
{
if ( !dict || !dict_count(dict) )
return;
if ( !check_rpd_count(true) )
return;
dnode_t *node;
pdb_class *pc;
char *c_name;
ea_t ea;
for ( node = dict_first(dict); node; node = dict_next(dict, node) )
{
c_name = (char *)dnode_get(node);
ea = (ea_t)dnode_getkey(node);
pc = p_pool->find_class(c_name);
if ( !pc )
continue;
fill_vtbl(c_name, ea, pc);
}
}
/// Free all data structures allocated by _shop_ptx_init().
static void
_shop_ptx_destroy(dict_t *dict)
{
dnode_t *dnp, *next;
if (dict) {
for (dnp = dict_first(dict); dnp;) {
CCS key, id;
next = dict_next(dict, dnp);
key = (CCS)dnode_getkey(dnp);
id = (CCS)dnode_get(dnp);
dict_delete_free(dict, dnp);
putil_free(key);
putil_free(id);
dnp = next;
}
dict_destroy(dict);
}
}
TA_RetCode TA_DictDeletePair_S2( TA_Dict *dict, const char *key1, const char *key2 )
{
TA_PrivDictInfo *theDict;
TA_String *stringToDelete;
dnode_t *node;
TA_Dict *subDict;
TA_RetCode retCode;
TA_Libc *libHandle;
dict_t *kazlibDict;
theDict = (TA_PrivDictInfo *)dict;
if( (theDict == NULL) ||
(key1 == NULL) ||
(key2 == NULL))
return TA_BAD_PARAM;
kazlibDict = &theDict->d;
libHandle = theDict->libHandle;
/* Find the dictionary for this 'key1'. */
node = dict_lookup( libHandle, kazlibDict, key1 );
if( !node )
return TA_KEY_NOT_FOUND;
subDict = (TA_Dict *)dnode_get(node);
retCode = TA_DictDeletePair_S( subDict, key2 );
/* Delete the dictionary if it is empty. */
if( (retCode == TA_SUCCESS) && (TA_DictSize(subDict) == 0) )
{
TA_DictFree( subDict );
/* Free the 'node' and the 'key1' string. */
stringToDelete = TA_StringFromChar( dnode_getkey(node) );
dict_delete_free( theDict->libHandle, kazlibDict, node );
TA_StringFree( TA_GetGlobalStringCache( libHandle ), stringToDelete );
}
return TA_SUCCESS;
}
TA_RetCode TA_DictAddPair_I( TA_Dict *dict,
int key,
void *value )
{
TA_PrivDictInfo *theDict;
dnode_t *node;
TA_Libc *libHandle;
dict_t *kazlibDict;
theDict = (TA_PrivDictInfo *)dict;
if( (theDict == NULL) || (value == NULL) )
return TA_BAD_PARAM;
kazlibDict = &theDict->d;
libHandle = theDict->libHandle;
/* Verify if an entry exist already with the same key. */
node = dict_lookup( libHandle, kazlibDict, (void *)key );
if( node )
{
/* An entry already exist with the same key...
* Re-use the existing node. Just replace the
* 'value' part.
* De-allocate the older 'value'.
*/
if( theDict->freeValueFunc )
(*theDict->freeValueFunc)( libHandle, dnode_get( node ) );
dnode_put( node, value );
}
else
{
/* Insert the new key-value pair in the dictionary. */
if( !dict_alloc_insert( libHandle, kazlibDict, (void *)key, value ) )
return TA_ALLOC_ERR;
}
return TA_SUCCESS;
}
int main(void)
{
input_t in;
dict_t darray[10];
dict_t *d = &darray[0];
dnode_t *dn;
size_t i;
char *tok1, *tok2, *val;
const char *key;
char *help =
"a <key> <val> add value to dictionary\n"
"d <key> delete value from dictionary\n"
"l <key> lookup value in dictionary\n"
"( <key> lookup lower bound\n"
") <key> lookup upper bound\n"
"< <key> lookup strict lower bound\n"
"> <key> lookup strict upper bound\n"
"# <num> switch to alternate dictionary (0-9)\n"
"j <num> <num> merge two dictionaries\n"
"f free the whole dictionary\n"
"k allow duplicate keys\n"
"c show number of entries\n"
"t dump whole dictionary in sort order\n"
"m make dictionary out of sorted items\n"
"p turn prompt on\n"
"s switch to non-functioning allocator\n"
"q quit";
for (i = 0; i < sizeof darray / sizeof *darray; i++)
dict_init(&darray[i], DICTCOUNT_T_MAX, comparef);
for (;;) {
if (prompt)
putchar('>');
fflush(stdout);
if (!fgets(in, sizeof(input_t), stdin))
break;
switch(in[0]) {
case '?':
puts(help);
break;
case 'a':
if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
puts("what?");
break;
}
key = dupstring(tok1);
val = dupstring(tok2);
if (!key || !val) {
puts("out of memory");
free((void *) key);
free(val);
}
if (!dict_alloc_insert(d, key, val)) {
puts("dict_alloc_insert failed");
free((void *) key);
free(val);
break;
}
break;
case 'd':
if (tokenize(in+1, &tok1, (char **) 0) != 1) {
puts("what?");
break;
}
dn = dict_lookup(d, tok1);
if (!dn) {
puts("dict_lookup failed");
break;
}
val = (char *) dnode_get(dn);
key = (char *) dnode_getkey(dn);
dict_delete_free(d, dn);
free(val);
free((void *) key);
break;
case 'f':
dict_free_nodes(d);
break;
case 'l':
case '(':
case ')':
case '<':
case '>':
if (tokenize(in+1, &tok1, (char **) 0) != 1) {
puts("what?");
break;
}
dn = 0;
switch (in[0]) {
case 'l':
dn = dict_lookup(d, tok1);
break;
case '(':
dn = dict_lower_bound(d, tok1);
break;
case ')':
dn = dict_upper_bound(d, tok1);
break;
case '<':
dn = dict_strict_lower_bound(d, tok1);
break;
case '>':
dn = dict_strict_upper_bound(d, tok1);
break;
}
if (!dn) {
puts("lookup failed");
break;
}
val = (char *) dnode_get(dn);
puts(val);
break;
case 'm':
construct(d);
break;
case 'k':
dict_allow_dupes(d);
break;
case 'c':
printf("%lu\n", (unsigned long) dict_count(d));
break;
case 't':
for (dn = dict_first(d); dn; dn = dict_next(d, dn)) {
printf("%s\t%s\n", (char *) dnode_getkey(dn),
(char *) dnode_get(dn));
}
break;
case 'q':
exit(0);
break;
case '\0':
break;
case 'p':
prompt = 1;
break;
case 's':
dict_set_allocator(d, new_node, del_node, NULL);
break;
case '#':
if (tokenize(in+1, &tok1, (char **) 0) != 1) {
puts("what?");
break;
} else {
int dictnum = atoi(tok1);
if (dictnum < 0 || dictnum > 9) {
puts("invalid number");
break;
}
d = &darray[dictnum];
}
break;
case 'j':
if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
puts("what?");
break;
} else {
int dict1 = atoi(tok1), dict2 = atoi(tok2);
if (dict1 < 0 || dict1 > 9 || dict2 < 0 || dict2 > 9) {
puts("invalid number");
break;
}
dict_merge(&darray[dict1], &darray[dict2]);
}
break;
default:
putchar('?');
putchar('\n');
break;
}
}
return 0;
}
d = VOIDPTR_TO_UINT(b);
return c - d;
}
static inline qid_t get_qid(struct ext2_inode *inode, int qtype)
{
if (qtype == USRQUOTA)
return inode_uid(*inode);
return inode_gid(*inode);
}
static void quota_dnode_free(dnode_t *node,
void *context EXT2FS_ATTR((unused)))
{
void *ptr = node ? dnode_get(node) : 0;
ext2fs_free_mem(&ptr);
free(node);
}
/*
* Set up the quota tracking data structures.
*/
errcode_t quota_init_context(quota_ctx_t *qctx, ext2_filsys fs, int qtype)
{
int i, err = 0;
dict_t *dict;
quota_ctx_t ctx;
err = ext2fs_get_mem(sizeof(struct quota_ctx), &ctx);
int main(int argc, char **args){
if(argc != 3){
fprintf(stderr,"%s RECV SEND\n",args[0]);
exit(1);
}
signal(SIGINT,&call_for_stop);
bstring pull_addr = bfromcstr(args[1]);
bstring pub_addr = bfromcstr(args[2]);
mongrel2_ctx *ctx = mongrel2_init(1); // Yes for threads?
mongrel2_socket *pull_socket = mongrel2_pull_socket(ctx);
mongrel2_connect(pull_socket, bdata(pull_addr));
pub_socket = mongrel2_pub_socket(ctx);
mongrel2_connect(pub_socket, bdata(pub_addr));
mongrel2_set_identity(pub_socket, bdata(&SENDER) );
mongrel2_request *request;
// Polling is done to show how to do a clean shutdown
int poll_response;
zmq_pollitem_t socket_tracker;
socket_tracker.socket = pull_socket->zmq_socket;
socket_tracker.events = ZMQ_POLLIN;
// Let's try out some ADT goodness
dict_t* dict = dict_create(DICTCOUNT_T_MAX, compare_session);
dict_set_allocator(dict, alloc_dict, free_dict, NULL);
dnode_t* tempnode = NULL;
m2_ws_session_data *counter = NULL;
int retval = 0;
while(shutdown != 1){
poll_response = zmq_poll(&socket_tracker,1,500*1000);
if(poll_response > 0){
request = mongrel2_recv(pull_socket);
fprintf(stdout,"got something...\n");
if(request != NULL && mongrel2_request_for_disconnect(request) != 1){
m2_ws_session_id* incoming = calloc(1,sizeof(m2_ws_session_id));
incoming->req = request;
printf("Looking at incoming->conn_id = %d\n",incoming->req->conn_id);
tempnode = dict_lookup(dict,incoming);
if(tempnode == NULL){
mongrel2_ws_reply_upgrade(request,pub_socket);
counter = calloc(1,sizeof(m2_ws_session_data));
counter->times_seen = 0;
retval = dict_alloc_insert(dict,incoming,counter);
assert(retval == 1);
} else {
free(incoming);
counter = dnode_get(tempnode);
counter->times_seen += 1;
}
if(blength(request->body) > 0){
if(tempnode && mongrel2_ws_frame_get_fin(blength(request->body),
(uint8_t*)bdata(request->body))){
printf("Hey, it's a close\n");
dict_delete_free(dict,tempnode);
mongrel2_disconnect(pub_socket,request);
}
} else {
bstring randmsg = genrandmsg();
mongrel2_ws_reply(pub_socket,request,randmsg);
}
printf("FYI: we've got %ld entries\n",dict_count(dict));
} else {
fprintf(stdout,"Connection %d disconnected\n", request->conn_id);
}
} else if (poll_response < 0){
fprintf(stdout, "Error on poll!");
shutdown = 1;
}
}
// bstring msg = bformat("{\"msg\" : \"hi there %d\"}", request->conn_id);
// fprintf(stdout,"Sending new msg: '%*s'",blength(msg),bdata(msg));
// mongrel2_ws_reply(pub_socket,request,msg);
// bdestroy(msg);
// mongrel2_request_finalize(request);
// mongrel2_reply(pub_socket,request,bfromcstr(""));
bdestroy(pull_addr);
bdestroy(pub_addr);
mongrel2_close(pull_socket);
mongrel2_close(pub_socket);
mongrel2_deinit(ctx);
fprintf(stdout,"\nClean shutdown done! Thanks for playing!\n");
return 0;
}
int
main(int argc, char **argv) {
char *merylCount = 0L;
char *fastaName = 0L;
int arg=1;
while (arg < argc) {
if (strcmp(argv[arg], "-m") == 0) {
merylCount = argv[++arg];
} else if (strcmp(argv[arg], "-f") == 0) {
fastaName = argv[++arg];
} else {
fprintf(stderr, "unknown option '%s'\n", argv[arg]);
}
arg++;
}
if ((merylCount == 0L) || (fastaName == 0L)) {
fprintf(stderr, "usage: %s -m <meryl-name-prefix> -f <fasta-file>\n", argv[0]);
exit(1);
}
// Open the count files
//
merylStreamReader *MSR = new merylStreamReader(merylCount);
fprintf(stderr, "Mers are "uint32FMT" bases.\n", MSR->merSize());
fprintf(stderr, "There are "uint64FMT" unique (copy = 1) mers.\n", MSR->numberOfUniqueMers());
fprintf(stderr, "There are "uint64FMT" distinct mers.\n", MSR->numberOfDistinctMers());
fprintf(stderr, "There are "uint64FMT" mers total.\n", MSR->numberOfTotalMers());
// Guess how many mers we can fit into 512MB, then report how many chunks we need to do.
uint32 merSize = MSR->merSize();
uint64 memoryLimit = 700 * 1024 * 1024;
uint64 perMer = sizeof(kMerLite) + sizeof(dnode_t);
uint64 mersPerBatch = memoryLimit / perMer;
uint32 numBatches = MSR->numberOfDistinctMers() / mersPerBatch;
uint32 batch = 0;
dnode_t *nodes = new dnode_t [mersPerBatch];
kMerLite *mers = new kMerLite [mersPerBatch];
if (MSR->numberOfDistinctMers() % mersPerBatch)
numBatches++;
fprintf(stderr, "perMer: "uint64FMT" bytes ("uint64FMT" for kMerLite, "uint64FMT" for dnode_t.\n",
perMer, (uint64)sizeof(kMerLite), (uint64)sizeof(dnode_t));
fprintf(stderr, "We can fit "uint64FMT" mers into "uint64FMT"MB.\n", mersPerBatch, memoryLimit >> 20);
fprintf(stderr, "So we need "uint32FMT" batches to verify the count.\n", numBatches);
while (MSR->validMer()) {
uint64 mersRemain = mersPerBatch;
dict_t *merDict = dict_create(mersPerBatch, kMerLiteSort);
batch++;
// STEP 1: Insert mersPerBatch into the merDict
//
fprintf(stderr, "STEP 1 BATCH "uint32FMTW(2)": Insert into merDict\n", batch);
while (MSR->nextMer() && mersRemain) {
mersRemain--;
mers[mersRemain] = MSR->theFMer();
// initialize the node with the value, then insert the node
// into the tree using the key
int32 val = (int32)MSR->theCount();
dnode_init(&nodes[mersRemain], (void *)val);
dict_insert(merDict, &nodes[mersRemain], &mers[mersRemain]);
}
// STEP 2: Stream the original file, decrementing the count
//
fprintf(stderr, "STEP 2 BATCH "uint32FMTW(2)": Stream fasta\n", batch);
seqStream *CS = new seqStream(fastaName, true);
merStream *MS = new merStream(new kMerBuilder(merSize), CS);
kMerLite mer;
dnode_t *nod;
while (MS->nextMer()) {
mer = MS->theFMer();
nod = dict_lookup(merDict, &mer);
if (nod != 0L) {
int32 val = (int32)dnode_get(nod);
val--;
dnode_put(nod, (void *)val);
} else {
// Unless the whole meryl file fit into our merDict, we cannot warn if
// we don't find mers.
//
if (numBatches == 1) {
char str[1024];
fprintf(stderr, "Didn't find node for mer '%s'\n", mer.merToString(merSize, str));
}
}
}
delete MS;
delete CS;
// STEP 3: Check every node in the tree to make sure that the counts
// are exactly zero.
//
fprintf(stderr, "STEP 3 BATCH "uint32FMTW(2)": Check\n", batch);
nod = dict_first(merDict);
while (nod) {
int32 val = (int32)dnode_get(nod);
kMerLite const *nodmer = (kMerLite const *)dnode_getkey(nod);
if (val != 0) {
char str[1024];
fprintf(stderr, "Got count "int32FMT" for mer '%s'\n",
val,
nodmer->merToString(merSize, str));
}
nod = dict_next(merDict, nod);
}
// STEP 4: Destroy the dictionary.
//
fprintf(stderr, "STEP 4 BATCH "uint32FMTW(2)": Destroy\n", batch);
while ((nod = dict_first(merDict)))
dict_delete(merDict, nod);
dict_destroy(merDict);
}
}
cluster_el->cluster = cluster;
cluster_el->next = di->cluster_list;
di->cluster_list = cluster_el;
di->num_dupblocks++;
}
/*
* Free a duplicate inode record
*/
static void inode_dnode_free(dnode_t *node,
void *context EXT2FS_ATTR((unused)))
{
struct dup_inode *di;
struct cluster_el *p, *next;
di = (struct dup_inode *) dnode_get(node);
for (p = di->cluster_list; p; p = next) {
next = p->next;
free(p);
}
free(di);
free(node);
}
/*
* Free a duplicate cluster record
*/
static void cluster_dnode_free(dnode_t *node,
void *context EXT2FS_ATTR((unused)))
{
struct dup_cluster *dc;
