X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fconfig%2Fconfig.cpp;fp=src%2Fconfig%2Fconfig.cpp;h=16eb42160f0b05cf83d946cf9b9570d104d2e127;hb=d486a17c04f3d6d865f787168d446f4cfea3be25;hp=0000000000000000000000000000000000000000;hpb=ef3620529c936a8790d6970c57198b4caee09c0d;p=ric-plt%2Fxapp-frame-cpp.git diff --git a/src/config/config.cpp b/src/config/config.cpp new file mode 100644 index 0000000..16eb421 --- /dev/null +++ b/src/config/config.cpp @@ -0,0 +1,371 @@ +// vi: ts=4 sw=4 noet: +/* +================================================================================== + Copyright (c) 2020 AT&T Intellectual Property. + Copyright (c) 2020 Nokia + + Licensed 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. +================================================================================== +*/ + +/* + Mnemonic: config.cpp + Abstract: Support for reading config json. + + The config structure allows simplified parsing of the json and + easy access to the things we belive all xAPPs will use (port + digging form the named "interface" and control settings). This + also supports the watching on the file and driving the user + callback when the config file appears to have changed (write + close on the file). + + Accessing information from the json is serialised (mutex) as + with the random nature of file updates, we must ensure that + we don't change the json as we're trying to read from it. Locking + should be transparent to the user xAPP. + + Date: 27 July 2020 + Author: E. Scott Daniels +*/ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "jhash.hpp" +#include "config.hpp" +#include "config_cb.hpp" + +namespace xapp { + + +// ----- private things -------- +/* + Notification listener. This function is started in a thread and listens for + changes to the config file. When it sees an interesting change (write close) + to the file, then it will read the new set of json, parse it, and drive the + user callback. + + We must watch the directory containing the file as if the file is edited and + replaced it's likely saved with a different referencing inode. We'd see the + first change, but not any subsequent changes as the inotify is based on inodes + and not directory entries. +*/ +void xapp::Config::Listener( ) { + struct inotify_event* ie; // event that popped + int ifd; // the inotify file des + int wfd; // the watched file des + int n; + char rbuf[4096]; // large read buffer as the event is var len + char* dname; // directory name + char* bname; // basename + char* tok; + + ifd = inotify_init1( 0 ); // initialise watcher setting blocking read (no option) + if( ifd < 0 ) { + fprintf( stderr, " ### ERR ### unable to initialise file watch %s\n", strerror( errno ) ); + return; + } + + dname = strdup( fname.c_str() ); // defrock the file name into dir and basename + if( (tok = strrchr( dname, '/' )) != NULL ) { + *tok = 0; + bname = strdup( tok+1 ); + } else { + free( dname ); + dname = strdup( "." ); + bname = strdup( fname.c_str() ); + } + + wfd = inotify_add_watch( ifd, (char *) dname, IN_MOVED_TO | IN_CLOSE_WRITE ); // we only care about close write changes + + if( wfd < 0 ) { + fprintf( stderr, " ### ERR ### unable to add watch on config file %s: %s\n", fname.c_str(), strerror( errno ) ); + return; + } + + while( true ) { + n = read( ifd, rbuf, sizeof( rbuf ) ); // read the event + if( n < 0 ) { + if( errno == EAGAIN ) { + continue; + } else { + fprintf( stderr, "len > 0 && strcmp( bname, ie->name ) == 0 ) { + // TODO: lock + auto njh = jparse( fname ); // reparse the file + // TODO: unlock + + if( njh != NULL && cb != NULL ) { // good parse, save and drive user callback + jh = njh; + cb->Drive_cb( *this, user_cb_data ); + } + } + } +} + + +/* + Read a file containing json and parse into a framework Jhash. + + Using C i/o will speed this up, but I can't imagine that we need + speed reading the config file once in a while. + The file read comes from a stack overflow example: + stackoverflow.com/questions/2912520/read-file-contents-into-a-string-in-c +*/ +std::shared_ptr xapp::Config::jparse( std::string ufname ) { + fname = ufname; + + std::ifstream ifs( fname ); + std::string st( (std::istreambuf_iterator( ifs ) ), (std::istreambuf_iterator() ) ); + + auto new_jh = std::shared_ptr( new xapp::Jhash( st.c_str() ) ); + return new_jh->Parse_errors() ? NULL : new_jh; +} + +/* + Read the configuration file from what we find as the filename in the environment (assumed + to be referenced by $XAPP_DESCRIPTOR_PATH/config-file.json. If the env var is not + defined we assume ./. The data is then parsed with the assumption that it's json. + + The actual meaning of the environment variable is confusing. The name is "path" which + should mean that this is the directory in which the config file lives, but the examples + elsewhere suggest that this is a filename (either fully qualified or relative). For now + we will assume that it's a file name, though we could add some intelligence to determine + if it's a directory name or not if it comes to it. +*/ +std::shared_ptr xapp::Config::jparse( ) { + char* data; + + if( (data = getenv( (char *) "XAPP_DESCRIPTOR_PATH" )) == NULL ) { + data = (char *) "./config-file.json"; + } + + return jparse( std::string( data ) ); +} + +// --------------------- construction, destruction ------------------------------------------- + +/* + By default expect to find XAPP_DESCRIPTOR_PATH in the environment and assume that it + is the directory name where we can find config-file.json. The build process will + read and parse the json allowing the user xAPP to invoke the supplied "obvious" + functions to retrieve data. If there is something in an xAPP's config that isn't + standard, it can get the raw Jhash object and go at it directly. The idea is that + the common things should be fairly painless to extract from the json goop. +*/ +xapp::Config::Config() : + jh( jparse() ), + listener( NULL ) +{ /* empty body */ } + +/* + Similar, except that it allows the xAPP to supply the filename (testing?) +*/ +xapp::Config::Config( std::string fname) : + jh( jparse( fname ) ), + listener( NULL ) +{ /* empty body */ } + + +/* + Read and return the raw file blob as a single string. User can parse, or do + whatever they need (allows non-json things if necessary). +*/ +std::string xapp::Config::Get_contents( ) { + std::string rv = ""; + + if( ! fname.empty() ) { + std::ifstream ifs( fname ); + std::string st( (std::istreambuf_iterator( ifs ) ), (std::istreambuf_iterator() ) ); + rv = st; + } + + return rv; +} + +// ----- convience function for things we think an xAPP will likely need to pull from the config + + +/* + Suss out the port for the named "interface". The interface is likely the application + name. +*/ +std::string xapp::Config::Get_port( std::string name ) { + int i; + int nele = 0; + double value; + std::string rv = ""; // result value + std::string pname; // element port name in the json + + if( jh == NULL ) { + return rv; + } + + jh->Unset_blob(); + if( jh->Set_blob( (char *) "messaging" ) ) { + nele = jh->Array_len( (char *) "ports" ); + for( i = 0; i < nele; i++ ) { + if( jh->Set_blob_ele( (char *) "ports", i ) ) { + pname = jh->String( (char *) "name" ); + if( pname.compare( name ) == 0 ) { // this element matches the name passed in + value = jh->Value( (char *) "port" ); + rv = std::to_string( (int) value ); + jh->Unset_blob( ); // leave hash in a known state + return rv; + } + } + + jh->Unset_blob( ); // Jhash requires bump to root, and array reselct to move to next ele + jh->Set_blob( (char *) "messaging" ); + } + } + + jh->Unset_blob(); + return rv; +} + +/* + Suss out the named string from the controls object. If the resulting value is + missing or "", then the default is returned. +*/ +std::string xapp::Config::Get_control_str( std::string name, std::string defval ) { + std::string value; + std::string rv; // result value + + rv = defval; + if( jh == NULL ) { + return rv; + } + + jh->Unset_blob(); + if( jh->Set_blob( (char *) "controls" ) ) { + if( jh->Exists( name.c_str() ) ) { + value = jh->String( name.c_str() ); + if( value.compare( "" ) != 0 ) { + rv = value; + } + } + } + + jh->Unset_blob(); + return rv; +} + +/* + Convenience funciton without default. "" returned if not found. + No default value; returns "" if not set. +*/ +std::string xapp::Config::Get_control_str( std::string name ) { + return Get_control_str( name, "" ); +} + +/* + Suss out the named field from the controls object with the assumption that it is a boolean. + If the resulting value is missing then the defval is used. +*/ +bool xapp::Config::Get_control_bool( std::string name, bool defval ) { + bool value; + bool rv; // result value + + rv = defval; + if( jh == NULL ) { + return rv; + } + + jh->Unset_blob(); + if( jh->Set_blob( (char *) "controls" ) ) { + if( jh->Exists( name.c_str() ) ) { + rv = jh->Bool( name.c_str() ); + } + } + + jh->Unset_blob(); + return rv; +} + + +/* + Convenience function without default. +*/ +bool xapp::Config::Get_control_bool( std::string name ) { + return Get_control_bool( name, false ); +} + + +/* + Suss out the named field from the controls object with the assumption that it is a value (float/int). + If the resulting value is missing then the defval is used. +*/ +double xapp::Config::Get_control_value( std::string name, double defval ) { + double value; + + auto rv = defval; // return value; set to default + if( jh == NULL ) { + return rv; + } + + jh->Unset_blob(); + if( jh->Set_blob( (char *) "controls" ) ) { + if( jh->Exists( name.c_str() ) ) { + rv = jh->Value( name.c_str() ); + } + } + + jh->Unset_blob(); + return rv; +} + + +/* + Convenience function. If value is undefined, then 0 is returned. +*/ +double xapp::Config::Get_control_value( std::string name ) { + return Get_control_value( name, 0.0 ); +} + + +// ---- notification support --------------------------------------------------------------- + + +/* + Accept the user's notification function, and data that it needs (pointer to + something unknown), and stash that as a callback. + + The fact that the user xAPP registers a callback also triggers the creation + of a thread to listen for changes on the config file. +*/ +void xapp::Config::Set_callback( notify_callback usr_func, void* usr_data ) { + cb = std::unique_ptr( new Config_cb( usr_func, usr_data ) ); + user_cb_data = usr_data; + + if( listener == NULL ) { // start thread if needed + listener = new std::thread( &xapp::Config::Listener, this ); + } +} + +} // namespace