bin/salome_utils.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 # ---
  22 # File   : salome_utils.py
  23 # Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
  24 # ---
  25
  26 ## @package salome_utils
  27 # \brief Set of utility functions used by SALOME python scripts.
  28
  29 #
  30 # Exported functions
  31 #
  32
  33 __all__ = [
  34     'getORBcfgInfo',
  35     'getHostFromORBcfg',
  36     'getPortFromORBcfg',
  37     'getUserName',
  38     'getHostName',
  39     'getShortHostName',
  40     'getAppName',
  41     'getPortNumber',
  42     'getTmpDir',
  43     'getHomeDir',
  44     'generateFileName',
  45     'makeTmpDir',
  46     'uniteFiles',
  47     ]
  48
  49 # ---
  50
  51 def _try_bool( arg ):
  52     """
  53     Check if specified parameter represents boolean value and returns its value.
  54     String values like 'True', 'TRUE', 'YES', 'Yes', 'y', 'NO', 'false', 'n', etc
  55     are supported.
  56     If <arg> does not represent a boolean, an exception is raised.
  57     """
  58     import types
  59     if type( arg ) == types.BooleanType  :
  60         return arg
  61     elif type( arg ) == types.StringType  :
  62         v = str( arg ).lower()
  63         if   v in [ "yes", "y", "true"  ]: return True
  64         elif v in [ "no",  "n", "false" ]: return False
  65         pass
  66     raise Exception("Not boolean value")
  67
  68 # ---
  69
  70 def getORBcfgInfo():
  71     """
  72     Get omniORB current configuration.
  73     Returns a list of three values: [ orb_version, host_name, port_number ].
  74
  75     The information is retrieved from the omniORB configuration file defined
  76     by the OMNIORB_CONFIG environment variable.
  77     If omniORB configuration file can not be accessed, a list of three empty
  78     strings is returned.
  79     """
  80     import os, re
  81     ret = [ "", "", "" ]
  82     try:
  83         f = open( os.getenv( "OMNIORB_CONFIG" ) )
  84         lines = f.readlines()
  85         f.close()
  86         regvar = re.compile( "(ORB)?InitRef.*corbaname::(.*):(\d+)\s*$" )
  87         for l in lines:
  88             try:
  89                 m = regvar.match( l )
  90                 if m:
  91                     if m.group(1) is None:
  92                         ret[0] = "4"
  93                     else:
  94                         ret[0] = "3"
  95                         pass
  96                     ret[1] = m.group(2)
  97                     ret[2] = m.group(3)
  98                     break
  99                 pass
 100             except:
 101                 pass
 102             pass
 103         pass
 104     except:
 105         pass
 106     return ret
 107
 108 # ---
 109
 110 def getHostFromORBcfg():
 111     """
 112     Get current omniORB host.
 113     """
 114     return getORBcfgInfo()[1]
 115 # ---
 116
 117 def getPortFromORBcfg():
 118     """
 119     Get current omniORB port.
 120     """
 121     return getORBcfgInfo()[2]
 122
 123 # ---
 124
 125 def getUserName():
 126     """
 127     Get user name:
 128     1. try USER environment variable
 129     2. if fails, return 'unknown' as default user name
 130     """
 131     import os
 132     return os.getenv( "USER", "unknown" ) # 'unknown' is default user name
 133
 134 # ---
 135
 136 def getHostName():
 137     """
 138     Get host name:
 139     1. try socket python module gethostname() function
 140     2. if fails, try HOSTNAME environment variable
 141     3. if fails, try HOST environment variable
 142     4. if fails, return 'unknown' as default host name
 143     """
 144     import os
 145     try:
 146         import socket
 147         host = socket.gethostname()
 148     except:
 149         host = None
 150         pass
 151     if not host: host = os.getenv("HOSTNAME")
 152     if not host: host = os.getenv("HOST")
 153     if not host: host = "unknown"           # 'unknown' is default host name
 154     return host
 155
 156 # ---
 157
 158 def getShortHostName():
 159     """
 160     Get short host name:
 161     1. try socket python module gethostname() function
 162     2. if fails, try HOSTNAME environment variable
 163     3. if fails, try HOST environment variable
 164     4. if fails, return 'unknown' as default host name
 165     """
 166     try:
 167         return getHostName().split('.')[0]
 168     except:
 169         pass
 170     return "unknown"           # 'unknown' is default host name
 171
 172 # ---
 173
 174 def getAppName():
 175     """
 176     Get application name:
 177     1. try APPNAME environment variable
 178     2. if fails, return 'SALOME' as default application name
 179     """
 180     import os
 181     return os.getenv( "APPNAME", "SALOME" ) # 'SALOME' is default user name
 182
 183 # ---
 184
 185 def getPortNumber(use_default=True):
 186     """
 187     Get current naming server port number:
 188     1. try NSPORT environment variable
 189     1. if fails, try to parse config file defined by OMNIORB_CONFIG environment variable
 190     2. if fails, return 2809 as default port number (if use_default is True) or None (id use_default is False)
 191     """
 192     import os
 193     try:
 194         return int( os.getenv( "NSPORT" ) )
 195     except:
 196         pass
 197     try:
 198         port = int( getPortFromORBcfg() )
 199         if port is not None: return port
 200     except:
 201         pass
 202     if use_default: return 2809 # '2809' is default port number
 203     return None
 204
 205 # ---
 206
 207 def getHomeDir():
 208     """
 209     Get home directory.
 210     """
 211     import os, sys
 212     if sys.platform == "win32":
 213         # for Windows the home directory is detected in the following way:
 214         # 1. try USERPROFILE env variable
 215         # 2. try combination of HOMEDRIVE and HOMEPATH env variables
 216         # 3. try HOME env variable
 217         # TODO: on Windows, also GetUserProfileDirectoryW() system function might be used
 218         dir = os.getenv("USERPROFILE")
 219         if not dir and os.getenv("HOMEDRIVE") and os.getenv("HOMEPATH"):
 220             dir = os.path.join(os.getenv("HOMEDRIVE"), os.getenv("HOMEPATH"))
 221         if not dir:
 222             dir = os.getenv("HOME")
 223         pass
 224     else:
 225         # for Linux: use HOME variable
 226         dir = os.getenv("HOME")
 227         pass
 228     return dir
 229 # ---
 230
 231 def getTmpDir():
 232     """
 233     Get directory to be used for the temporary files.
 234     """
 235     import os, sys
 236     if sys.platform == "win32":
 237         # for Windows: temporarily using home directory for tmp files;
 238         # to be replaced with TEMP environment variable later...
 239         dir = os.getenv("HOME")
 240     else:
 241         # for Linux: use /tmp/logs/{user} folder
 242         dir = os.path.join( '/tmp', 'logs', getUserName() )
 243         pass
 244     return dir
 245
 246 # ---
 247
 248 def generateFileName( dir, prefix = None, suffix = None, extension = None,
 249                       unique = False, separator = "_", hidden = False, **kwargs ):
 250     """
 251     Generate file name by sepecified parameters. If necessary, file name
 252     can be generated to be unique.
 253
 254     Parameters:
 255     - dir       : directory path
 256     - prefix    : file prefix (not added by default)
 257     - suffix    : file suffix (not added by default)
 258     - extension : file extension (not added by default)
 259     - unique    : if this parameter is True, the unique file name is generated:
 260     in this case, if the file with the generated name already exists
 261     in the <dir> directory, an integer suffix is added to the end of the
 262     file name. This parameter is False by default.
 263     - separator : separator of the words ('_' by default)
 264     - hidden    : if this parameter is True, the file name is prepended by . (dot)
 265     symbol. This parameter is False by default.
 266
 267     Other keyword parameters are:
 268     - with_username : 'add user name' flag/option:
 269       * boolean value can be passed to determine user name automatically
 270       * string value to be used as user name
 271     - with_hostname : 'add host name' flag/option:
 272       * boolean value can be passed to determine host name automatically
 273       * string value to be used as host name
 274     - with_port     : 'add port number' flag/option:
 275       * boolean value can be passed to determine port number automatically
 276       * string value to be used as port number
 277     - with_app      : 'add application name' flag/option:
 278       * boolean value can be passed to determine application name automatically
 279       * string value to be used as application name
 280     All <with_...> parameters are optional.
 281     """
 282     supported = [ 'with_username', 'with_hostname', 'with_port', 'with_app' ]
 283     from launchConfigureParser import verbose
 284     filename = []
 285     # separator
 286     if separator is None:
 287         separator = ""
 288         pass
 289     else:
 290         separator = str( separator )
 291         pass
 292     # prefix (if specified)
 293     if prefix is not None:
 294         filename.append( str( prefix ) )
 295         pass
 296     # additional keywords
 297     ### check unsupported parameters
 298     for kw in kwargs:
 299         if kw not in supported and verbose():
 300             print 'Warning! salome_utilitie.py: generateFileName(): parameter %s is not supported' % kw
 301             pass
 302         pass
 303     ### process supported keywords
 304     for kw in supported:
 305         if kw not in kwargs: continue
 306         ### user name
 307         if kw == 'with_username':
 308             try:
 309                 # auto user name ?
 310                 if _try_bool( kwargs[kw] ): filename.append( getUserName() )
 311                 pass
 312             except:
 313                 # user name given as parameter
 314                 filename.append( kwargs[kw] )
 315                 pass
 316             pass
 317         ### host name
 318         elif kw == 'with_hostname':
 319             try:
 320                 # auto host name ?
 321                 if _try_bool( kwargs[kw] ): filename.append( getShortHostName() )
 322                 pass
 323             except:
 324                 # host name given as parameter
 325                 filename.append( kwargs[kw] )
 326                 pass
 327             pass
 328         ### port number
 329         elif kw == 'with_port':
 330             try:
 331                 # auto port number ?
 332                 if _try_bool( kwargs[kw] ): filename.append( str( getPortNumber() ) )
 333                 pass
 334             except:
 335                 # port number given as parameter
 336                 filename.append( str( kwargs[kw] ) )
 337                 pass
 338             pass
 339         ### application name
 340         elif kw == 'with_app':
 341             try:
 342                 # auto application name ?
 343                 if _try_bool( kwargs[kw] ): filename.append( getAppName() )
 344                 pass
 345             except:
 346                 # application name given as parameter
 347                 filename.append( kwargs[kw] )
 348                 pass
 349             pass
 350         pass
 351     # suffix (if specified)
 352     if suffix is not None:
 353         filename.append( str( suffix ) )
 354         pass
 355     # raise an exception if file name is empty
 356     if not filename:
 357         raise Exception("Empty file name")
 358     #
 359     if extension is not None and extension.startswith("."): extension = extension[1:]
 360     #
 361     import os
 362     name = separator.join( filename )
 363     if hidden: name = "." + name                       # add dot for hidden files
 364     if extension: name = name + "." + str( extension ) # add extension if defined
 365     name = os.path.join( dir, name )
 366     if unique:
 367         # create unique file name
 368         index = 0
 369         while os.path.exists( name ):
 370             index = index + 1
 371             name = separator.join( filename ) + separator + str( index )
 372             if hidden: name = "." + name                       # add dot for hidden files
 373             if extension: name = name + "." + str( extension ) # add extension if defined
 374             name = os.path.join( dir, name )
 375             pass
 376         pass
 377     return os.path.normpath(name)
 378
 379 # ---
 380
 381 def makeTmpDir( path, mode=0777 ):
 382     """
 383     Make temporary directory with the specified path.
 384     If the directory exists then clear its contents.
 385
 386     Parameters:
 387     - path : absolute path to the directory to be created.
 388     - mode : access mode
 389     """
 390     import os
 391     if os.path.exists( path ):
 392         import sys
 393         if sys.platform == "win32":
 394             os.system( "rmdir /S /Q " + '"' + path + '"' )
 395             os.system( "mkdir " + '"' + path + '"' )
 396         else:
 397             os.system( "rm -rf " + path + "/*" )
 398     else:
 399         dirs = path.split("/")
 400         shift1 = shift2 = 0
 401         if not dirs[0]: shift1 = 1
 402         if dirs[-1]: shift2 = 1
 403         for i in range(1+shift1,len(dirs)+shift2):
 404             p = "/".join(dirs[:i])
 405             try:
 406                 os.mkdir(p, mode)
 407                 os.chmod(p, mode)
 408             except:
 409                 pass
 410
 411 # ---
 412
 413 def uniteFiles( src_file, dest_file ):
 414     """
 415     Unite contents of the source file with contents of the destination file
 416     and put result of the uniting to the destination file.
 417     If the destination file does not exist then the source file is simply
 418     copied to its path.
 419
 420     Parameters:
 421     - src_file  : absolute path to the source file
 422     - dest_file : absolute path to the destination file
 423     """
 424     import os
 425
 426     if not os.path.exists( src_file ):
 427         return
 428         pass
 429
 430     if os.path.exists( dest_file ):
 431         # add a symbol of new line to contents of the destination file (just in case)
 432         dest = open( dest_file, 'r' )
 433         dest_lines = dest.readlines()
 434         dest.close()
 435
 436         dest_lines.append( "\n" )
 437
 438         dest = open( dest_file, 'w' )
 439         dest.writelines( dest_lines )
 440         dest.close()
 441
 442         import sys
 443         if sys.platform == "win32":
 444             command = "type " + '"' + src_file + '"' + " >> " + '"' + dest_file + '"'
 445         else:
 446             command = "cat " + src_file + " >> " + dest_file
 447             pass
 448         pass
 449     else:
 450         import sys
 451         if sys.platform == "win32":
 452             command = "copy " + '"' + src_file + '"' + " " + '"' + dest_file + '"' + " > nul"
 453         else:
 454             command = "cp " + src_file + " " + dest_file
 455             pass
 456         pass
 457
 458     os.system( command )
 459
 460 # --
 461
 462 _verbose = None
 463
 464 def verbose():
 465     """
 466     Get verbosity level. Default verbosity level is specified via the environment variable
 467     SALOME_VERBOSE, e.g.:
 468     [bash %] export SALOME_VERBOSE=1
 469     The function setVerbose() can be used to change verbosity level explicitly.
 470     """
 471     global _verbose
 472     # verbose has already been called
 473     if _verbose is not None:
 474         return _verbose
 475     # first time
 476     try:
 477         from os import getenv
 478         _verbose = int(getenv('SALOME_VERBOSE'))
 479     except:
 480         _verbose = 0
 481         pass
 482     #
 483     return _verbose
 484
 485 def setVerbose(level):
 486     """
 487     Change verbosity level. The function verbose() can be used to get current verbosity level.
 488     """
 489     global _verbose
 490     _verbose = level
 491     return
 492