static rc_t sra_meta_stats_make(sra_meta_stats_data** self, VTable* vtbl, bool has_spot_group, bool compressed) { rc_t rc = 0; sra_meta_stats_data* data = calloc(1, sizeof(*data)); assert(self != NULL && vtbl != NULL); if( data == NULL ) { rc = RC(rcVDB, rcFunction, rcConstructing, rcMemory, rcExhausted); } else if( (rc = VTableOpenMetadataUpdate(vtbl, &data->meta)) == 0 ) { KMDataNode* node; data->compressed = compressed; if( (rc = KMetadataOpenNodeUpdate(data->meta, &node, "STATS/TABLE")) == 0 ) { rc = sra_meta_stats_node_group_open(node, &data->table, compressed); KMDataNodeRelease(node); } if( rc == 0 && has_spot_group ) { if( (rc = KMetadataOpenNodeUpdate(data->meta, &node, "STATS/SPOT_GROUP/default")) == 0 ) { rc = sra_meta_stats_node_group_open(node, &data->dflt_grp, compressed); KMDataNodeRelease(node); } } } if( rc == 0 ) { *self = data; } else { sra_meta_stats_whack(data); } return rc; }
static rc_t group_stats_write(group_stats_t const *const self, stats_data_t const *const parent, char const strings[]) { static char const namebase[] = "STATS/SPOT_GROUP/"; char namepath[sizeof(namebase) + 3]; /* sizeof(namebase) includes terminator */ char *const name = namepath + sizeof(namebase) - 1; unsigned nodeid = self->node_name - 1; KMDataNode *node; rc_t rc; memcpy(namepath, namebase, sizeof(namebase)); name[4] = '\0'; name[3] = nodeid % 26 + 'A'; nodeid /= 26; name[2] = nodeid % 26 + 'A'; nodeid /= 26; name[1] = nodeid % 26 + 'A'; nodeid /= 26; name[0] = nodeid % 26 + 'A'; nodeid /= 26; RC_THROW(KMetadataOpenNodeUpdate(parent->meta, &node, "%s", namepath)); rc = group_stats_write_1(self, parent, self->name_len, strings + self->name_offset, node); KMDataNodeRelease(node); return rc; }
static rc_t pacbio_meta_entry( ld_context *lctx, const char * toolname ) { KMetadata* meta = NULL; rc_t rc = VDatabaseOpenMetadataUpdate( lctx->database, &meta ); if ( rc != 0 ) { LOGERR( klogErr, rc, "Cannot open database-metadata" ); } else { KMDataNode *node = NULL; rc = KMetadataOpenNodeUpdate( meta, &node, "/" ); if ( rc != 0 ) { LOGERR( klogErr, rc, "Cannot open database-metadata-root" ); } else { rc = KLoaderMeta_Write( node, toolname, __DATE__, "PacBio HDF5", PACBIO_LOAD_VERS ); if ( rc != 0 ) { LOGERR( klogErr, rc, "Cannot write pacbio metadata node" ); } KMDataNodeRelease( node ); } KMetadataRelease( meta ); } return rc; }
static rc_t enter_vdbcopy_node( KMetadata *dst_meta, const bool show_meta ) { rc_t rc; KMDataNode *hist_node; if ( show_meta ) KOutMsg( "--- entering Copy entry...\n" ); rc = KMetadataOpenNodeUpdate ( dst_meta, &hist_node, "HISTORY" ); DISP_RC( rc, "enter_vdbcopy_node:KMetadataOpenNodeUpdate('HISTORY') failed" ); if ( rc == 0 ) { char event_name[ 32 ]; uint32_t index = get_child_count( hist_node ) + 1; rc = string_printf ( event_name, sizeof( event_name ), NULL, "EVENT_%u", index ); DISP_RC( rc, "enter_vdbcopy_node:string_printf(EVENT_NR) failed" ); if ( rc == 0 ) { KMDataNode *event_node; rc = KMDataNodeOpenNodeUpdate ( hist_node, &event_node, event_name ); DISP_RC( rc, "enter_vdbcopy_node:KMDataNodeOpenNodeUpdate('EVENT_NR') failed" ); if ( rc == 0 ) { rc = enter_date_name_vers( event_node ); KMDataNodeRelease ( event_node ); } } KMDataNodeRelease ( hist_node ); } return rc; }
LIB_EXPORT rc_t CC TableWriterSeq_Whack(const TableWriterSeq* cself, bool commit, uint64_t* rows) { rc_t rc = 0; if( cself != NULL ) { TableWriterSeq* self = (TableWriterSeq*)cself; VTable *vtbl; TableReader_Whack(cself->tmpkey_reader); if (commit && (rc = TableWriter_GetVTable(cself->base, &vtbl)) == 0 ) { KMetadata* meta; if ((rc = VTableOpenMetadataUpdate(vtbl, &meta)) == 0) { KMDataNode* node = NULL; if (cself->stats) { if ((rc = KMetadataOpenNodeUpdate(meta, &node, "MATE_STATISTICS")) == 0) { rc = TableWriterSeq_WriteStatistics(cself, node); KMDataNodeRelease(node); } } if ((rc = KMetadataOpenNodeUpdate(meta, &node, "unaligned")) == 0) { KMDataNode *sub = NULL; KMDataNodeOpenNodeUpdate(node, &sub, "first-unaligned"); KMDataNodeWriteB64(sub, &self->firstUnaligned); KMDataNodeRelease(sub); KMDataNodeOpenNodeUpdate(node, &sub, "first-half-aligned"); KMDataNodeWriteB64(sub, &self->firstHalfAligned); KMDataNodeRelease(sub); KMDataNodeRelease(node); } KMetadataRelease(meta); } } rc = TableWriter_Whack(cself->base, commit && (rc == 0), rows); KVectorRelease(cself->stats); free(self->qual_buf); free(self); } return rc; }
rc_t VTableCreateCursorWriteInt ( VTable *self, VCursor **cursp, KCreateMode mode, bool create_thread ) { rc_t rc; if ( cursp == NULL ) rc = RC ( rcVDB, rcCursor, rcCreating, rcParam, rcNull ); else { if ( self == NULL ) rc = RC ( rcVDB, rcTable, rcAccessing, rcSelf, rcNull ); else if ( self -> read_only ) rc = RC ( rcVDB, rcCursor, rcCreating, rcTable, rcReadonly ); #if VCURSOR_WRITE_MODES_SUPPORTED #error "expecting kcmInsert mode only" #else else if ( mode != kcmInsert ) rc = RC ( rcVDB, rcCursor, rcCreating, rcMode, rcUnsupported ); #endif else { VCursor *curs; #if LAZY_OPEN_COL_NODE if ( self -> col_node == NULL ) KMetadataOpenNodeUpdate ( self -> meta, & self -> col_node, "col" ); #endif rc = VCursorMake ( & curs, self ); if ( rc == 0 ) { rc = VCursorSupplementSchema ( curs ); #if VCURSOR_FLUSH_THREAD if ( rc == 0 && create_thread ) { rc = KLockMake ( & curs -> flush_lock ); if ( rc == 0 ) rc = KConditionMake ( & curs -> flush_cond ); if ( rc == 0 ) rc = KThreadMake ( & curs -> flush_thread, run_flush_thread, curs ); } if(rc == 0) rc = VCursorLaunchPagemapThread(curs); #endif if ( rc == 0 ) { * cursp = curs; return 0; } VCursorRelease ( curs ); } } * cursp = NULL; } return rc; }
static rc_t group_stats_write_table(group_stats_t const *const self, stats_data_t const *const parent) { KMDataNode *node; rc_t rc; RC_THROW(KMetadataOpenNodeUpdate(parent->meta, &node, "STATS/TABLE")); rc = parent->write(self, node); KMDataNodeRelease(node); return rc; }
static rc_t drop_all( KMetadata *dst_meta ) { KMDataNode *dst_node; rc_t rc = KMetadataOpenNodeUpdate ( dst_meta, & dst_node, NULL ); DISP_RC( rc, "drop_all:KMetadataOpenNodeUpdate() failed" ); if ( rc == 0 ) { rc = KMDataNodeDropAll ( dst_node ); DISP_RC( rc, "drop_all:KMetadataDropAll() failed" ); KMDataNodeRelease ( dst_node ); } return rc; }
LIB_EXPORT rc_t CC SRATableVOpenMDataNodeUpdate ( SRATable *self, struct KMDataNode **node, const char *spec, va_list args ) { rc_t rc; char path[4096]; int n; if (self == NULL) return RC(RC_MODULE, RC_TARGET, rcOpening, rcSelf, rcNull); if (spec == NULL) return RC(RC_MODULE, RC_TARGET, rcOpening, rcParam, rcNull); n = vsnprintf(path, sizeof(path), spec, args); if (n >= sizeof(path)) return RC(RC_MODULE, RC_TARGET, rcOpening, rcName, rcTooLong); rc = KMetadataOpenNodeUpdate(self->meta, node, "%s", path); if (rc) { SRADBG(("failed to open table metadata node '%s' %R", path, rc)); } return rc; }
LIB_EXPORT rc_t CC TableWriterAlgn_Whack(const TableWriterAlgn* cself, bool commit, uint64_t* rows) { rc_t rc = 0; if( cself != NULL ) { VTable* vtbl; TableReader_Whack(cself->tmpkey_reader); if( (rc = TableWriter_GetVTable(cself->base, &vtbl)) == 0 ) { KMetadata* meta; if( (rc = VTableOpenMetadataUpdate(vtbl, &meta)) == 0 ) { KMDataNode* node; if( (rc = KMetadataOpenNodeUpdate(meta, &node, "CONFIG/REF_TABLE")) == 0 ) { rc = KMDataNodeWriteCString(node, cself->ref_table_name); KMDataNodeRelease(node); } KMetadataRelease(meta); } } rc = TableWriter_Whack(cself->base, commit, rows); free((TableWriterAlgn*)cself); } return rc; }
static rc_t copy_stray_metadata ( const KMetadata *src_meta, KMetadata *dst_meta, const char * excluded_nodes, const bool show_meta ) { /* open root node */ const KMDataNode *src_root; rc_t rc = KMetadataOpenNodeRead ( src_meta, & src_root, NULL ); DISP_RC( rc, "copy_stray_metadata:KMetadataOpenNodeRead() failed" ); if ( rc == 0 ) { KMDataNode *dst_root; rc = KMetadataOpenNodeUpdate ( dst_meta, & dst_root, NULL ); DISP_RC( rc, "copy_stray_metadata:KMetadataOpenNodeUpdate() failed" ); if ( rc == 0 ) { /* treat the root node in a special way */ rc = copy_metadata_root ( src_root, dst_root, excluded_nodes, show_meta ); KMDataNodeRelease ( dst_root ); } KMDataNodeRelease ( src_root ); } return rc; }
/* StoreSchema */ rc_t VDatabaseStoreSchema ( VDatabase *self ) { /* open schema node */ KMDataNode *node; rc_t rc = KMetadataOpenNodeUpdate ( self -> meta, & node, "schema" ); if ( rc == 0 ) { size_t num_writ; char expr [ 256 ]; rc = VSchemaToText ( self -> schema, expr, sizeof expr - 1, & num_writ, "%N%V", self -> sdb -> name, self -> sdb -> version ); if ( rc != 0 ) LOGERR ( klogInt, rc, "failed to determine database schema" ); else { expr [ num_writ ] = 0; rc = KMDataNodeWriteAttr ( node, "name", expr ); if ( rc != 0 ) PLOGERR (klogInt, ( klogInt, rc, "failed to write database type '$(expr)'", "expr=%s", expr )); else { /* truncate existing schema */ rc = KMDataNodeWrite ( node, "", 0 ); if ( rc == 0 ) { rc = VSchemaDump ( self -> schema, sdmCompact, expr, ( rc_t ( CC * ) ( void*, const void*, size_t ) ) KMDataNodeAppend, node ); } if ( rc != 0 ) PLOGERR (klogInt, ( klogInt, rc, "failed to write database schema '$(expr)'", "expr=%s", expr )); } } KMDataNodeRelease ( node ); } return rc; }
static rc_t enter_schema_update( KMetadata *dst_meta, const bool show_meta ) { rc_t rc; KMDataNode *sw_node; if ( show_meta ) KOutMsg( "--- entering schema-update\n" ); rc = KMetadataOpenNodeUpdate ( dst_meta, &sw_node, "SOFTWARE" ); DISP_RC( rc, "enter_schema_update:KMetadataOpenNodeUpdate('SOFTWARE') failed" ); if ( rc == 0 ) { KMDataNode *update_node; rc = KMDataNodeOpenNodeUpdate ( sw_node, &update_node, "update" ); DISP_RC( rc, "enter_schema_update:KMDataNodeOpenNodeUpdate('update') failed" ); if ( rc == 0 ) { rc = enter_date_name_vers( update_node ); KMDataNodeRelease ( update_node ); } KMDataNodeRelease ( sw_node ); } return rc; }
/* StoreSchema * stores schema definition in metadata * * <schema name="">...</schema> */ LIB_EXPORT rc_t VTableStoreSchema ( VTable *self ) { /* open schema node */ KMDataNode *node; rc_t rc = KMetadataOpenNodeUpdate ( self -> meta, & node, "schema" ); if ( rc == 0 ) { size_t num_writ; char expr [ 256 ]; rc = VSchemaToText ( self -> schema, expr, sizeof expr - 1, & num_writ, "%N%V", self -> stbl -> name, self -> stbl -> version ); if ( rc != 0 ) LOGERR ( klogInt, rc, "failed to determine table schema" ); else { expr [ num_writ ] = 0; /* if table has a default view declaration, store the table information under a new attribute */ if ( self -> stbl -> dflt_view != NULL ) { uint32_t type; const SNameOverload *name; const STable *view = VSchemaFind ( self -> schema, & name, & type, self -> stbl -> dflt_view-> addr, __func__, false ); if ( view == NULL ) { rc = RC ( rcVDB, rcTable, rcUpdating, rcSchema, rcNotFound ); PLOGERR ( klogInt, ( klogInt, rc, "failed to locate default view schema '$(expr)'", "expr=%S", self -> stbl -> dflt_view )); } else { rc = KMDataNodeWriteAttr ( node, "table", expr ); if ( rc != 0 ) PLOGERR ( klogInt, ( klogInt, rc, "failed to write table type '$(expr)'", "expr=%s", expr )); else { rc = VSchemaToText ( self -> schema, expr, sizeof expr - 1, & num_writ, "%N%V", view -> name, view -> version ); if ( rc != 0 ) LOGERR ( klogInt, rc, "failed to determine table default view schema" ); else expr [ num_writ ] = 0; } } } if ( rc == 0 ) { rc = KMDataNodeWriteAttr ( node, "name", expr ); if ( rc != 0 ) PLOGERR ( klogInt, ( klogInt, rc, "failed to write table name '$(expr)'", "expr=%s", expr )); } if ( rc == 0 ) { /* truncate existing schema */ rc = KMDataNodeWrite ( node, "", 0 ); if ( rc == 0 ) { rc = VSchemaDump ( self -> schema, sdmCompact, expr, ( rc_t ( CC * ) ( void*, const void*, size_t ) ) KMDataNodeAppend, node ); } if ( rc != 0 ) PLOGERR ( klogInt, ( klogInt, rc, "failed to write table schema '$(expr)'", "expr=%s", expr )); } } KMDataNodeRelease ( node ); } return rc; }
/* OpenUpdate * finish create operation */ static rc_t VTableOpenUpdate ( VTable *self, const char *decl ) { /* open metadata */ rc_t rc = KTableOpenMetadataUpdate ( self -> ktbl, & self -> meta ); if ( rc == 0 ) { /* open "col" node */ rc = KMetadataOpenNodeUpdate ( self -> meta, & self -> col_node, "col" ); if ( rc == 0 ) { /* fetch stored schema */ rc = VTableLoadSchema ( self ); if ( rc == 0 ) { /* fetch requested schema */ const STable *stbl = self -> stbl; if ( decl != NULL && decl [ 0 ] != 0 ) { uint32_t type; const SNameOverload *name; if ( self -> db != NULL ) { const STblMember *mbr = SDatabaseFind ( self -> db -> sdb, self -> schema, & name, & type, decl, "VTableOpenUpdate" ); if ( mbr == NULL || type != eTblMember ) { PLOGMSG ( klogWarn, ( klogWarn, "expression '$(expr)' is not a table member", "expr=%s", decl )); stbl = NULL; } else { stbl = mbr -> tbl; assert ( stbl != NULL ); } } else { stbl = VSchemaFind ( self -> schema, & name, & type, decl, "VTableOpenUpdate", true ); if ( stbl != NULL && type != eTable ) { PLOGMSG ( klogWarn, ( klogWarn, "expression '$(expr)' is not a table", "expr=%s", decl )); stbl = NULL; } } } /* error if the two definitions differ */ if ( stbl != NULL && self -> stbl != NULL && stbl != self -> stbl ) rc = RC ( rcVDB, rcTable, rcOpening, rcSchema, rcIncorrect ); else if ( stbl == NULL && self -> stbl == NULL ) rc = RC ( rcVDB, rcTable, rcOpening, rcSchema, rcNotFound ); else if ( self -> stbl == NULL ) { /* write schema to metadata */ self -> stbl = stbl; rc = VTableStoreSchema ( self ); } else if ( stbl != NULL ) { /* use latest schema but don't overwrite in metadata */ self -> stbl = stbl; } } } } DBGMSG(DBG_VDB, DBG_FLAG(DBG_VDB_VDB), ("VTableOpenUpdate = %d\n", rc)); return rc; }
static rc_t DB_Fini(const SParam* p, DB_Handle* h, bool drop) { rc_t rc = 0, rc2; /* THIS FUNCTION MAKES NO ATTEMPT TO PRESERVE INITIAL ERROR CODES EACH SUCCESSIVE ERROR OVERWRITES THE PREVIOUS CODE */ if( h != NULL ) { PLOGMSG(klogInfo, (klogInfo, "Fini SEQUENCE", "severity=status")); if( (rc2 = CGWriterSeq_Whack(h->wseq, !drop, NULL)) != 0 && !drop ) { drop = true; rc = rc2; } h->wseq = NULL; h->reads = NULL; PLOGMSG(klogInfo, (klogInfo, "Fini (PRI&SEC)_ALIGNMENT", "severity=status")); if( (rc2 = CGWriterAlgn_Whack(h->walgn, !drop, NULL, NULL)) != 0 && !drop ) { drop = true; rc = rc2; } h->walgn = NULL; h->mappings = NULL; PLOGMSG(klogInfo, (klogInfo, "Fini EVIDENCE_INTERVAL", "severity=status")); if( (rc2 = CGWriterEvdInt_Whack(h->wev_int, !drop, NULL)) != 0 && !drop ) { drop = true; rc = rc2; } h->wev_int = NULL; h->ev_int = NULL; PLOGMSG(klogInfo, (klogInfo, "Fini EVIDENCE_ALIGNMENT", "severity=status")); if( (rc2 = CGWriterEvdDnbs_Whack(h->wev_dnb, !drop, NULL)) != 0 && !drop ) { drop = true; rc = rc2; } h->wev_dnb = NULL; h->ev_dnb = NULL; PLOGMSG(klogInfo, (klogInfo, "Fini calculating reference coverage", "severity=status")); if( (rc2 = ReferenceMgr_Release(h->rmgr, !drop, NULL, drop ? false : true)) != 0 && !drop ) { drop = true; rc = rc2; LOGERR(klogErr, rc, "Failed calculating reference coverage"); } h->rmgr = NULL; if( rc == 0 ) { KMetadata* meta; if( (rc = VDatabaseOpenMetadataUpdate(h->db, &meta)) == 0 ) { KMDataNode *node; if( (rc = KMetadataOpenNodeUpdate(meta, &node, "/")) == 0 ) { if( (rc = KLoaderMeta_Write(node, p->argv0, __DATE__, "Complete Genomics", KAppVersion())) != 0 ) { LOGERR(klogErr, rc, "Cannot update loader meta"); } KMDataNodeRelease(node); } KMetadataRelease(meta); } } PLOGMSG(klogInfo, (klogInfo, "Fini VDatabaseRelease", "severity=status")); VDatabaseRelease(h->db); h->db = NULL; VSchemaRelease(h->schema); h->schema = NULL; if( drop || rc != 0 ) { rc2 = VDBManagerDrop(h->mgr, kptDatabase, p->out); if( GetRCState(rc2) == rcNotFound ) { /* WHAT WOULD BE THE POINT OF RESETTING "rc" TO ZERO? */ rc = 0; } else if( rc2 != 0 ) { if ( rc == 0 ) rc = rc2; PLOGERR(klogErr, (klogErr, rc2, "cannot drop db at '$(path)'", PLOG_S(path), p->out)); } } VDBManagerRelease(h->mgr); h->mgr = NULL; } return rc; }
static rc_t CC sra_meta_stats_update(sra_meta_stats_data* self, const int64_t spot_id, const uint32_t spot_len, const uint32_t bio_spot_len, const uint32_t cmp_spot_len, bool has_grp, const char* grp, uint64_t grp_len) { rc_t rc = 0; const uint32_t max_grp_qty = 10000; assert(self != NULL); rc = sra_meta_stats_node_group_update(&self->table, spot_id, spot_len, bio_spot_len, cmp_spot_len); if( has_grp && self->grp_qty <= max_grp_qty && rc == 0 ) { /* an empty group is considered default */ if( grp_len == 0 || grp == NULL || grp[0] == '\0' || (grp_len == 7 && strncasecmp("default", grp, grp_len) == 0 ) ) { rc = sra_meta_stats_node_group_update(&self->dflt_grp, spot_id, spot_len, bio_spot_len, cmp_spot_len); } else { size_t i; KMDataNode* n; const KMDataNode *cn; bool new_group, unsafe; /* look for cached node */ if ( self->last_grp_name != NULL && self->last_grp_name_len == grp_len && strncmp(self->last_grp_name, grp, grp_len) == 0 ) { return sra_meta_stats_node_group_update(&self->last_grp, spot_id, spot_len, bio_spot_len, cmp_spot_len); } /* release cached group */ sra_meta_stats_node_group_release(&self->last_grp); /* realloc cached name */ if ( self->last_grp_name == NULL || grp_len >= self->last_grp_name_sz ) { char *p = realloc ( self -> last_grp_name, grp_len + 1 ); if ( p == NULL ) return RC ( rcXF, rcFunction, rcExecuting, rcMemory, rcExhausted ); self -> last_grp_name = p; self -> last_grp_name_sz = grp_len + 1; } /* sanitize name */ for ( unsafe = false, i = 0; i < grp_len; ++ i ) { if ( ( self -> last_grp_name [ i ] = grp [ i ] ) == '/' ) { unsafe = true; self -> last_grp_name [ i ] = '\\'; } } self -> last_grp_name_len = i; self -> last_grp_name [ i ] = 0; /* look for new group */ new_group = true; rc = KMetadataOpenNodeRead(self->meta, &cn, "STATS/SPOT_GROUP/%s", self->last_grp_name ); if ( rc == 0 ) { new_group = false; KMDataNodeRelease ( cn ); } /* detect abusive quantity of nodes */ if ( new_group && ++self->grp_qty > max_grp_qty ) { rc = KMetadataOpenNodeUpdate(self->meta, &n, "STATS"); if( rc == 0 ) { sra_meta_stats_node_group_release(&self->dflt_grp); KMDataNodeDropChild(n, "SPOT_GROUP"); KMDataNodeRelease(n); free(self->last_grp_name); self->last_grp_name = NULL; } return rc; } /* create new or cache existing group */ rc = KMetadataOpenNodeUpdate(self->meta, &n, "STATS/SPOT_GROUP/%s", self->last_grp_name ); if ( rc == 0 ) { rc = sra_meta_stats_node_group_open(n, &self->last_grp, self->compressed); if (rc == 0 && new_group) { if (unsafe) { char value [ 512 ], *v = value; if ( grp_len >= sizeof value ) v = malloc ( grp_len + 1 ); if ( v == NULL ) rc = RC ( rcXF, rcFunction, rcExecuting, rcMemory, rcExhausted ); else { rc = string_printf ( v, grp_len + 1, NULL, "%.*s", ( uint32_t ) grp_len, grp ); assert ( rc == 0 ); rc = KMDataNodeWriteAttr(n, "name", v); if ( rc == 0 ) memcpy ( self->last_grp_name, grp, grp_len ); if ( v != value ) free ( v ); } } if ( rc == 0 ) rc = sra_meta_stats_node_group_update(&self->last_grp, 0, 0, 0, 0); } KMDataNodeRelease(n); if( rc == 0 ) rc = sra_meta_stats_node_group_update(&self->last_grp, spot_id, spot_len, bio_spot_len, cmp_spot_len); } } } return rc; }
static rc_t MakeIndexes(const SRATable* stbl, KTable* ktbl, KMetadata* meta) { rc_t rc = 0; int i; char* buffer = NULL; size_t buffer_sz = g_file_block_sz * 100; SIndexObj idx[] = { /* meta, file, format, index, func, file_size, buffer_sz, minSpotId, maxSpotId */ {NULL, "fastq", "fastq", "fuse-fastq", Fastq_Idx, 0, 0, 0, 0}, {NULL, "sff", "SFF", "fuse-sff", SFF_Idx, 0, 0, 0, 0}, {NULL, "fastq.gz", "fastq-gzip", "fuse-fastq-gz", FastqGzip_Idx, 0, 0, 0, 0}, {NULL, "sff.gz", "SFF-gzip", "fuse-sff-gz", SFFGzip_Idx, 0, 0, 0, 0} }; for(i = 0; rc == 0 && i < sizeof(idx) / sizeof(idx[0]); i++) { KMDataNode* parent = NULL; if( (rc = KMetadataOpenNodeUpdate(meta, &parent, "/FUSE")) == 0 ) { KMDataNodeDropChild(parent, "root"); /* drop old stuff */ if( g_ungzip || strcmp(&idx[i].file[strlen(idx[i].file) - 3], ".gz") == 0 ) { STSMSG(0, ("Preparing index %s", idx[i].index)); MD5StateInit(&idx[i].md5); SLListInit(&idx[i].li); KMDataNodeDropChild(parent, "%s.tmp", idx[i].file); if( (rc = KMDataNodeOpenNodeUpdate(parent, &idx[i].meta, "%s.tmp", idx[i].file)) == 0 ) { if( idx[i].func != NULL ) { if( buffer == NULL ) { if( (buffer = malloc(buffer_sz)) == NULL ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcExhausted); break; } } rc = idx[i].func(stbl, &idx[i], buffer, buffer_sz); if( rc == 0 ) { MD5StateFinish(&idx[i].md5, idx[i].md5_digest); rc = CommitIndex(ktbl, idx[i].index, &idx[i].li); } } if( rc == 0 ) { rc = WriteFileMeta(&idx[i]); } KMDataNodeRelease(idx[i].meta); } if( GetRCState(rc) == rcUnsupported ) { KMDataNodeDropChild(parent, "%s", idx[i].file); PLOGERR(klogWarn, (klogWarn, rc, "Index $(i) is not supported for this table", PLOG_S(i), idx[i].index)); rc = 0; } else if( rc == 0 ) { char f[4096]; strcpy(f, idx[i].file); strcat(f, ".tmp"); KMDataNodeDropChild(parent, "%s", idx[i].file); rc = KMDataNodeRenameChild(parent, f, idx[i].file); } } else if( !g_ungzip ) { KTableDropIndex(ktbl, idx[i].index); KMDataNodeDropChild(parent, "%s", idx[i].file); } KMDataNodeDropChild(parent, "%s.tmp", idx[i].file); KMDataNodeRelease(parent); } SLListWhack(&idx[i].li, WhackIndexData, NULL); } free(buffer); return rc; }