static bool map_typename ( const ctx_t *ctx, const char *sub_node, const char *in, char *out, char *schema_src, size_t size ) { FUNC_ENTRY ( ctx ); rc_t rc; const KConfigNode *n; size_t num_read, remaining; typename_to_config_path ( in, out ); rc = KConfigOpenNodeRead ( ctx -> caps -> cfg, & n, "sra-sort/%s/%s", sub_node, out ); if ( rc != 0 ) return map_typename_builtin ( ctx, sub_node, in, out, schema_src, size ); rc = KConfigNodeRead ( n, 0, out, size - 1, & num_read, & remaining ); if ( rc != 0 ) ERROR ( rc, "KConfigNodeRead failed" ); else if ( remaining != 0 ) { rc = RC ( rcExe, rcNode, rcReading, rcBuffer, rcInsufficient ); ERROR ( rc, "type map of '%s' is too long", in ); } else { out [ num_read ] = 0; typename_to_config_path ( out, schema_src ); KConfigNodeRelease ( n ); rc = KConfigOpenNodeRead ( ctx -> caps -> cfg, & n, "sra-sort/schema-src/%s", schema_src ); if ( rc != 0 ) ERROR ( rc, "KConfigOpenNodeRead - failed to find entry 'sra-sort/schema-src/%s'", schema_src ); else { rc = KConfigNodeRead ( n, 0, schema_src, size - 1, & num_read, & remaining ); if ( rc != 0 ) ERROR ( rc, "KConfigNodeRead failed" ); else if ( remaining != 0 ) { rc = RC ( rcExe, rcNode, rcReading, rcBuffer, rcInsufficient ); ERROR ( rc, "type map of '%s' is too long", in ); } else { schema_src [ num_read ] = 0; } } } KConfigNodeRelease ( n ); return true; }
/* RemoteRepositories * retrieve all remote repositories in a Vector */ LIB_EXPORT rc_t CC KRepositoryMgrRemoteRepositories ( const KRepositoryMgr *self, KRepositoryVector *remote_repositories ) { rc_t rc; if ( remote_repositories == NULL ) rc = RC ( rcKFG, rcMgr, rcAccessing, rcParam, rcNull ); else { VectorInit ( remote_repositories, 0, 8 ); if ( self == NULL ) rc = RC ( rcKFG, rcMgr, rcAccessing, rcSelf, rcNull ); else { const KConfig *kfg = KRepositoryMgrGetROKConfig ( self ); const KConfigNode *remote; rc = KConfigOpenNodeRead ( kfg, & remote, "/repository/remote" ); if ( rc == 0 ) { rc = KRepositoryMgrCategoryRepositories ( remote, krepRemoteCategory, remote_repositories ); KConfigNodeRelease ( remote ); if ( rc == 0 ) VectorReorder ( remote_repositories, KRepositorySort, NULL ); } if ( rc != 0 ) KRepositoryVectorWhack ( remote_repositories ); } } return rc; }
/* Config * configure an existing path manager */ static rc_t SRAPathConfigValue ( const KConfig *kfg, const char *node_path, char *value, size_t value_size, const char *dflt ) { const KConfigNode *node; rc_t rc = KConfigOpenNodeRead ( kfg, & node, node_path ); if ( rc == 0 ) { size_t num_read, remaining; rc = KConfigNodeRead ( node, 0, value, value_size - 1, & num_read, & remaining ); if ( rc == 0 ) { if ( remaining != 0 ) rc = RC ( rcSRA, rcMgr, rcConstructing, rcString, rcExcessive ); else value [ num_read ] = 0; } KConfigNodeRelease ( node ); } if ( rc != 0 ) { if ( dflt != NULL && dflt [ 0 ] != 0 ) { size_t num_read = string_copy_measure ( value, value_size, dflt ); rc = 0; if ( num_read == value_size ) rc = RC ( rcSRA, rcMgr, rcConstructing, rcString, rcExcessive ); } else value[0] = 0; } return rc; }
/* UserRepositories * retrieve all user repositories in a Vector */ LIB_EXPORT rc_t CC KRepositoryMgrUserRepositories ( const KRepositoryMgr *self, KRepositoryVector *user_repositories ) { rc_t rc; if ( user_repositories == NULL ) rc = RC ( rcKFG, rcMgr, rcAccessing, rcParam, rcNull ); else { VectorInit ( user_repositories, 0, 8 ); if ( self == NULL ) rc = RC ( rcKFG, rcMgr, rcAccessing, rcSelf, rcNull ); else { const KConfig *kfg = KRepositoryMgrGetROKConfig ( self ); const KConfigNode *user; rc = KConfigOpenNodeRead ( kfg, & user, "/repository/user" ); if ( rc == 0 ) { rc = KRepositoryMgrCategoryRepositories ( user, krepUserCategory, user_repositories ); KConfigNodeRelease ( user ); if ( rc == 0 ) VectorReorder ( user_repositories, KRepositorySort, NULL ); } if ( rc != 0 ) KRepositoryVectorWhack ( user_repositories ); } } return rc; }
static bool KNSProxiesHttpProxyInitFromKfg ( KNSProxies * self, const KConfig * kfg ) { bool fromKfg = false; const KConfigNode * proxy; rc_t rc = KConfigOpenNodeRead ( kfg, & proxy, "/http/proxy" ); if ( rc == 0 ) { const KConfigNode * proxy_path; rc = KConfigNodeOpenNodeRead ( proxy, & proxy_path, "path" ); if ( rc == 0 ) { String * path; rc = KConfigNodeReadString ( proxy_path, & path ); if ( rc == 0 ) { DBGMSG ( DBG_KNS, DBG_FLAG ( DBG_KNS_PROXY ), ( "Loading proxy '%S' from configuration\n", path ) ); rc = KNSProxiesAddHTTPProxyPath ( self, "%S", path ); if ( rc == 0 ) fromKfg = true; StringWhack ( path ); } KConfigNodeRelease ( proxy_path ); } KConfigNodeRelease ( proxy ); } return fromKfg; }
static rc_t ConfigRepoSet(DLList* repos, KConfig * kfg, const char* kfgPath, const char *dflt, uint8_t type) { const KConfigNode *node; rc_t rc = KConfigOpenNodeRead ( kfg, & node, kfgPath ); if ( rc == 0 ) { KNamelist* children; rc = KConfigNodeListChild ( node, &children ); if ( rc == 0 ) { uint32_t count; rc = KNamelistCount ( children, &count ); if ( rc == 0 ) { uint32_t i; for (i = 0; i < count; ++i) { const char* name; rc = KNamelistGet ( children, i, &name ); if ( rc == 0 ) { #define BufSize 4096 char buf[ BufSize ]; size_t bSize = string_size(kfgPath); string_copy(buf, BufSize, kfgPath, bSize); if (bSize + string_size(name) < sizeof(buf)) { NCBIRepository* repo; string_copy(buf + bSize, sizeof(buf) - bSize, name, string_size(name) + 1); rc = ConfigRepo( kfg, dflt, buf, buf, type, &repo ); DLListPushTail( repos, (DLNode*) repo ); } #undef BufSize } else { rc = RC ( rcSRA, rcMgr, rcConstructing, rcString, rcExcessive ); } if ( rc != 0 ) { break; } } } KNamelistRelease ( children ); } KConfigNodeRelease ( node ); } if (GetRCState(rc) == rcNotFound) { return 0; } return rc; }
static void KNSManagerHttpProxyInit ( KNSManager * self ) { const KConfigNode * proxy; rc_t rc = KConfigOpenNodeRead ( self -> kfg, & proxy, "http/proxy" ); if ( rc == 0 ) { const KConfigNode * proxy_path; rc = KConfigNodeOpenNodeRead ( proxy, & proxy_path, "path" ); if ( rc == 0 ) { String * path; rc = KConfigNodeReadString ( proxy_path, & path ); if ( rc == 0 ) { rc = KNSManagerSetHTTPProxyPath ( self, "%S", path ); if ( rc == 0 ) { const KConfigNode * proxy_enabled; rc = KConfigNodeOpenNodeRead ( proxy, & proxy_enabled, "enabled" ); if ( rc == 0 ) { rc = KConfigNodeReadBool ( proxy_enabled, & self -> http_proxy_enabled ); KConfigNodeRelease ( proxy_enabled ); } else if ( GetRCState ( rc ) == rcNotFound ) { rc = 0; } if ( rc != 0 ) { KNSManagerSetHTTPProxyPath ( self, NULL ); assert ( self -> http_proxy_enabled == false ); } } StringWhack ( path ); } KConfigNodeRelease ( proxy_path ); } KConfigNodeRelease ( proxy ); } }
static uint64_t KConfigGetNodeU64 ( const ctx_t *ctx, const char *path, bool *found ) { rc_t rc; uint64_t val = 0; const KConfigNode *n; bool dummy; if ( found == NULL ) found = & dummy; rc = KConfigOpenNodeRead ( ctx -> caps -> cfg, & n, "sra-sort/map_file_bsize" ); if ( rc == 0 ) { char buff [ 256 ]; size_t num_read, remaining; rc = KConfigNodeRead ( n, 0, buff, sizeof buff - 1, & num_read, & remaining ); if ( rc != 0 ) ERROR ( rc, "failed to read KConfig node '%s'", path ); else if ( remaining != 0 ) { rc = RC ( rcExe, rcNode, rcReading, rcBuffer, rcInsufficient ); ERROR ( rc, "failed to read KConfig node '%s'", path ); } else { char *end; buff [ num_read ] = 0; val = strtou64 ( buff, & end, 0 ); if ( end [ 0 ] != 0 ) { rc = RC ( rcExe, rcNode, rcReading, rcNumeral, rcIncorrect ); ERROR ( rc, "bad '%s' config value: '%s'", path, buff ); } } KConfigNodeRelease ( n ); } return val; }
static rc_t check_if_schema_exists( KDirectory * dir, const char * schema_name ) { KConfig * cfg; rc_t rc = KConfigMake ( &cfg, NULL ); if ( rc != 0 ) { LOGERR( klogErr, rc, "check_if_schema_exists:KConfigMake() failed" ); } else { const KConfigNode *node; rc = KConfigOpenNodeRead ( cfg, &node, "vdb/schema/paths" ); if ( rc != 0 ) { LOGERR( klogErr, rc, "check_if_schema_exists:KConfigOpenNodeRead( 'vdb/schema/paths' ) failed" ); } else { char buffer[ 1024 ]; size_t num_read; rc = KConfigNodeRead ( node, 0, buffer, sizeof buffer, &num_read, NULL ); if ( rc != 0 ) { LOGERR( klogErr, rc, "check_if_schema_exists:KConfigNodeRead() failed" ); } else { uint32_t path_type; buffer[ num_read ] = 0; path_type = KDirectoryPathType ( dir, "%s/%s", buffer, schema_name ); if ( ( path_type & kptFile ) == 0 ) { rc = RC( rcExe, rcFile, rcConstructing, rcParam, rcInvalid ); } } KConfigNodeRelease ( node ); } KConfigRelease ( cfg ); } return rc; }
static rc_t RefSeqMgr_ConfigValue ( const KConfig *kfg, const char *node_path, char *value, size_t value_size ) { const KConfigNode *node; rc_t rc = KConfigOpenNodeRead ( kfg, & node, "%s", node_path ); if ( rc == 0 ) { size_t num_read, remaining; rc = KConfigNodeRead ( node, 0, value, value_size - 1, & num_read, & remaining ); if ( rc == 0 ) { if ( remaining != 0 ) rc = RC ( rcSRA, rcMgr, rcConstructing, rcString, rcExcessive ); else value [ num_read ] = 0; } KConfigNodeRelease ( node ); } return rc; }
static void check_env ( const KConfig *self, char *path, size_t path_size ) { size_t num_read; const char *home; const KConfigNode *home_node; /* Check to see if home node exists */ rc_t rc = KConfigOpenNodeRead ( self, &home_node, "HOME" ); if ( home_node == NULL ) { /* just grab the HOME env variable */ home = getenv ( "HOME" ); if ( home != NULL ) { num_read = string_copy_measure ( path, path_size, home ); if ( num_read >= path_size ) path [ 0 ] = 0; } } else { /* if it exists check for a path */ rc = KConfigNodeRead ( home_node, 0, path, path_size, &num_read, NULL ); if ( rc != 0 ) { home = getenv ( "HOME" ); if ( home != NULL ) { num_read = string_copy_measure ( path, path_size, home ); if ( num_read >= path_size ) path [ 0 ] = 0; } } rc = KConfigNodeRelease ( home_node ); } }
static rc_t RefSeqMgr_KfgReadStr(const KConfig* kfg, const char* path, char* value, size_t value_sz) { rc_t rc = 0; const KConfigNode *node; if ( (rc = KConfigOpenNodeRead(kfg, &node, "%s", path)) == 0 ) { size_t num_read, remaining; if( (rc = KConfigNodeRead(node, 0, value, value_sz - 1, &num_read, &remaining)) == 0 ) { if( remaining != 0 ) { rc = RC(rcAlign, rcIndex, rcConstructing, rcString, rcTooLong); } else { value[num_read] = '\0'; } } KConfigNodeRelease(node); } else if( GetRCState(rc) == rcNotFound ) { rc = 0; value[0] = '\0'; } return rc; }
static rc_t ShowConfig(const KConfig* cfg, Params* prm) { rc_t rc = 0; bool hasAny = false; bool hasQuery = false; bool xml = true; assert(cfg && prm); xml = prm->xml; while (rc == 0) { KNamelist* names = NULL; const KConfigNode* node = NULL; uint32_t count = 0; uint32_t i = 0; int indent = 0; const char* root = NULL; const char* nodeName = NULL; size_t nodeNameL = 1; rc = ParamsGetNextParam(prm, &root); if (rc == 0) { if (root == NULL) { if (hasQuery) { break; } else { root = "/"; } } else { hasQuery = true; } assert(root); } if (rc == 0) { int64_t len = strlen(root); assert(len > 0); while (len > 0) { if (root[len - 1] == '/') { --len; } else { break; } } assert(len >= 0); if (len == 0) { root += strlen(root) - 1; nodeName = root; } else { char *c = memrchr(root, '/', len); if (c != NULL) { nodeName = c + 1; } else { nodeName = root; } } assert(nodeName && nodeName[0]); nodeNameL = strlen(nodeName); while (nodeNameL > 1 && nodeName[nodeNameL - 1] == '/') { --nodeNameL; } } if (rc == 0) { rc = KConfigOpenNodeRead(cfg, &node, root); DISP_RC(rc, root); } if (rc == 0) { rc = KConfigNodeListChild(node, &names); } if (rc == 0) { rc = KNamelistCount(names, &count); } if (rc == 0 && count == 0) { char buf[512] = ""; size_t num_read = 0; rc = KConfigNodeReadData(node, buf, sizeof buf, &num_read); if (rc == 0 && num_read > 0) { if (prm->showMultiple) { OUTMSG(("<!-- Configuration node %s -->\n", root)); } if (xml) { VDB_CONGIG_OUTMSG(("<%.*s>", nodeNameL, nodeName)); VDB_CONGIG_OUTMSG(("%.*s", (int)num_read, buf)); VDB_CONGIG_OUTMSG(("</%.*s>\n", nodeNameL, nodeName)); } else { OUTMSG(("%.*s = \"%.*s\"\n", nodeNameL, nodeName, (int)num_read, buf)); } hasAny = true; } } else { if (rc == 0) { if (nodeName[0] != '/') { if (prm->showMultiple) { OUTMSG(("<!-- Configuration node %s -->\n", root)); } VDB_CONGIG_OUTMSG(("<%.*s>\n", nodeNameL, nodeName)); } else { if (prm->showMultiple) { OUTMSG(("<!-- Current configuration -->\n")); } VDB_CONGIG_OUTMSG(("<Config>\n")); } hasAny = true; ++indent; } for (i = 0; i < count && rc == 0; ++i) { const char* name = NULL; if (rc == 0) { rc = KNamelistGet(names, i, &name); } if (rc == 0) { char* fullname = NULL; if (strcmp(root, "/") == 0) { fullname = malloc(strlen(name) + 2); if (fullname == NULL) { rc = RC(rcExe, rcStorage, rcAllocating, rcMemory, rcExhausted); } sprintf(fullname, "/%s", name); } else { fullname = strdup(root); if (fullname == NULL) { rc = RC(rcExe, rcStorage, rcAllocating, rcMemory, rcExhausted); } } if (rc == 0) { rc = KConfigNodePrintChildNames (xml, node, name, indent, fullname); hasAny = true; } free(fullname); fullname = NULL; } } if (rc == 0) { if (nodeName[0] != '/') { VDB_CONGIG_OUTMSG(("</%.*s>\n", nodeNameL, nodeName)); } else { VDB_CONGIG_OUTMSG(("</Config>\n")); } } } RELEASE(KConfigNode, node); RELEASE(KNamelist, names); if (rc == 0) { if (hasAny) { OUTMSG(("\n")); } else if (nodeNameL > 0 && nodeName != NULL) { VDB_CONGIG_OUTMSG(("<%.*s/>\n", nodeNameL, nodeName)); } } if (!hasQuery) { break; } } return rc; }
static rc_t ShowModules(const KConfig* cfg, const Params* prm) { rc_t rc = 0; #ifdef _STATIC OUTMSG(("<!-- Modules are not used in static build -->\n")); #else const VDBManager* mgr = NULL; KNamelist* list = NULL; OUTMSG(("<!-- Modules -->\n")); rc = VDBManagerMakeRead(&mgr, NULL); DISP_RC(rc, "while calling VDBManagerMakeRead"); if (rc == 0) { rc = VDBManagerListExternalSchemaModules(mgr, &list); DISP_RC(rc, "while calling VDBManagerListExternalSchemaModules"); } if (rc == 0) { uint32_t count = 0; rc = KNamelistCount(list, &count); DISP_RC(rc, "while calling KNamelistCount " "on VDBManagerListExternalSchemaModules result"); if (rc == 0) { int64_t i = 0; for (i = 0; i < count && rc == 0; ++i) { const char* name = NULL; rc = KNamelistGet(list, i, &name); DISP_RC(rc, "while calling KNamelistGet " "on VDBManagerListExternalSchemaModules result"); if (rc == 0) { OUTMSG(("%s\n", name)); } } } } OUTMSG(("\n")); RELEASE(KNamelist, list); RELEASE(VDBManager, mgr); #endif #if 0 KDirectory* dir = NULL; const char* paths[] = { "vdb/module/paths", "vdb/wmodule/paths" }; int i = 0; assert(cfg); for (i = 0; i < sizeof paths / sizeof paths[0] && rc == 0; ++i) { const KConfigNode* node = NULL; if (rc == 0) { const char* path = paths[i]; rc = KConfigOpenNodeRead(cfg, &node, path); if (rc != 0) { if (GetRCState(rc) == rcNotFound) { rc = 0; continue; } else { DISP_RC(rc, path); } } else { char buf[PATH_MAX + 1]; size_t num_read = 0; size_t remaining = 0; rc = KConfigNodeRead(node, 0, buf, sizeof buf, &num_read, &remaining); assert(remaining == 0); assert(num_read <= sizeof buf); DISP_RC(rc, path); if (rc == 0) { if (num_read < sizeof buf) { buf[num_read] = '\0'; if (dir == NULL) { rc = KDirectoryNativeDir(&dir); } if (rc == 0) { OUTMSG(("%s = %s\n", path, buf)); rc = ShowModDir(dir, buf); if (rc == 0) { OUTMSG(("\n")); } } } } } RELEASE(KConfigNode, node); } } RELEASE(KDirectory, dir); #endif return rc; }
static rc_t RefSeqMgr_KfgReadRepositories(const KConfig* kfg, char* paths, size_t paths_sz) { /* servers are children of refseq/repository, e.g.: /refseq/repository/main="..." */ /* volumes are in refseq/repository/<serverName>/volumes, e.g.: /refseq/repository/main/volumes="..." */ /* all server/volume combinations are returned in paths separated by ':' */ rc_t rc = 0; const KConfigNode *node; #define KFG_PATH "/refseq/repository/" paths[0] = 0; rc = KConfigOpenNodeRead ( kfg, & node, KFG_PATH ); if ( rc == 0 ) { KNamelist* children; rc = KConfigNodeListChild ( node, &children ); if ( rc == 0 ) { uint32_t count; rc = KNamelistCount ( children, &count ); if ( rc == 0 ) { uint32_t i; for (i = 0; i < count; ++i) /* for all servers */ { const char* name; rc = KNamelistGet ( children, i, &name ); if ( rc == 0 ) { #define BufSize 4096 char server[ BufSize ]; char buf[ BufSize ]; size_t num_writ; rc = string_printf(buf, BufSize, &num_writ, KFG_PATH "%s", name); if (rc == 0) { rc = RefSeqMgr_ConfigValue ( kfg, buf, server, sizeof(server) ); if (rc == 0) { rc = string_printf(buf, BufSize, &num_writ, KFG_PATH "%s/volumes", name); if (rc == 0) { char volumes[ BufSize ]; rc = RefSeqMgr_ConfigValue ( kfg, buf, volumes, sizeof(volumes) ); if (rc == 0) { /* create a server/volume pair for every combination, append to paths, ':' - separate */ char *vol_rem = volumes; char *vol_sep; do { char const *volume = vol_rem; vol_sep = string_chr(volume, string_size(volume), ':'); if(vol_sep) { vol_rem = vol_sep + 1; *vol_sep = 0; } string_copy(paths + string_size(paths), paths_sz - string_size(paths), server, string_size(server)); if (paths[string_size(paths)-1] != '/') { string_copy(paths + string_size(paths), paths_sz - string_size(paths), "/", 1); } string_copy(paths + string_size(paths), paths_sz - string_size(paths), volume, string_size(volume)); string_copy(paths + string_size(paths), paths_sz - string_size(paths), ":", 1); } while(vol_sep); } } } } #undef BufSize } if ( rc != 0 ) { break; } } } KNamelistRelease ( children ); } KConfigNodeRelease ( node ); } if (GetRCState(rc) == rcNotFound) { paths[0] = '\0'; return 0; } return 0; }
static void KNSManagerLoadAWS ( struct KNSManager *self ) { rc_t rc; const KConfigNode *aws_node; const KConfig *kfg = self -> kfg; if ( self == NULL ) return; rc = KConfigOpenNodeRead ( kfg, &aws_node, "AWS" ); if ( rc == 0 ) { do { String *access_key_id = NULL, *secret_access_key = NULL, *region = NULL, *output = NULL; const KConfigNode *access_key_id_node, *secret_access_key_node, *region_node, *output_node; rc = KConfigNodeOpenNodeRead ( aws_node, &access_key_id_node, "aws_access_key_id" ); if ( rc == 0 ) { rc = KConfigNodeReadString ( access_key_id_node, &access_key_id ); KConfigNodeRelease ( access_key_id_node ); if( rc != 0 ) break; } rc = KConfigNodeOpenNodeRead ( aws_node, &secret_access_key_node, "aws_secret_access_key" ); if ( rc == 0 ) { rc = KConfigNodeReadString ( secret_access_key_node, &secret_access_key ); KConfigNodeRelease ( secret_access_key_node ); if ( rc != 0 ) break; } rc = KConfigNodeOpenNodeRead ( aws_node, ®ion_node, "region" ); if ( rc == 0 ) { rc = KConfigNodeReadString ( region_node, ®ion ); KConfigNodeRelease ( region_node ); if ( rc != 0 ) break; } rc = KConfigNodeOpenNodeRead ( aws_node, &output_node, "output" ); if ( rc == 0 ) { rc = KConfigNodeReadString ( output_node, &output ); KConfigNodeRelease ( output_node ); if ( rc != 0 ) break; } self -> aws_access_key_id = access_key_id; self -> aws_secret_access_key = secret_access_key; self -> aws_region = region; self -> aws_output = output; } while ( 0 ); KConfigNodeRelease ( aws_node ); } }