src/config/config.cpp

   1 // vi: ts=4 sw=4 noet:
   2 /*
   3 ==================================================================================
   4     Copyright (c) 2020 AT&T Intellectual Property.
   5     Copyright (c) 2020 Nokia
   6
   7    Licensed under the Apache License, Version 2.0 (the "License");
   8    you may not use this file except in compliance with the License.
   9    You may obtain a copy of the License at
  10
  11        http://www.apache.org/licenses/LICENSE-2.0
  12
  13    Unless required by applicable law or agreed to in writing, software
  14    distributed under the License is distributed on an "AS IS" BASIS,
  15    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16    See the License for the specific language governing permissions and
  17    limitations under the License.
  18 ==================================================================================
  19 */
  20
  21 /*
  22     Mnemonic:   config.cpp
  23     Abstract:   Support for reading config json.
  24
  25                                 The config structure allows simplified parsing of the json and
  26                                 easy access to the things we belive all xAPPs will use (port
  27                                 digging form the named "interface" and control settings). This
  28                                 also supports the watching on the file and driving the user
  29                                 callback when the config file appears to have changed (write
  30                                 close on the file).
  31
  32                                 Accessing information from the json is serialised (mutex) as
  33                                 with the random nature of file updates, we must ensure that
  34                                 we don't change the json as we're trying to read from it. Locking
  35                                 should be transparent to the user xAPP.
  36
  37     Date:       27 July 2020
  38     Author:     E. Scott Daniels
  39 */
  40
  41 #include <errno.h>
  42 #include <poll.h>
  43 #include <stdlib.h>
  44 #include <sys/inotify.h>
  45 #include <unistd.h>
  46 #include <string.h>
  47
  48 #include <iostream>
  49 #include <sstream>
  50 #include <fstream>
  51 #include <thread>
  52 #include <memory>
  53
  54 #include "jhash.hpp"
  55 #include "config.hpp"
  56 #include "config_cb.hpp"
  57
  58 namespace xapp {
  59
  60
  61 // ----- private things --------
  62 /*
  63         Notification listener. This function is started in a thread and listens for
  64         changes to the config file. When it sees an interesting change (write close)
  65         to the file, then it will read the new set of json, parse it, and drive the
  66         user callback.
  67
  68         We must watch the directory containing the file as if the file is edited and
  69         replaced it's likely saved with a different referencing inode. We'd see the
  70         first change, but not any subsequent changes as the inotify is based on inodes
  71         and not directory entries.
  72 */
  73 void xapp::Config::Listener( ) {
  74         struct inotify_event*   ie;             // event that popped
  75         int ifd;                                                // the inotify file des
  76         int     wfd;                                            // the watched file des
  77         int     n;
  78         char    rbuf[4096];                             // large read buffer as the event is var len
  79         char*   dname;                                  // directory name
  80         char*   bname;                                  // basename
  81         char*   tok;
  82
  83         ifd = inotify_init1( 0 );               // initialise watcher setting blocking read (no option)
  84         if( ifd < 0 ) {
  85                 fprintf( stderr, "<XFCPP> ### ERR ### unable to initialise file watch %s\n", strerror( errno ) );
  86                 return;
  87         }
  88
  89         dname = strdup( fname.c_str() );                                        // defrock the file name into dir and basename
  90         if( (tok = strrchr( dname, '/' )) != NULL ) {
  91                 *tok = 0;
  92                 bname = strdup( tok+1 );
  93         } else {
  94                 free( dname );
  95                 dname = strdup( "." );
  96                 bname = strdup( fname.c_str() );
  97         }
  98
  99         wfd = inotify_add_watch( ifd, (char *) dname, IN_MOVED_TO | IN_CLOSE_WRITE );           // we only care about close write changes
 100
 101         if( wfd < 0 ) {
 102                 fprintf( stderr, "<XFCPP> ### ERR ### unable to add watch on config file %s: %s\n", fname.c_str(), strerror( errno ) );
 103                 return;
 104         }
 105
 106         while( true ) {
 107                 n = read( ifd, rbuf, sizeof( rbuf ) );                          // read the event
 108                 if( n < 0  ) {
 109                         if( errno == EAGAIN ) {
 110                                 continue;
 111                         } else {
 112                                 fprintf( stderr, "<XFCPP ### CRIT ### config listener read err: %s\n", strerror( errno ) );
 113                                 return;
 114                         }
 115                 }
 116
 117                 ie = (inotify_event *) rbuf;
 118                 if( ie->len > 0 && strcmp( bname, ie->name ) == 0  ) {
 119                         // TODO: lock
 120                         auto njh = jparse( fname );                                                     // reparse the file
 121                         // TODO: unlock
 122
 123                         if( njh != NULL && cb != NULL ) {                               // good parse, save and drive user callback
 124                                 jh = njh;
 125                                 cb->Drive_cb( *this, user_cb_data );
 126                         }
 127                 }
 128         }
 129 }
 130
 131
 132 /*
 133         Read a file containing json and parse into a framework Jhash.
 134
 135         Using C i/o will speed this up, but I can't imagine that we need
 136         speed reading the config file once in a while.
 137         The file read comes from a stack overflow example:
 138                 stackoverflow.com/questions/2912520/read-file-contents-into-a-string-in-c
 139 */
 140 std::shared_ptr<xapp::Jhash> xapp::Config::jparse( std::string ufname ) {
 141         fname = ufname;
 142
 143         std::ifstream ifs( fname );
 144         std::string st( (std::istreambuf_iterator<char>( ifs ) ), (std::istreambuf_iterator<char>() ) );
 145
 146         auto new_jh = std::shared_ptr<xapp::Jhash>( new xapp::Jhash( st.c_str() ) );
 147         return  new_jh->Parse_errors() ? NULL : new_jh;
 148 }
 149
 150 /*
 151         Read the configuration file from what we find as the filename in the environment (assumed
 152         to be referenced by $XAPP_DESCRIPTOR_PATH/config-file.json. If the env var is not
 153         defined we assume ./.  The data is then parsed with the assumption that it's json.
 154
 155         The actual meaning of the environment variable is confusing. The name is "path" which
 156         should mean that this is the directory in which the config file lives, but the examples
 157         elsewhere suggest that this is a filename (either fully qualified or relative). For now
 158         we will assume that it's a file name, though we could add some intelligence to determine
 159         if it's a directory name or not if it comes to it.
 160 */
 161 std::shared_ptr<xapp::Jhash> xapp::Config::jparse( ) {
 162         char*   data;
 163
 164         if( (data = getenv( (char *) "XAPP_DESCRIPTOR_PATH" )) == NULL ) {
 165                 data =  (char *) "./config-file.json";
 166         }
 167
 168         return jparse( std::string( data ) );
 169 }
 170
 171 // --------------------- construction, destruction -------------------------------------------
 172
 173 /*
 174         By default expect to find XAPP_DESCRIPTOR_PATH in the environment and assume that it
 175         is the directory name where we can find config-file.json. The build process will
 176         read and parse the json allowing the user xAPP to invoke the supplied  "obvious"
 177         functions to retrieve data.  If there is something in an xAPP's config that isn't
 178         standard, it can get the raw Jhash object and go at it directly. The idea is that
 179         the common things should be fairly painless to extract from the json goop.
 180 */
 181 xapp::Config::Config() :
 182         jh( jparse() ),
 183         listener( NULL )
 184 { /* empty body */ }
 185
 186 /*
 187         Similar, except that it allows the xAPP to supply the filename (testing?)
 188 */
 189 xapp::Config::Config( std::string fname) :
 190         jh( jparse( fname ) ),
 191         listener( NULL )
 192 { /* empty body */ }
 193
 194
 195 /*
 196         Read and return the raw file blob as a single string. User can parse, or do
 197         whatever they need (allows non-json things if necessary).
 198 */
 199 std::string xapp::Config::Get_contents( ) {
 200         std::string rv = "";
 201
 202         if( ! fname.empty() ) {
 203                 std::ifstream ifs( fname );
 204                 std::string st( (std::istreambuf_iterator<char>( ifs ) ), (std::istreambuf_iterator<char>() ) );
 205                 rv = st;
 206         }
 207
 208         return rv;
 209 }
 210
 211 // ----- convience function for things we think an xAPP will likely need to pull from the config
 212
 213
 214 /*
 215         Suss out the port for the named "interface". The interface is likely the application
 216         name.
 217 */
 218 std::string xapp::Config::Get_port( std::string name ) {
 219         int i;
 220         int     nele = 0;
 221         double value;
 222         std::string rv = "";            // result value
 223         std::string pname;                      // element port name in the json
 224
 225         if( jh == NULL ) {
 226                 return rv;
 227         }
 228
 229         jh->Unset_blob();
 230         if( jh->Set_blob( (char *) "messaging" ) ) {
 231                 nele = jh->Array_len( (char *) "ports" );
 232                 for( i = 0; i < nele; i++ ) {
 233                         if( jh->Set_blob_ele( (char *) "ports", i ) ) {
 234                                 pname = jh->String( (char *) "name" );
 235                                 if( pname.compare( name ) == 0 ) {                              // this element matches the name passed in
 236                                         value = jh->Value( (char *) "port" );
 237                                         rv = std::to_string( (int) value );
 238                                         jh->Unset_blob( );                                                      // leave hash in a known state
 239                                         return rv;
 240                                 }
 241                         }
 242
 243                         jh->Unset_blob( );                                                              // Jhash requires bump to root, and array reselct to move to next ele
 244                         jh->Set_blob( (char *) "messaging" );
 245                 }
 246         }
 247
 248         jh->Unset_blob();
 249         return rv;
 250 }
 251
 252 /*
 253         Suss out the named string from the controls object. If the resulting value is
 254         missing or "", then the default is returned.
 255 */
 256 std::string xapp::Config::Get_control_str( std::string name, std::string defval ) {
 257         std::string value;
 258         std::string rv;                         // result value
 259
 260         rv = defval;
 261         if( jh == NULL ) {
 262                 return rv;
 263         }
 264
 265         jh->Unset_blob();
 266         if( jh->Set_blob( (char *) "controls" ) ) {
 267                 if( jh->Exists( name.c_str() ) )  {
 268                         value = jh->String( name.c_str() );
 269                         if( value.compare( "" ) != 0 ) {
 270                                 rv = value;
 271                         }
 272                 }
 273         }
 274
 275         jh->Unset_blob();
 276         return rv;
 277 }
 278
 279 /*
 280         Convenience funciton without default. "" returned if not found.
 281         No default value; returns "" if not set.
 282 */
 283 std::string xapp::Config::Get_control_str( std::string name ) {
 284         return Get_control_str( name, "" );
 285 }
 286
 287 /*
 288         Suss out the named field from the controls object with the assumption that it is a boolean.
 289         If the resulting value is missing then the defval is used.
 290 */
 291 bool xapp::Config::Get_control_bool( std::string name, bool defval ) {
 292         bool value;
 293         bool rv;                                // result value
 294
 295         rv = defval;
 296         if( jh == NULL ) {
 297                 return rv;
 298         }
 299
 300         jh->Unset_blob();
 301         if( jh->Set_blob( (char *) "controls" ) ) {
 302                 if( jh->Exists( name.c_str() ) )  {
 303                         rv = jh->Bool( name.c_str() );
 304                 }
 305         }
 306
 307         jh->Unset_blob();
 308         return rv;
 309 }
 310
 311
 312 /*
 313         Convenience function without default.
 314 */
 315 bool xapp::Config::Get_control_bool( std::string name ) {
 316         return Get_control_bool( name, false );
 317 }
 318
 319
 320 /*
 321         Suss out the named field from the controls object with the assumption that it is a value (float/int).
 322         If the resulting value is missing then the defval is used.
 323 */
 324 double xapp::Config::Get_control_value( std::string name, double defval ) {
 325         double value;
 326
 327         auto rv = defval;                               // return value; set to default
 328         if( jh == NULL ) {
 329                 return rv;
 330         }
 331
 332         jh->Unset_blob();
 333         if( jh->Set_blob( (char *) "controls" ) ) {
 334                 if( jh->Exists( name.c_str() ) )  {
 335                         rv = jh->Value( name.c_str() );
 336                 }
 337         }
 338
 339         jh->Unset_blob();
 340         return rv;
 341 }
 342
 343
 344 /*
 345         Convenience function. If value is undefined, then 0 is returned.
 346 */
 347 double xapp::Config::Get_control_value( std::string name ) {
 348         return Get_control_value( name, 0.0 );
 349 }
 350
 351
 352 // ---- notification support ---------------------------------------------------------------
 353
 354
 355 /*
 356         Accept the user's notification function, and data that it needs (pointer to
 357         something unknown), and stash that as a callback.
 358
 359         The fact that the user xAPP registers a callback also triggers the creation
 360         of a thread to listen for changes on the config file.
 361 */
 362 void xapp::Config::Set_callback( notify_callback usr_func, void* usr_data ) {
 363         cb = std::unique_ptr<Config_cb>( new Config_cb( usr_func, usr_data ) );
 364         user_cb_data = usr_data;
 365
 366         if( listener == NULL ) {                                // start thread if needed
 367                 listener = new std::thread( &xapp::Config::Listener, this );
 368         }
 369 }
 370
 371 } // namespace