cmframework/src/cmframework/server/cmargs.py

   1 # Copyright 2019 Nokia
   2
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14 import sys
  15 import argparse
  16 import os
  17
  18 from ConfigParser import SafeConfigParser
  19
  20 from cmframework.apis import cmerror
  21 from cmframework.utils import cmlogger
  22
  23
  24 class CMArgsParser(object):
  25     def __init__(self, prog):
  26         self.prog = prog
  27         self.ip = None
  28         self.port = None
  29         self.verbose = False
  30         self.log_level = cmlogger.CMLogger.str_to_level('debug')
  31         self.log_dest = cmlogger.CMLogger.str_to_dest('syslog')
  32         self.disable_remote_activation = False
  33         self.rmq_host = None
  34         self.rmq_port = None
  35         self.activators = None
  36         self.validators = None
  37         self.rmq_ip = None
  38         self.backend_uri = None
  39         self.backend_api = None
  40         self.filename = None
  41         self.inventory_handlers = None
  42         self.inventory_data = None
  43         self.install_phase = False
  44         self.activationstate_handler_uri = None
  45         self.activationstate_handler_api = None
  46         self.activator_workers = 1
  47         self.snapshot_handler_uri = None
  48         self.snapshot_handler_api = None
  49         self.alarmhandler_api = None
  50
  51     def parse(self, args):
  52         argparse.ArgumentParser(description='Configuration Management Server',
  53                                 prog=self.prog)
  54
  55         if '--file' in args:
  56             self.parse_config(args)
  57         else:
  58             self.parse_cmd_line(args)
  59
  60     def parse_config(self, args):
  61         parser = argparse.ArgumentParser(description='Configuration Management Server',
  62                                          prog=self.prog)
  63
  64         parser.add_argument('--file',
  65                             dest='filename',
  66                             required=True,
  67                             type=str,
  68                             action='store')
  69         try:
  70             args = parser.parse_args(args)
  71             self.filename = args.filename
  72         except Exception as error:
  73             raise cmerror.CMError(str(error))
  74
  75         self.parse_config_file()
  76
  77     def parse_config_file(self):
  78         config = SafeConfigParser(
  79             {'log_level': cmlogger.CMLogger.level_to_str(self.log_level),
  80              'log_dest': cmlogger.CMLogger.dest_to_str(self.log_dest),
  81              'verbose': repr(self.verbose),
  82              'disable_remote_activation': repr(self.disable_remote_activation),
  83              'activator_workers': '10',
  84              'alarmhandler_api': 'cmframework.lib.cmalarmhandler_dummy.AlarmHandler_Dummy',
  85              'snapshot_handler_api': ''})
  86         try:
  87             config.read(self.filename)
  88             self.ip = config.get('cmserver', 'ip')
  89             self.port = config.getint('cmserver', 'port')
  90             self.backend_api = config.get('cmserver', 'backend_api')
  91             self.backend_uri = config.get('cmserver', 'backend_uri')
  92             self.verbose = config.getboolean('cmserver', 'verbose')
  93             self.log_level = cmlogger.CMLogger.str_to_level(config.get('cmserver', 'log_level'))
  94             self.log_dest = cmlogger.CMLogger.str_to_dest(config.get('cmserver', 'log_dest'))
  95             self.validators = CMArgsParser.dir_parser(config.get('cmserver', 'validators'))
  96             self.activators = CMArgsParser.dir_parser(config.get('cmserver', 'activators'))
  97             self.disable_remote_activation = \
  98                 config.getboolean('cmserver', 'disable_remote_activation')
  99             if not self.disable_remote_activation:
 100                 self.rmq_ip = config.get('cmserver', 'rmq_ip')
 101                 self.rmq_port = config.getint('cmserver', 'rmq_port')
 102             self.inventory_handlers = CMArgsParser.dir_parser(config.get('cmserver',
 103                                                                          'inventory_handlers'))
 104             self.inventory_data = config.get('cmserver', 'inventory_data')
 105             self.install_phase = config.getboolean('cmserver', 'install_phase')
 106             self.activationstate_handler_uri = config.get('cmserver', 'activationstate_handler_uri')
 107             self.activationstate_handler_api = config.get('cmserver', 'activationstate_handler_api')
 108             self.activator_workers = config.getint('cmserver', 'activator_workers')
 109             self.snapshot_handler_uri = config.get('cmserver', 'snapshot_handler_uri')
 110             self.snapshot_handler_api = config.get('cmserver', 'snapshot_handler_api')
 111             self.alarmhandler_api = config.get('cmserver', 'alarmhandler_api')
 112         except Exception as error:
 113             raise cmerror.CMError(str(error))
 114
 115     def parse_cmd_line(self, args):
 116         parser = argparse.ArgumentParser(description='Configuration Management Server',
 117                                          prog=self.prog)
 118
 119         parser.add_argument('--ip',
 120                             required=True,
 121                             help='The IP address to listen to',
 122                             type=str,
 123                             action='store')
 124
 125         parser.add_argument('--port',
 126                             required=True,
 127                             help='The port number used for listening',
 128                             type=int,
 129                             action='store')
 130
 131         parser.add_argument('--backend-api',
 132                             dest='backend_api',
 133                             metavar='BACKEND-API',
 134                             required=True,
 135                             help='The module.class implementing the backend api',
 136                             type=str,
 137                             action='store')
 138
 139         parser.add_argument('--backend-uri',
 140                             dest='backend_uri',
 141                             metavar='BACKEND-URI',
 142                             required=True,
 143                             help='The uri needed by the backend api',
 144                             type=str, action='store')
 145
 146         parser.add_argument('--log-level',
 147                             dest='log_level',
 148                             metavar='LOG-LEVEL',
 149                             required=False,
 150                             help=('The enabled logging level, possible values are '
 151                                   '{debug, info, warn, error}'),
 152                             type=CMArgsParser.log_level_parser,
 153                             default=self.log_level,
 154                             action='store')
 155
 156         parser.add_argument('--log-dest',
 157                             dest='log_dest',
 158                             metavar='LOG-DEST',
 159                             required=False,
 160                             help='The logs destination, possible values are {console, syslog}',
 161                             type=CMArgsParser.log_dest_parser,
 162                             default=self.log_dest,
 163                             action='store')
 164
 165         parser.add_argument('--verbose',
 166                             dest='verbose',
 167                             required=False,
 168                             default=self.verbose,
 169                             help='Enable verbose mode',
 170                             action='store_true')
 171
 172         parser.add_argument('--validators',
 173                             dest='validators',
 174                             metavar='VALIDATORS-PATH',
 175                             required=True,
 176                             help='The full path were validatation plugin(s) are located',
 177                             type=CMArgsParser.dir_parser,
 178                             action='store')
 179
 180         parser.add_argument('--activators',
 181                             dest='activators',
 182                             metavar='ACTIVATORS-PATH',
 183                             required=True,
 184                             help='The full path were activation plugin(s) are located',
 185                             type=CMArgsParser.dir_parser,
 186                             action='store')
 187
 188         parser.add_argument('--disable-remote-activation',
 189                             dest='disable_remote_activation',
 190                             required=False,
 191                             default=self.disable_remote_activation,
 192                             help='Enable running activators in the target nodes',
 193                             action='store_true')
 194
 195         parser.add_argument('--rmq-ip',
 196                             dest='rmq_ip',
 197                             metavar='RMQ-IP',
 198                             required=False,
 199                             help='RMQ broker IP address',
 200                             type=str,
 201                             action='store')
 202
 203         parser.add_argument('--rmq-port',
 204                             dest='rmq_port',
 205                             metavar='RMQ-PORT',
 206                             required=False,
 207                             help='RMQ broker port number',
 208                             type=int,
 209                             action='store')
 210
 211         parser.add_argument('--inventory-handlers',
 212                             dest='inventory_handlers',
 213                             metavar='INVENTORY-HANDLERS-PATH',
 214                             required=True,
 215                             help='The full path were inventory handlers are located',
 216                             type=CMArgsParser.dir_parser,
 217                             action='store')
 218
 219         parser.add_argument('--inventory-data',
 220                             dest='inventory_data',
 221                             metavar='INVENTORY-DATA',
 222                             required=True,
 223                             help='The full path for the inventory data file',
 224                             type=str,
 225                             action='store')
 226
 227         parser.add_argument('--install-phase',
 228                             dest='install_phase',
 229                             required=False,
 230                             default=False,
 231                             help='Indicate install phase startup',
 232                             action='store_true')
 233
 234         parser.add_argument('--activationstate-handler-api',
 235                             dest='activationstate_handler_api',
 236                             metavar='ACTIVATIONSTATE-HANDLER-API',
 237                             required=True,
 238                             help='The module.class implementing the activationstate handler api',
 239                             type=str,
 240                             action='store')
 241
 242         parser.add_argument('--activationstate-handler-uri',
 243                             dest='activationstate_handler_uri',
 244                             metavar='ACTIVATIONSTATE-HANDLER-URI',
 245                             required=True,
 246                             help='The uri needed by the activationstate handler uri',
 247                             type=str, action='store')
 248
 249         parser.add_argument('--activator-workers',
 250                             dest='activator_workers',
 251                             metavar='ACTIVATOR_WORKERS',
 252                             required=False,
 253                             default=1,
 254                             help='Number of activator workers',
 255                             type=int,
 256                             action='store')
 257
 258         parser.add_argument('--snapshot-handler-api',
 259                             dest='snapshot_handler_api',
 260                             metavar='SNAPSHOT-HANDLER-API',
 261                             required=True,
 262                             help='The module.class implementing the snapshot handler api',
 263                             type=str,
 264                             action='store')
 265
 266         parser.add_argument('--snapshot-handler-uri',
 267                             dest='snapshot_handler_uri',
 268                             metavar='SNAPSHOT-HANDLER-URI',
 269                             required=False,
 270                             default='',
 271                             help='The uri needed by the snapshot handler uri',
 272                             type=str, action='store')
 273
 274         parser.add_argument('--alarmhandler-api',
 275                             dest='alarmhandler_api',
 276                             metavar='ALARMHANDLER-API',
 277                             required=True,
 278                             help='The module.class implementing the alarmhandler api',
 279                             type=str,
 280                             action='store')
 281
 282         try:
 283             args = parser.parse_args(args)
 284             self.ip = args.ip
 285             self.port = args.port
 286             self.backend_api = args.backend_api
 287             self.backend_uri = args.backend_uri
 288             self.verbose = args.verbose
 289             self.log_level = args.log_level
 290             self.log_dest = args.log_dest
 291             self.validators = args.validators
 292             self.activators = args.activators
 293             self.disable_remote_activation = args.disable_remote_activation
 294             if not self.disable_remote_activation:
 295                 self.rmq_ip = args.rmq_ip
 296                 self.rmq_port = args.rmq_port
 297             self.inventory_handlers = args.inventory_handlers
 298             self.inventory_data = args.inventory_data
 299             self.install_phase = args.install_phase
 300             self.activationstate_handler_api = args.activationstate_handler_api
 301             self.activationstate_handler_uri = args.activationstate_handler_uri
 302             self.activator_workers = args.activator_workers
 303             self.snapshot_handler_api = args.snapshot_handler_api
 304             self.snapshot_handler_uri = args.snapshot_handler_uri
 305             self.alarmhandler_api = args.alarmhandler_api
 306         except Exception as error:
 307             raise cmerror.CMError(str(error))
 308
 309     @staticmethod
 310     def log_level_parser(level):
 311         try:
 312             return cmlogger.CMLogger.str_to_level(level)
 313         except cmerror.CMError as exp:
 314             raise argparse.ArgumentTypeError(str(exp))
 315
 316     @staticmethod
 317     def log_dest_parser(dest):
 318         try:
 319             return cmlogger.CMLogger.str_to_dest(dest)
 320         except cmerror.CMError as exp:
 321             raise argparse.ArgumentTypeError(str(exp))
 322
 323     @staticmethod
 324     def dir_parser(path):
 325         if os.path.isdir(path):
 326             return path
 327         raise argparse.ArgumentTypeError('Not a directory')
 328
 329     def get_ip(self):
 330         return self.ip
 331
 332     def get_port(self):
 333         return self.port
 334
 335     def get_backend_api(self):
 336         return self.backend_api
 337
 338     def get_backend_uri(self):
 339         return self.backend_uri
 340
 341     def get_log_level(self):
 342         return self.log_level
 343
 344     def get_log_dest(self):
 345         return self.log_dest
 346
 347     def get_verbose(self):
 348         return self.verbose
 349
 350     def get_validators(self):
 351         return self.validators
 352
 353     def get_activators(self):
 354         return self.activators
 355
 356     def get_disable_remote_activation(self):
 357         return self.disable_remote_activation
 358
 359     def get_rmq_ip(self):
 360         return self.rmq_ip
 361
 362     def get_rmq_port(self):
 363         return self.rmq_port
 364
 365     def get_inventory_handlers(self):
 366         return self.inventory_handlers
 367
 368     def get_inventory_data(self):
 369         return self.inventory_data
 370
 371     def is_install_phase(self):
 372         return self.install_phase
 373
 374     def get_activationstate_handler_api(self):
 375         return self.activationstate_handler_api
 376
 377     def get_activationstate_handler_uri(self):
 378         return self.activationstate_handler_uri
 379
 380     def get_activator_workers(self):
 381         return self.activator_workers
 382
 383     def get_snapshot_handler_api(self):
 384         return self.snapshot_handler_api
 385
 386     def get_snapshot_handler_uri(self):
 387         return self.snapshot_handler_uri
 388
 389     def get_alarmhandler_api(self):
 390         return self.alarmhandler_api
 391
 392
 393 def main():
 394     cm_parser = CMArgsParser('cmserver')
 395     try:
 396         cm_parser.parse(sys.argv[1:])
 397         print 'ip = %s' % cm_parser.get_ip()
 398         print 'port = %d' % cm_parser.get_port()
 399         print 'backend-api = %s' % cm_parser.get_backend_api()
 400         print 'backend-uri = %s' % cm_parser.get_backend_uri()
 401         print 'log-level = %s' % cmlogger.CMLogger.level_to_str(cm_parser.get_log_level())
 402         print 'log-dest = %s' % cmlogger.CMLogger.dest_to_str(cm_parser.get_log_dest())
 403         print 'verbose = %s' % repr(cm_parser.get_verbose())
 404         print 'validators = %s' % repr(cm_parser.get_validators())
 405         print 'activators = %s' % repr(cm_parser.get_activators())
 406         print 'rmq-ip = %s' % repr(cm_parser.get_rmq_ip())
 407         print 'rmq-port = %s' % repr(cm_parser.get_rmq_port())
 408         print 'inventory-handlers = %s' % repr(cm_parser.get_inventory_handlers())
 409         print 'inventory-data = %s' % repr(cm_parser.get_inventory_data())
 410         print 'install-phase = %s' % repr(cm_parser.is_install_phase())
 411         print 'activationstate-handler-api = %s' % repr(cm_parser.get_activationstate_handler_api())
 412         print 'activationstate-handler-uri = %s' % repr(cm_parser.get_activationstate_handler_uri())
 413         print 'activator-workers = %s' % repr(cm_parser.get_activator_workers())
 414         print 'snapshot-handler-api = %s' % repr(cm_parser.get_snapshot_handler_api())
 415         print 'snapshot-handler-uri = %s' % repr(cm_parser.get_snapshot_handler_uri())
 416         print 'alarmhandler-api = %s' % cm_parser.get_alarmhandler_api()
 417     except cmerror.CMError as error:
 418         print 'Got error %s' % str(error)
 419         sys.exit(1)
 420
 421
 422 if __name__ == '__main__':
 423     main()