http://git-wip-us.apache.org/repos/asf/trafodion/blob/87849fcf/core/sqf/src/trafconf/tcdbsqlite.cpp ---------------------------------------------------------------------- diff --git a/core/sqf/src/trafconf/tcdbsqlite.cpp b/core/sqf/src/trafconf/tcdbsqlite.cpp new file mode 100644 index 0000000..c54882b --- /dev/null +++ b/core/sqf/src/trafconf/tcdbsqlite.cpp @@ -0,0 +1,3390 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// @@@ START COPYRIGHT @@@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// +// @@@ END COPYRIGHT @@@ +// +/////////////////////////////////////////////////////////////////////////////// + +#include <string> +#include <stdlib.h> +#include <string.h> + +using namespace std; + +#include "tclog.h" +#include "tctrace.h" +#include "trafconf/trafconfig.h" +#include "tcdbsqlite.h" + +#define MAX_PROCESS_PATH 256 + +/////////////////////////////////////////////////////////////////////////////// +// Cluster Configuration +/////////////////////////////////////////////////////////////////////////////// + +CTcdbSqlite::CTcdbSqlite( void ) + : CTcdbStore( TCDBSQLITE ) + , db_(NULL) +{ + const char method_name[] = "CTcdbSqlite::CTcdbSqlite"; + TRACE_ENTRY; + + memcpy(&eyecatcher_, "TCSL", 4); + + TRACE_EXIT; +} + +CTcdbSqlite::~CTcdbSqlite ( void ) +{ + const char method_name[] = "CTcdbSqlite::~CTcdbSqlite"; + TRACE_ENTRY; + + memcpy(&eyecatcher_, "tcsl", 4); + + TRACE_EXIT; +} + +int CTcdbSqlite::AddLNodeData( int nid + , int pnid + , int firstCore + , int lastCore + , int processors + , int roles ) +{ + const char method_name[] = "CTcdbSqlite::AddLNodeData"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + if (TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST)) + { + trace_printf( "%s@%d inserting into lnode values (lNid=%d, pNid=%d, " + "processors=%d, roles=%d, firstCore=%d, lastCore=%d)\n" + , method_name, __LINE__ + , nid + , pnid + , processors + , roles + , firstCore + , lastCore ); + } + + int rc; + const char *sqlStmt; + sqlStmt = "insert into lnode values (?, ?, ?, ?, ?, ?)"; + + sqlite3_stmt *prepStmt = NULL; + rc = sqlite3_prepare_v2( db_, sqlStmt, static_cast<int>(strlen(sqlStmt)+1), &prepStmt, NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { + rc = sqlite3_bind_int( prepStmt, 1, nid ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(nid) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_int( prepStmt, 2, pnid ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(pnid) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_int( prepStmt, 3, processors ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(processors) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_int( prepStmt, 4, roles ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(roles) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_int( prepStmt, 5, firstCore ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(firsCore) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_int( prepStmt, 6, lastCore ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(lastCore) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmt ); + if (( rc != SQLITE_DONE ) && ( rc != SQLITE_ROW ) + && ( rc != SQLITE_CONSTRAINT ) ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + "(lNid=%d, pNid=%d, processors=%d, roles=%d, " + "firstCore=%d, lastCore=%d)\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) + , nid, pnid, processors, roles, firstCore, lastCore ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::AddPNodeData( const char *name + , int pnid + , int excludedFirstCore + , int excludedLastCore ) +{ + const char method_name[] = "CTcdbSqlite::AddPNodeData"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + if (TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST)) + { + trace_printf( "%s@%d inserting into pnode values (pNid=%d, " + "nodeName=%s, excFirstCore=%d, excLastCore=%d)\n" + , method_name, __LINE__ + , pnid + , name + , excludedFirstCore + , excludedLastCore ); + } + + int rc; + const char *sqlStmt; + sqlStmt = "insert into pnode values (?, ?, ?, ?)"; + + sqlite3_stmt *prepStmt = NULL; + rc = sqlite3_prepare_v2( db_, sqlStmt, static_cast<int>(strlen(sqlStmt)+1), &prepStmt, NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { + rc = sqlite3_bind_int( prepStmt, 1, pnid ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(pnid) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_text( prepStmt, 2, name, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(name) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_int( prepStmt, 3, excludedFirstCore ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(excludedFirstCore) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_int( prepStmt, 4, excludedLastCore ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(excludedLastCore) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmt ); + if (( rc != SQLITE_DONE ) && ( rc != SQLITE_ROW ) + && ( rc != SQLITE_CONSTRAINT ) ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + "(pNid=%d, nodeName=%s, excFirstCore=%d, excLastCore=%d)\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) + , pnid, name, excludedFirstCore, excludedLastCore ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +// insert key into monRegKeyName table +int CTcdbSqlite::AddRegistryKey( const char *key ) +{ + const char method_name[] = "CTcdbSqlite::AddRegistryKey"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST)) + { + trace_printf("%s@%d inserting key=%s into monRegKeyName\n", + method_name, __LINE__, key); + } + + int rc; + const char * sqlStmt; + sqlStmt = "insert into monRegKeyName (keyName) values ( :key );"; + sqlite3_stmt * prepStmt; + rc = sqlite3_prepare_v2( db_, sqlStmt, static_cast<int>(strlen(sqlStmt)+1), &prepStmt, + NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { + rc = sqlite3_bind_text( prepStmt, + sqlite3_bind_parameter_index( prepStmt, ":key" ), + key, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(:key) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmt ); + if (( rc != SQLITE_DONE ) && ( rc != SQLITE_ROW ) + && ( rc != SQLITE_CONSTRAINT ) ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, key=%s, error: %s\n" + , method_name, sqlStmt, key, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +// insert key into monRegProcName table +int CTcdbSqlite::AddRegistryProcess( const char *name ) +{ + const char method_name[] = "CTcdbSqlite::AddRegistryProcess"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST)) + { + trace_printf("%s@%d inserting name=%s into monRegProcName\n", + method_name, __LINE__, name); + } + + int rc; + const char * sqlStmt; + sqlStmt = "insert into monRegProcName (procName) values ( :name );"; + sqlite3_stmt * prepStmt; + rc = sqlite3_prepare_v2( db_, sqlStmt, static_cast<int>(strlen(sqlStmt)+1), &prepStmt, + NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { + rc = sqlite3_bind_text( prepStmt, + sqlite3_bind_parameter_index( prepStmt, ":name" ), + name, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(:name) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmt ); + if (( rc != SQLITE_DONE ) && ( rc != SQLITE_ROW ) + && ( rc != SQLITE_CONSTRAINT ) ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, name=%s, error: %s\n" + , method_name, sqlStmt, name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::AddRegistryClusterData( const char *key + , const char *dataValue ) +{ + const char method_name[] = "CTcdbSqlite::AddRegistryClusterData"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST)) + { + trace_printf("%s@%d inserting key=%s into monRegClusterData\n", + method_name, __LINE__, key); + } + + int rc; + const char * sqlStmt; + sqlStmt = "insert or replace into monRegClusterData (dataValue, keyId)" + " select :dataValue," + " k.keyId FROM monRegKeyName k" + " where k.keyName = :key"; + sqlite3_stmt * prepStmt; + rc = sqlite3_prepare_v2( db_, sqlStmt, static_cast<int>(strlen(sqlStmt)+1), &prepStmt, + NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { + rc = sqlite3_bind_text( prepStmt, + sqlite3_bind_parameter_index( prepStmt, + ":dataValue" ), + dataValue, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(:dataValue) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_text( prepStmt, + sqlite3_bind_parameter_index( prepStmt, ":key" ), + key, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(:key) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmt ); + if (( rc != SQLITE_DONE ) && ( rc != SQLITE_ROW ) + && ( rc != SQLITE_CONSTRAINT ) ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, key=%s, error: %s\n" + , method_name, sqlStmt, key, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::AddRegistryProcessData( const char *procName + , const char *key + , const char *dataValue ) +{ + const char method_name[] = "CTcdbSqlite::AddRegistryProcessData"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST)) + { + trace_printf("%s@%d inserting key=%s into monRegProcData for " + "proc=%s\n", method_name, __LINE__, key, procName); + } + + int rc; + const char * sqlStmt; + sqlStmt = "insert or replace into monRegProcData (dataValue, procId, keyId )" + " select :dataValue," + " p.procId," + " (SELECT k.keyId " + " FROM monRegKeyName k" + " WHERE k.keyName = :key)" + " FROM monRegProcName p" + " WHERE UPPER(p.procName) = UPPER(:procName)"; + + sqlite3_stmt * prepStmt; + rc = sqlite3_prepare_v2( db_, sqlStmt, static_cast<int>(strlen(sqlStmt)+1), &prepStmt, + NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { + rc = sqlite3_bind_text( prepStmt, + sqlite3_bind_parameter_index( prepStmt, + ":procName" ), + procName, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(:procName) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_text( prepStmt, + sqlite3_bind_parameter_index( prepStmt, + ":dataValue" ), + dataValue, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(:dataValue) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_text( prepStmt, + sqlite3_bind_parameter_index( prepStmt, ":key" ), + key, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(:key) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmt ); + if (( rc != SQLITE_DONE ) && ( rc != SQLITE_ROW ) + && ( rc != SQLITE_CONSTRAINT ) ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, key=%s, proc=%s, error: %s\n" + , method_name, sqlStmt, key, procName, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::AddUniqueString( int nid + , int id + , const char *uniqStr ) +{ + const char method_name[] = "CTcdbSqlite::AddUniqueString"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST)) + { + trace_printf("%s@%d inserting unique string nid=%d id=%d into " + "monRegUniqueStrings\n", method_name, __LINE__, + nid, id); + } + + int rc; + const char * sqlStmt; + sqlStmt = "insert or replace into monRegUniqueStrings values (?, ?, ?)"; + + sqlite3_stmt * prepStmt; + rc = sqlite3_prepare_v2( db_, sqlStmt, static_cast<int>(strlen(sqlStmt)+1), &prepStmt, + NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { + rc = sqlite3_bind_int( prepStmt, 1, nid ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(nid) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_int( prepStmt, 2, id ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(id) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + rc = sqlite3_bind_text( prepStmt, 3, uniqStr, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(uniqStr) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmt ); + if ( rc != SQLITE_DONE ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, nid=%d, id=%d, error: %s\n" + , method_name, sqlStmt, nid, id, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::Close( void ) +{ + const char method_name[] = "CTcdbSqlite::Close"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc = sqlite3_close( db_ ); + if ( rc == SQLITE_OK) + { + db_ = NULL; + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_close() error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::DeleteNodeData( int pnid ) +{ + const char method_name[] = "CTcdbSqlite::DeleteNodeData"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + if (TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST)) + { + trace_printf( "%s@%d delete from lnode, pnode values (pNid=%d)\n" + , method_name, __LINE__ + , pnid ); + } + + int rc; + + const char *sqlStmt1; + sqlStmt1 = "delete from lnode where lnode.pNid = ?"; + + sqlite3_stmt *prepStmt1 = NULL; + rc = sqlite3_prepare_v2( db_, sqlStmt1, static_cast<int>(strlen(sqlStmt1)+1), &prepStmt1, NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error=%s\n" + , method_name, sqlStmt1, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { + rc = sqlite3_bind_int( prepStmt1, 1, pnid ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(pnid) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt1 != NULL ) + { + sqlite3_finalize( prepStmt1 ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmt1 ); + if (( rc != SQLITE_DONE ) && ( rc != SQLITE_ROW ) + && ( rc != SQLITE_CONSTRAINT ) ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, pNid=%d, error: %s\n" + , method_name, sqlStmt1, pnid, sqlite3_errmsg(db_)); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt1 != NULL ) + { + sqlite3_finalize( prepStmt1 ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + const char *sqlStmt2; + sqlStmt2 = "delete from pnode where pnode.pNid = ?"; + + sqlite3_stmt *prepStmt2 = NULL; + rc = sqlite3_prepare_v2( db_, sqlStmt2, static_cast<int>(strlen(sqlStmt2)+1), &prepStmt2, NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error=%s\n" + , method_name, sqlStmt2, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt1 != NULL ) + { + sqlite3_finalize( prepStmt1 ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { + rc = sqlite3_bind_int( prepStmt2, 1, pnid ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(pnid) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt1 != NULL ) + { + sqlite3_finalize( prepStmt1 ); + } + if ( prepStmt2 != NULL ) + { + sqlite3_finalize( prepStmt2 ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmt2 ); + if (( rc != SQLITE_DONE ) && ( rc != SQLITE_ROW ) + && ( rc != SQLITE_CONSTRAINT ) ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, pNid=%d, error: %s\n" + , method_name, sqlStmt2, pnid, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt1 != NULL ) + { + sqlite3_finalize( prepStmt1 ); + } + if ( prepStmt2 != NULL ) + { + sqlite3_finalize( prepStmt2 ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt1 != NULL ) + { + sqlite3_finalize( prepStmt1 ); + } + if ( prepStmt2 != NULL ) + { + sqlite3_finalize( prepStmt2 ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::DeleteUniqueString( int nid ) +{ + const char method_name[] = "CTcdbSqlite::DeleteUniqueString"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST)) + { + trace_printf( "%s@%d delete from monRegUniqueStrings values (nid=%d)\n" + , method_name, __LINE__ + , nid ); + } + + int rc; + + const char *sqlStmtA; + sqlStmtA = "delete from monRegUniqueStrings where monRegUniqueStrings.nid = ?"; + + sqlite3_stmt *prepStmtA = NULL; + rc = sqlite3_prepare_v2( db_, sqlStmtA, static_cast<int>(strlen(sqlStmtA)+1), &prepStmtA, NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error=%s\n" + , method_name, sqlStmtA, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { + rc = sqlite3_bind_int( prepStmtA, 1, nid ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(nid) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmtA != NULL ) + { + sqlite3_finalize( prepStmtA ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmtA ); + if (( rc != SQLITE_DONE ) && ( rc != SQLITE_ROW ) + && ( rc != SQLITE_CONSTRAINT ) ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, pNid=%d, error: %s\n" + , method_name, sqlStmtA, nid, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmtA != NULL ) + { + sqlite3_finalize( prepStmtA ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmtA != NULL ) + { + sqlite3_finalize( prepStmtA ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::Initialize( void ) +{ + const char method_name[] = "CTcdbSqlite::Initialize"; + TRACE_ENTRY; + + if ( IsInitialized() ) + { + // Already initialized + TRACE_EXIT; + return( TCALREADYINIT ); + } + + char dbase[MAX_PROCESS_PATH]; + + // Open the configuration database file + char *configenv = getenv("SQ_CONFIGDB"); + if (configenv != NULL) + { + snprintf( dbase, sizeof(dbase), "%s", configenv); + } + else + { + snprintf( dbase, sizeof(dbase) + , "%s/sql/scripts/sqconfig.db", getenv("TRAF_HOME")); + } + int rc = sqlite3_open_v2( dbase, &db_ + , SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX + , NULL); + if ( rc ) + { + db_ = NULL; + + // See if database is in current directory + int rc2 = sqlite3_open_v2( "sqconfig.db", &db_ + , SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX + , NULL); + if ( rc2 ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s], sqlite3_open_v2(%s) failed, error: %s\n" + , method_name, dbase, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( db_ != NULL ) + { + rc = sqlite3_busy_timeout(db_, 1000); + if ( rc ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s], sqlite3_busy_timeout(%s) failed, error: %s\n" + , method_name, dbase, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + + char *sErrMsg = NULL; + sqlite3_exec(db_, "PRAGMA synchronous = OFF", NULL, NULL, &sErrMsg); + if (sErrMsg != NULL) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s], sqlite3_exec(PRAGMA synchronous = OFF) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetNode( int nid + , node_configuration_t &nodeConfig ) +{ + const char method_name[] = "CTcdbSqlite::GetNode"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc; + int firstcore = -1; + int lastcore = -1; + int excfirstcore = -1; + int exclastcore = -1; + int lnid = -1; + int pnid = -1; + int processors = 0; + int roles; + const char *nodename = NULL; + const char *sqlStmt; + sqlite3_stmt *prepStmt = NULL; + + // Prepare select logical nodes + sqlStmt = "select p.pNid, l.lNid, p.nodeName, l.firstCore, l.lastCore," + " p.excFirstCore, p.excLastCore, l.processors, l.roles" + " from pnode p, lnode l where p.pNid = l.pNid" + " and l.lNid = ?"; + + rc = sqlite3_prepare_v2( db_ + , sqlStmt + , static_cast<int>(strlen(sqlStmt)+1) + , &prepStmt + , NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { // Set nid in prepared statement + rc = sqlite3_bind_int(prepStmt, 1, nid ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(nid) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + rc = sqlite3_step( prepStmt ); + if ( rc == SQLITE_ROW ) + { // Process row + int colCount = sqlite3_column_count(prepStmt); + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d sqlite3_column_count=%d\n", + method_name, __LINE__, colCount); + for (int i=0; i<colCount; ++i) + { + trace_printf("%s@%d column %d is %s\n", + method_name, __LINE__, i, + sqlite3_column_name(prepStmt, i)); + } + } + + pnid = sqlite3_column_int(prepStmt, 0); + lnid = sqlite3_column_int(prepStmt, 1); + nodename = (const char *) sqlite3_column_text(prepStmt, 2); + firstcore = sqlite3_column_int(prepStmt, 3); + lastcore = sqlite3_column_int(prepStmt, 4); + excfirstcore = sqlite3_column_int(prepStmt, 5); + exclastcore = sqlite3_column_int(prepStmt, 6); + processors = sqlite3_column_int(prepStmt, 7); + roles = sqlite3_column_int(prepStmt, 8); + SetLNodeData( lnid + , pnid + , nodename + , excfirstcore + , exclastcore + , firstcore + , lastcore + , processors + , roles + , nodeConfig ); + } + else if ( rc == SQLITE_DONE ) + { + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d Finished processing logical nodes.\n", + method_name, __LINE__); + } + TRACE_EXIT; + return( TCDBNOEXIST ); + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetNode( const char *name + , node_configuration_t &nodeConfig ) +{ + const char method_name[] = "CTcdbSqlite::GetNode"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc; + int firstcore = -1; + int lastcore = -1; + int excfirstcore = -1; + int exclastcore = -1; + int nid = -1; + int pnid = -1; + int processors = 0; + int roles; + const char *nodename = NULL; + const char *sqlStmt; + sqlite3_stmt *prepStmt = NULL; + + // Prepare select logical nodes + sqlStmt = "select p.pNid, l.lNid, p.nodeName, l.firstCore, l.lastCore," + " p.excFirstCore, p.excLastCore, l.processors, l.roles" + " from pnode p, lnode l where p.pNid = l.pNid" + " and p.nodeName = ?"; + + rc = sqlite3_prepare_v2( db_ + , sqlStmt + , static_cast<int>(strlen(sqlStmt)+1) + , &prepStmt + , NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { // Set name in prepared statement + rc = sqlite3_bind_text( prepStmt, 1, name, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(name) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + rc = sqlite3_step( prepStmt ); + if ( rc == SQLITE_ROW ) + { // Process row + int colCount = sqlite3_column_count(prepStmt); + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d sqlite3_column_count=%d\n", + method_name, __LINE__, colCount); + for (int i=0; i<colCount; ++i) + { + trace_printf("%s@%d column %d is %s\n", + method_name, __LINE__, i, + sqlite3_column_name(prepStmt, i)); + } + } + + pnid = sqlite3_column_int(prepStmt, 0); + nid = sqlite3_column_int(prepStmt, 1); + nodename = (const char *) sqlite3_column_text(prepStmt, 2); + firstcore = sqlite3_column_int(prepStmt, 3); + lastcore = sqlite3_column_int(prepStmt, 4); + excfirstcore = sqlite3_column_int(prepStmt, 5); + exclastcore = sqlite3_column_int(prepStmt, 6); + processors = sqlite3_column_int(prepStmt, 7); + roles = sqlite3_column_int(prepStmt, 8); + SetLNodeData( nid + , pnid + , nodename + , excfirstcore + , exclastcore + , firstcore + , lastcore + , processors + , roles + , nodeConfig ); + } + else if ( rc == SQLITE_DONE ) + { + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d Finished processing logical nodes.\n", + method_name, __LINE__); + } + TRACE_EXIT; + return( TCDBNOEXIST ); + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + // Destroy prepared statement object + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetNodes( int &count + , int max + , node_configuration_t nodeConfig[] ) +{ + const char method_name[] = "CTcdbSqlite::GetNodes"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc; + int firstcore = -1; + int lastcore = -1; + int excfirstcore = -1; + int exclastcore = -1; + int nid = -1; + int pnid = -1; + int processors = 0; + int roles; + int nodeCount = 0; + const char *nodename = NULL; + const char *sqlStmt; + sqlite3_stmt *prepStmt = NULL; + + // Prepare select logical nodes + sqlStmt = "select p.pNid, l.lNid, p.nodeName, l.firstCore, l.lastCore," + " p.excFirstCore, p.excLastCore, l.processors, l.roles" + " from pnode p, lnode l where p.pNid = l.pNid"; + + rc = sqlite3_prepare_v2( db_ + , sqlStmt + , static_cast<int>(strlen(sqlStmt)+1) + , &prepStmt + , NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + + // Process logical nodes + while ( 1 ) + { + rc = sqlite3_step( prepStmt ); + if ( rc == SQLITE_ROW ) + { // Process row + if ( max == 0 ) + { + nodeCount++; + continue; + } + + int colCount = sqlite3_column_count(prepStmt); + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d sqlite3_column_count=%d\n", + method_name, __LINE__, colCount); + for (int i=0; i<colCount; ++i) + { + trace_printf("%s@%d column %d is %s\n", + method_name, __LINE__, i, + sqlite3_column_name(prepStmt, i)); + } + } + + if ( nodeCount < max ) + { + pnid = sqlite3_column_int(prepStmt, 0); + nid = sqlite3_column_int(prepStmt, 1); + nodename = (const char *) sqlite3_column_text(prepStmt, 2); + firstcore = sqlite3_column_int(prepStmt, 3); + lastcore = sqlite3_column_int(prepStmt, 4); + excfirstcore = sqlite3_column_int(prepStmt, 5); + exclastcore = sqlite3_column_int(prepStmt, 6); + processors = sqlite3_column_int(prepStmt, 7); + roles = sqlite3_column_int(prepStmt, 8); + SetLNodeData( nid + , pnid + , nodename + , excfirstcore + , exclastcore + , firstcore + , lastcore + , processors + , roles + , nodeConfig[nodeCount] ); + nodeCount++; + } + else + { + count = nodeCount; + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBTRUNCATE ); + } + } + else if ( rc == SQLITE_DONE ) + { + count = nodeCount; + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d Finished processing logical nodes.\n", + method_name, __LINE__); + } + break; + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetPNode( int pNid + , physical_node_configuration_t &pnodeConfig ) +{ + const char method_name[] = "CTcdbSqlite::GetPNode"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc; + int excfirstcore = -1; + int exclastcore = -1; + int pnid = -1; + const char *nodename = NULL; + const char *sqlStmt; + sqlite3_stmt *prepStmt = NULL; + + // Prepare select logical nodes + sqlStmt = "select p.pNid, p.nodeName, p.excFirstCore, p.excLastCore" + " from pnode p where p.pNid = ?"; + + rc = sqlite3_prepare_v2( db_ + , sqlStmt + , static_cast<int>(strlen(sqlStmt)+1) + , &prepStmt + , NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { // Set nid in prepared statement + rc = sqlite3_bind_int(prepStmt, 1, pNid ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(pNid) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + rc = sqlite3_step( prepStmt ); + if ( rc == SQLITE_ROW ) + { // Process row + int colCount = sqlite3_column_count(prepStmt); + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d sqlite3_column_count=%d\n", + method_name, __LINE__, colCount); + for (int i=0; i<colCount; ++i) + { + trace_printf("%s@%d column %d is %s\n", + method_name, __LINE__, i, + sqlite3_column_name(prepStmt, i)); + } + } + + pnid = sqlite3_column_int(prepStmt, 0); + nodename = (const char *) sqlite3_column_text(prepStmt, 1); + excfirstcore = sqlite3_column_int(prepStmt, 2); + exclastcore = sqlite3_column_int(prepStmt, 3); + SetPNodeData( pnid + , nodename + , excfirstcore + , exclastcore + , pnodeConfig ); + } + else if ( rc == SQLITE_DONE ) + { + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d Finished processing logical nodes.\n", + method_name, __LINE__); + } + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetPNode( const char *name + , physical_node_configuration_t &pnodeConfig ) +{ + const char method_name[] = "CTcdbSqlite::GetPNode"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc; + int excfirstcore = -1; + int exclastcore = -1; + int pnid = -1; + const char *nodename = NULL; + const char *sqlStmt; + sqlite3_stmt *prepStmt = NULL; + + // Prepare select logical nodes + sqlStmt = "select p.pNid, p.nodeName, p.excFirstCore, p.excLastCore" + " from pnode p where p.nodeName = ?"; + + rc = sqlite3_prepare_v2( db_ + , sqlStmt + , static_cast<int>(strlen(sqlStmt)+1) + , &prepStmt + , NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_bind_text( prepStmt, 1, name, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(name) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + rc = sqlite3_step( prepStmt ); + if ( rc == SQLITE_ROW ) + { // Process row + int colCount = sqlite3_column_count(prepStmt); + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d sqlite3_column_count=%d\n", + method_name, __LINE__, colCount); + for (int i=0; i<colCount; ++i) + { + trace_printf("%s@%d column %d is %s\n", + method_name, __LINE__, i, + sqlite3_column_name(prepStmt, i)); + } + } + + pnid = sqlite3_column_int(prepStmt, 0); + nodename = (const char *) sqlite3_column_text(prepStmt, 1); + excfirstcore = sqlite3_column_int(prepStmt, 2); + exclastcore = sqlite3_column_int(prepStmt, 3); + SetPNodeData( pnid + , nodename + , excfirstcore + , exclastcore + , pnodeConfig ); + } + else if ( rc == SQLITE_DONE ) + { + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d Finished processing logical nodes.\n", + method_name, __LINE__); + } + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetSNodes( int &count + , int max + , physical_node_configuration_t spareNodeConfig[] ) +{ + const char method_name[] = "CTcdbSqlite::GetSNodes"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc; + int pnid = -1; + int excfirstcore = -1; + int exclastcore = -1; + int snodeCount = 0; + const char *nodename = NULL; + const char *sqlStmt; + sqlite3_stmt *prepStmt = NULL; + + // Prepare select spare nodes + sqlStmt = "select p.pNid, p.nodeName, p.excFirstCore, p.excLastCore," + " s.spNid " + " from pnode p, snode s where p.pNid = s.pNid"; + + rc = sqlite3_prepare_v2( db_ + , sqlStmt + , static_cast<int>(strlen(sqlStmt)+1) + , &prepStmt + , NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + + count = snodeCount; + + // Process spare nodes + while ( 1 ) + { + rc = sqlite3_step( prepStmt ); + if ( rc == SQLITE_ROW ) + { // Process row + if ( max == 0 ) + { + snodeCount++; + continue; + } + + int colCount = sqlite3_column_count(prepStmt); + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d sqlite3_column_count=%d\n", + method_name, __LINE__, colCount); + for (int i=0; i<colCount; ++i) + { + trace_printf("%s@%d column %d is %s\n", + method_name, __LINE__, i, + sqlite3_column_name(prepStmt, i)); + } + } + + if ( snodeCount < max ) + { + pnid = sqlite3_column_int(prepStmt, 0); + nodename = (const char *) sqlite3_column_text(prepStmt, 1); + excfirstcore = sqlite3_column_int(prepStmt, 2); + exclastcore = sqlite3_column_int(prepStmt, 3); + if ( ! GetSNodeData( pnid + , nodename + , excfirstcore + , exclastcore + , spareNodeConfig[snodeCount] ) ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s], Error: Invalid node configuration\n" + , method_name); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + snodeCount++; + } + else + { + count = snodeCount; + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBTRUNCATE ); + } + } + else if ( rc == SQLITE_DONE ) + { + count = snodeCount; + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d Finished processing spare nodes.\n", + method_name, __LINE__); + } + break; + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetSNodeData( int pnid + , const char *nodename + , int excfirstcore + , int exclastcore + , physical_node_configuration_t &spareNodeConfig ) +{ + const char method_name[] = "CTcdbSqlite::GetSNodeData"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc; + const char *sqlStmt; + sqlite3_stmt *prepStmt = NULL; + + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf( "%s@%d pnid=%d, name=%s, excluded cores=(%d:%d)\n" + , method_name, __LINE__ + , pnid + , nodename + , excfirstcore + , exclastcore ); + } + + spareNodeConfig.pnid = pnid; + strncpy( spareNodeConfig.node_name + , nodename + , sizeof(spareNodeConfig.node_name) ); + spareNodeConfig.excluded_first_core = excfirstcore; + spareNodeConfig.excluded_last_core = exclastcore; + + // Select all spared nodes configured for this spare node + sqlStmt = "select p.pNid, s.spNid" + " from pnode p, snode s" + " where p.pNid = s.pNid and p.pNid = ?"; + + rc = sqlite3_prepare_v2( db_ + , sqlStmt + , static_cast<int>(strlen(sqlStmt)+1) + , &prepStmt + , NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { // Set pnid in prepared statement + rc = sqlite3_bind_int(prepStmt, 1, pnid ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf), + "[%s] sqlite3_bind_int(pnid) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + int spnid; + int sparedpnid; + int spareCount = 0; + + // Process spare nodes + while ( 1 ) + { + rc = sqlite3_step( prepStmt ); + if ( rc == SQLITE_ROW ) + { // Process row + int colCount = sqlite3_column_count(prepStmt); + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d sqlite3_column_count=%d\n", + method_name, __LINE__, colCount); + for (int i=0; i<colCount; ++i) + { + trace_printf("%s@%d column %d is %s\n", + method_name, __LINE__, i, + sqlite3_column_name(prepStmt, i)); + } + } + + spnid = sqlite3_column_int(prepStmt, 0); + sparedpnid = sqlite3_column_int(prepStmt, 1); + spareNodeConfig.spare_pnid[spareCount] = sparedpnid; + spareCount++; + } + else if ( rc == SQLITE_DONE ) + { + spareNodeConfig.spare_count = spareCount; + if ( TcTraceSettings & (TC_TRACE_NODE | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d Finished processing spared node set.\n", + method_name, __LINE__); + } + break; + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetPersistProcess( const char *persistPrefix + , persist_configuration_t &persistConfig ) +{ + const char method_name[] = "CTcdbSqlite::GetPersistProcess"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc, rs; + char param[TC_PERSIST_KEY_MAX]; + const char *persistKey; + const char *persistValue; + const char *sqlStmt; + sqlite3_stmt *prepStmt = NULL; + + if ( TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST) ) + { + trace_printf( "%s@%d processkey=%s\n" + , method_name, __LINE__ + , persistPrefix ); + } + + strncpy( persistConfig.persist_prefix + , persistPrefix + , sizeof(persistConfig.persist_prefix) ); + + snprintf( param, sizeof(param), "%s_%%", persistPrefix ); + + // Prepare select persistent process for the key + sqlStmt = "select p.keyName, p.valueName" + " from monRegPersistData p" + " where p.keyName like ?"; + + rc = sqlite3_prepare_v2( db_ + , sqlStmt + , static_cast<int>(strlen(sqlStmt)+1) + , &prepStmt + , NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + else + { // Set key in prepared statement + rc = sqlite3_bind_text( prepStmt, 1, param, -1, SQLITE_STATIC ); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] sqlite3_bind_text(keyName) failed, error: %s\n" + , method_name, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + while ( 1 ) + { + rc = sqlite3_step( prepStmt ); + if ( rc == SQLITE_ROW ) + { // Process row + int colCount = sqlite3_column_count(prepStmt); + if ( TcTraceSettings & (TC_TRACE_PERSIST | TC_TRACE_REQUEST) ) + { + trace_printf( "%s@%d sqlite3_column_count=%d\n" + , method_name, __LINE__, colCount); + for (int i=0; i<colCount; ++i) + { + trace_printf("%s@%d column %d is %s\n", + method_name, __LINE__, i, + sqlite3_column_name(prepStmt, i)); + } + } + + persistKey = (const char *) sqlite3_column_text(prepStmt, 0); + persistValue = (const char *) sqlite3_column_text(prepStmt, 1); + + if ( TcTraceSettings & (TC_TRACE_PERSIST | TC_TRACE_REQUEST) ) + { + trace_printf( "%s@%d monRegPersistData key=%s, value=%s\n" + , method_name, __LINE__, persistKey, persistValue); + } + + // Parse the value based on the key + rs = SetPersistProcessData( persistKey + , persistValue + , persistConfig ); + if ( rs != TCSUCCESS ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s], Error: Invalid persist key value in " + "configuration, key=%s, value=%s\n" + , method_name, persistKey, persistValue ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + else if ( rc == SQLITE_DONE ) + { + if ( TcTraceSettings & (TC_TRACE_PERSIST | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d Finished processing all rows.\n", + method_name, __LINE__); + } + break; + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetPersistProcessKeys( const char *persistProcessKeys ) +{ + const char method_name[] = "CTcdbSqlite::GetPersistProcessKeys"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + + int rc; + + const char *sqlStmt; + sqlite3_stmt *prepStmt = NULL; + sqlStmt = "select p.valueName" + " from monRegPersistData p" + " where p.keyName = 'PERSIST_PROCESS_KEYS'"; + + rc = sqlite3_prepare_v2( db_ + , sqlStmt + , static_cast<int>(strlen(sqlStmt)+1) + , &prepStmt + , NULL); + if ( rc != SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + + // Process persistent process keys + rc = sqlite3_step( prepStmt ); + if ( rc == SQLITE_ROW ) + { // Process row + int colCount = sqlite3_column_count(prepStmt); + + if ( TcTraceSettings & (TC_TRACE_PERSIST | TC_TRACE_REQUEST) ) + { + trace_printf("%s@%d sqlite3_column_count=%d\n", + method_name, __LINE__, colCount); + for (int i=0; i<colCount; ++i) + { + trace_printf("%s@%d column %d is %s\n", + method_name, __LINE__, i, + sqlite3_column_name(prepStmt, i)); + } + } + + const unsigned char *value; + + value = sqlite3_column_text(prepStmt, 0); + strncpy( (char *)persistProcessKeys, (const char *)value, TC_PERSIST_KEYS_VALUE_MAX ); + + } + else if ( rc == SQLITE_DONE ) + { + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBNOEXIST ); + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_CRIT, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetRegistryClusterSet( int &count + , int max + , registry_configuration_t registryConfig[] ) +{ + const char method_name[] = "CTcdbSqlite::GetRegistryClusterSet"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc; + const unsigned char *group; + const unsigned char *key; + const unsigned char *value; + int entryNum = 0; + + count = 0; + + if ( db_ == NULL ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf("%s@%d cannot initialize registry from database " + "since database open failed.\n", method_name, + __LINE__); + } + + TRACE_EXIT; + return( TCNOTINIT ); + } + + // Read cluster configuration registry entries and populate in-memory + // structures. + const char *sqlStmt; + sqlStmt = "select k.keyName, d.dataValue " + " from monRegKeyName k, monRegClusterData d " + " where k.keyId = d.keyId"; + sqlite3_stmt *prepStmt; + + rc = sqlite3_prepare_v2( db_, sqlStmt, static_cast<int>(strlen(sqlStmt)+1), &prepStmt, NULL); + if( rc!=SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + + while ( 1 ) + { + rc = sqlite3_step(prepStmt); + if ( rc == SQLITE_ROW ) + { // Process row + if ( max == 0 ) + { + ++entryNum; + continue; + } + + if ( entryNum < max ) + { + group = (const unsigned char *) "CLUSTER"; + key = sqlite3_column_text(prepStmt, 0); + value = sqlite3_column_text(prepStmt, 1); + if ( TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST) ) + { + trace_printf( "%s@%d entry %d: group=%s key=%s, value=%s\n" + , method_name, __LINE__ + , entryNum, group, key, value); + } + strncpy( registryConfig[entryNum].scope, (const char *)group, TC_REGISTRY_KEY_MAX ); + strncpy( registryConfig[entryNum].key, (const char *)key, TC_REGISTRY_KEY_MAX ); + strncpy( registryConfig[entryNum].value, (const char *)value, TC_REGISTRY_VALUE_MAX ); + ++entryNum; + } + else + { + count = entryNum; + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBTRUNCATE ); + } + } + else if ( rc == SQLITE_DONE ) + { + count = entryNum; + break; + } + else + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCDBOPERROR ); + } + } + + count =entryNum; + + if ( prepStmt != NULL ) + { + sqlite3_finalize( prepStmt ); + } + TRACE_EXIT; + return( TCSUCCESS ); +} + +int CTcdbSqlite::GetRegistryProcessSet( int &count + , int max + , registry_configuration_t registryConfig[] ) +{ + const char method_name[] = "CTcdbSqlite::GetRegistryProcessSet"; + TRACE_ENTRY; + + if ( !IsInitialized() ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf( "%s@%d Database is not initialized for access!\n" + , method_name, __LINE__); + } + TRACE_EXIT; + return( TCNOTINIT ); + } + + int rc; + const unsigned char *group; + const unsigned char *key; + const unsigned char *value; + int entryNum = 0; + + count = 0; + + if ( db_ == NULL ) + { + if (TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST | TC_TRACE_INIT)) + { + trace_printf("%s@%d cannot initialize registry from database " + "since database open failed.\n", method_name, + __LINE__); + } + + TRACE_EXIT; + return( TCNOTINIT ); + } + + // Read process configuration registry entries and populate in-memory + // structures. + const char *sqlStmt; + sqlStmt = "select p.procName, k.keyName, d.dataValue" + " from monRegProcName p, monRegKeyName k, monRegProcData d" + " where p.procId = d.procId" + " and k.keyId = d.keyId"; + sqlite3_stmt *prepStmt; + + rc = sqlite3_prepare_v2( db_, sqlStmt, static_cast<int>(strlen(sqlStmt)+1), &prepStmt, NULL); + if( rc!=SQLITE_OK ) + { + char buf[TC_LOG_BUF_SIZE]; + snprintf( buf, sizeof(buf) + , "[%s] prepare (%s) failed, error: %s\n" + , method_name, sqlStmt, sqlite3_errmsg(db_) ); + TcLogWrite( SQLITE_DB_ACCESS_ERROR, TC_LOG_ERR, buf ); + TRACE_EXIT; + return( TCDBOPERROR ); + } + + while ( 1 ) + { + rc = sqlite3_step(prepStmt); + if ( rc == SQLITE_ROW ) + { // Process row + if ( max == 0 ) + { + ++entryNum; + continue; + } + + if ( entryNum < max ) + { + group = sqlite3_column_text(prepStmt, 0); + key = sqlite3_column_text(prepStmt, 1); + value = sqlite3_column_text(prepStmt, 2); + if ( TcTraceSettings & (TC_TRACE_REGISTRY | TC_TRACE_REQUEST) ) + { + trace_printf( "%s@%d entry %d: group=%s key=%s,
<TRUNCATED>
