FIXTURE_TEST_CASE(TestManyNoDep, EmptyFixture) {
rc_t rc = 0;
const char SRR543323[] = "SRR543323";
VPath* acc = NULL;
REQUIRE_RC(VFSManagerMakePath(vmgr, &acc, SRR543323));
const VPath *local = NULL;
REQUIRE_RC_FAIL(VResolverLocal(resolver, acc, &local));
RELEASE(VPath, acc);
struct VSchema *schema;
REQUIRE_RC(VDBManagerMakeSRASchema(mgr, &schema));
const VDatabase *db = NULL;
REQUIRE_RC(VDBManagerOpenDBRead(mgr, &db, schema, SRR543323));
REQUIRE_RC(VSchemaRelease(schema));
const VDBDependencies *dep = NULL;
// missing
REQUIRE_RC(VDatabaseListDependencies(db, &dep, true));
uint32_t count = 1;
REQUIRE_RC(VDBDependenciesCount(dep, &count));
CHECK_EQUAL(count, (uint32_t)21);
RELEASE(VDBDependencies, dep);
REQUIRE_RC(VDatabaseListDependencies(db, &dep, false));
REQUIRE_RC(VDBDependenciesCount(dep, &count));
CHECK_EQUAL(count, (uint32_t)21);
RELEASE(VDBDependencies, dep);
RELEASE(VDatabase, db);
RELEASE(VPath, local);
}
static rc_t ref_walker_init( struct ref_walker * self )
{
rc_t rc = KDirectoryNativeDir( &self->dir );
if ( rc == 0 )
rc = VDBManagerMakeRead ( &self->vmgr, self->dir );
if ( rc == 0 )
rc = VDBManagerMakeSRASchema( self->vmgr, &self->vschema );
if ( rc == 0 )
rc = AlignMgrMakeRead ( &self->amgr );
if ( rc == 0 )
rc = VFSManagerMake ( &self->vfs_mgr );
if ( rc == 0 )
rc = VNamelistMake ( &self->sources, 10 );
self->cb_block.data = self;
self->cb_block.destroy = NULL;
self->cb_block.populate = populate_data;
self->cb_block.alloc_size = alloc_size;
self->cb_block.fixed_size = 0;
BSTreeInit( &self->regions );
self->primary_alignments = true;
if ( rc != 0 )
ref_walker_release( self );
return rc;
}
static rc_t pacbio_load_schema( ld_context *lctx, const char *schema_name )
{
rc_t rc;
if ( pacbio_is_schema_dflt( schema_name ) )
{
rc = VDBManagerMakeSRASchema ( lctx->vdb_mgr, &lctx->schema );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot create sra-schema" );
if ( rc == 0 )
{
rc = VSchemaParseFile ( lctx->schema, schema_name );
if ( rc != 0 )
PLOGERR( klogErr, ( klogErr, rc, "cannot to parse schema file '$(schema)'",
"schema=%s", schema_name ) );
}
}
else
{
rc = VDBManagerMakeSchema ( lctx->vdb_mgr, &lctx->schema );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot create sra-schema" );
else
{
char path[ 4096 ];
rc = pacbio_extract_path( lctx->wd, schema_name, path, sizeof path );
if ( rc == 0 )
{
rc = VSchemaAddIncludePath ( lctx->schema, path );
if ( rc != 0 )
PLOGERR( klogErr, ( klogErr, rc, "cannot add schema-include-path '$(path)'",
"path=%s", path ) );
else
{
rc = VSchemaParseFile ( lctx->schema, schema_name );
if ( rc != 0 )
PLOGERR( klogErr, ( klogErr, rc, "cannot to parse schema file '$(schema)'",
"schema=%s", schema_name ) );
}
}
}
}
return rc;
}
rc_t SRAMgrMake ( SRAMgr **mgrp,
const VDBManager *vmgr, const KDirectory *wd )
{
rc_t rc;
/* require sraschema object */
SRAMgr *mgr = malloc ( sizeof * mgr );
if ( mgr == NULL )
rc = RC ( rcSRA, rcMgr, rcConstructing, rcMemory, rcExhausted );
else
{
VSchema *schema;
rc = VDBManagerMakeSRASchema ( vmgr, & schema );
if ( rc == 0 )
{
rc = SRAMgrInitPath ( mgr, wd );
if ( rc == 0 )
{
KRefcountInit ( & mgr -> refcount, 1, "SRAMgr", "SRAMgrMake", "sramgr" );
mgr -> vmgr = vmgr;
mgr -> schema = schema;
mgr -> mode = kcmCreate; /* TBD - should this include parents? */
mgr -> read_only = true;
* mgrp = mgr;
return 0;
}
VSchemaRelease ( schema );
}
free ( mgr );
}
* mgrp = NULL;
return rc;
}
static rc_t align_info(const Params* prm) {
rc_t rc = 0;
const VDatabase* db = NULL;
const VDBManager* mgr = NULL;
const KDBManager *kmgr = NULL;
VSchema* schema = NULL;
bool is_db = false;
if (prm == NULL)
{ return RC(rcExe, rcQuery, rcExecuting, rcParam, rcNull); }
if (rc == 0) {
rc = VDBManagerMakeRead(&mgr, NULL);
DISP_RC(rc, "while calling VDBManagerMakeRead");
}
if (rc == 0) {
rc = VDBManagerOpenKDBManagerRead(mgr, &kmgr);
DISP_RC(rc, "while calling VDBManagerOpenKDBManagerRead");
}
if (rc == 0) {
rc = VDBManagerMakeSRASchema(mgr, &schema);
DISP_RC(rc, "while calling VDBManagerMakeSRASchema");
}
if (rc == 0) {
/* const char path[] = "/panfs/pan1/trace_work/scratch/XXX000013"; */
rc = VDBManagerOpenDBRead(mgr, &db, schema, prm->dbPath);
if (rc == 0) {
is_db = true;
}
else if (rc == SILENT_RC(rcDB, rcMgr, rcOpening, rcDatabase, rcIncorrect)) {
PLOGMSG(klogWarn, (klogWarn,
"'$(path)' is not a database", "path=%s", prm->dbPath));
rc = 0;
}
else {
PLOGERR(klogErr,
(klogErr, rc, "$(path)", "path=%s", prm->dbPath));
}
}
if (is_db) {
if (rc == 0) {
if (prm->paramRef) {
const VDBDependencies* dep = NULL;
uint32_t count = 0;
int i = 0;
rc = VDatabaseListDependencies(db, &dep, false);
DISP_RC2(rc, prm->dbPath,
"while calling VDatabaseListDependencies");
if (rc == 0) {
rc = VDBDependenciesCount(dep, &count);
DISP_RC2(rc, prm->dbPath,
"while calling VDBDependenciesCount");
}
for (i = 0; i < count && rc == 0; ++i) {
bool circular = false;
const char* name = NULL;
const char* path = NULL;
const char* remote = NULL;
bool local = false;
const char* seqId = NULL;
rc = VDBDependenciesCircular(dep, &circular, i);
if (rc != 0) {
DISP_RC2(rc, prm->dbPath,
"while calling VDBDependenciesCircular");
break;
}
rc = VDBDependenciesName(dep, &name, i);
if (rc != 0) {
DISP_RC2(rc, prm->dbPath,
"while calling VDBDependenciesName");
break;
}
rc = VDBDependenciesPath(dep, &path, i);
if (rc != 0) {
DISP_RC2(rc, prm->dbPath,
"while calling VDBDependenciesPath");
break;
}
rc = VDBDependenciesLocal(dep, &local, i);
if (rc != 0) {
DISP_RC2(rc, prm->dbPath,
"while calling VDBDependenciesLocal");
break;
}
rc = VDBDependenciesSeqId(dep, &seqId, i);
if (rc != 0) {
DISP_RC2(rc, prm->dbPath,
"while calling VDBDependenciesSeqId");
break;
}
rc = VDBDependenciesPathRemote(dep, &remote, i);
if (rc != 0) {
DISP_RC2(rc, prm->dbPath,
"while calling VDBDependenciesRemote");
break;
}
OUTMSG(("%s,%s,%s,%s", seqId, name,
(circular ? "true" : "false"),
(local ? "local" : "remote")));
if (path && path[0]) {
OUTMSG((":%s", path));
}
else if (remote && remote[0]) {
OUTMSG(("::%s", remote));
}
OUTMSG(("\n"));
}
DESTRUCT(VDBDependencies, dep);
}
if (prm->paramBamHeader) {
rc_t rc3 = bam_header(db);
if (rc3 != 0 && rc == 0)
{ rc = rc3; }
}
if (prm->paramQuality) {
rc_t rc3 = qual_stats(prm, db);
if (rc3 != 0 && rc == 0)
{ rc = rc3; }
}
}
}
DESTRUCT(VSchema, schema);
DESTRUCT(KDBManager, kmgr);
DESTRUCT(VDBManager, mgr);
DESTRUCT(VDatabase, db);
return rc;
}
/* OpenRead
* open an existing table
*
* "tbl" [ OUT ] - return parameter for table
*
* "spec" [ IN ] - NUL terminated UTF-8 string giving path
* to table.
*/
static
rc_t CC SRAMgrVOpenAltTableRead ( const SRAMgr *self,
const SRATable **rslt, const char *altname, const char *spec, va_list args )
{
rc_t rc;
if ( rslt == NULL )
rc = RC ( rcSRA, rcTable, rcOpening, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcSRA, rcMgr, rcAccessing, rcSelf, rcNull );
else if ( spec == NULL )
rc = RC ( rcSRA, rcTable, rcOpening, rcName, rcNull );
else if ( spec [ 0 ] == 0 )
rc = RC ( rcSRA, rcTable, rcOpening, rcName, rcEmpty );
else
{
char path [ 4096 ];
rc = ResolveTablePath ( self, path, sizeof path, spec, args );
if ( rc == 0 )
{
SRATable *tbl = calloc ( 1, sizeof *tbl );
if ( tbl == NULL )
rc = RC ( rcSRA, rcTable, rcConstructing, rcMemory, rcExhausted );
else
{
VSchema *schema = NULL;
rc = VDBManagerMakeSRASchema(self -> vmgr, & schema);
if ( rc == 0 )
{
rc = VDBManagerOpenTableRead ( self -> vmgr, & tbl -> vtbl, schema, path );
if ( rc != 0 && GetRCObject ( rc ) == rcTable && GetRCState ( rc ) == rcIncorrect )
{
const VDatabase *db;
rc_t rc2 = VDBManagerOpenDBRead ( self -> vmgr, & db, schema, path );
if ( rc2 == 0 )
{
rc2 = VDatabaseOpenTableRead ( db, & tbl -> vtbl, altname );
if ( rc2 == 0 )
rc = 0;
VDatabaseRelease ( db );
}
}
VSchemaRelease(schema);
if ( rc == 0 )
{
rc = VTableOpenMetadataRead ( tbl -> vtbl, & tbl -> meta );
if ( rc == 0 )
{
rc = KMetadataVersion ( tbl -> meta, & tbl -> metavers );
if ( rc == 0 )
{
rc = VTableCreateCursorRead ( tbl -> vtbl, & tbl -> curs );
if ( rc == 0 )
{
tbl -> mgr = SRAMgrAttach ( self );
tbl -> mode = self -> mode;
tbl -> read_only = true;
KRefcountInit ( & tbl -> refcount, 1, "SRATable", "OpenTableRead", path );
rc = SRATableFillOut ( tbl, false );
if ( rc == 0 )
{
* rslt = tbl;
return 0;
}
}
}
}
}
}
SRATableWhack ( tbl );
}
}
}
* rslt = NULL;
}
return rc;
}
