bin/salome_utils.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2012  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     port = getPortFromORBcfg()
 198     if port is not None: return port
 199     if use_default: return 2809 # '2809' is default port number
 200     return None
 201
 202 # ---
 203
 204 def getHomeDir():
 205     """
 206     Get home directory.
 207     """
 208     import os, sys
 209     if sys.platform == "win32":
 210         # for Windows the home directory is detected in the following way:
 211         # 1. try USERPROFILE env variable
 212         # 2. try combination of HOMEDRIVE and HOMEPATH env variables
 213         # 3. try HOME env variable
 214         # TODO: on Windows, also GetUserProfileDirectoryW() system function might be used
 215         dir = os.getenv("USERPROFILE")
 216         if not dir and os.getenv("HOMEDRIVE") and os.getenv("HOMEPATH"):
 217             dir = os.path.join(os.getenv("HOMEDRIVE"), os.getenv("HOMEPATH"))
 218         if not dir:
 219             dir = os.getenv("HOME")
 220         pass
 221     else:
 222         # for Linux: use HOME variable
 223         dir = os.getenv("HOME")
 224         pass
 225     return dir
 226 # ---
 227
 228 def getTmpDir():
 229     """
 230     Get directory to be used for the temporary files.
 231     """
 232     import os, sys
 233     if sys.platform == "win32":
 234         # for Windows: temporarily using home directory for tmp files;
 235         # to be replaced with TEMP environment variable later...
 236         dir = os.getenv("HOME")
 237     else:
 238         # for Linux: use /tmp/logs/{user} folder
 239         dir = os.path.join( '/tmp', 'logs', getUserName() )
 240         pass
 241     return dir
 242
 243 # ---
 244
 245 def generateFileName( dir, prefix = None, suffix = None, extension = None,
 246                       unique = False, separator = "_", hidden = False, **kwargs ):
 247     """
 248     Generate file name by sepecified parameters. If necessary, file name
 249     can be generated to be unique.
 250
 251     Parameters:
 252     - dir       : directory path
 253     - prefix    : file prefix (not added by default)
 254     - suffix    : file suffix (not added by default)
 255     - extension : file extension (not added by default)
 256     - unique    : if this parameter is True, the unique file name is generated:
 257     in this case, if the file with the generated name already exists
 258     in the <dir> directory, an integer suffix is added to the end of the
 259     file name. This parameter is False by default.
 260     - separator : separator of the words ('_' by default)
 261     - hidden    : if this parameter is True, the file name is prepended by . (dot)
 262     symbol. This parameter is False by default.
 263
 264     Other keyword parameters are:
 265     - with_username : 'add user name' flag/option:
 266       * boolean value can be passed to determine user name automatically
 267       * string value to be used as user name
 268     - with_hostname : 'add host name' flag/option:
 269       * boolean value can be passed to determine host name automatically
 270       * string value to be used as host name
 271     - with_port     : 'add port number' flag/option:
 272       * boolean value can be passed to determine port number automatically
 273       * string value to be used as port number
 274     - with_app      : 'add application name' flag/option:
 275       * boolean value can be passed to determine application name automatically
 276       * string value to be used as application name
 277     All <with_...> parameters are optional.
 278     """
 279     supported = [ 'with_username', 'with_hostname', 'with_port', 'with_app' ]
 280     from launchConfigureParser import verbose
 281     filename = []
 282     # separator
 283     if separator is None:
 284         separator = ""
 285         pass
 286     else:
 287         separator = str( separator )
 288         pass
 289     # prefix (if specified)
 290     if prefix is not None:
 291         filename.append( str( prefix ) )
 292         pass
 293     # additional keywords
 294     ### check unsupported parameters
 295     for kw in kwargs:
 296         if kw not in supported and verbose():
 297             print 'Warning! salome_utilitie.py: generateFileName(): parameter %s is not supported' % kw
 298             pass
 299         pass
 300     ### process supported keywords
 301     for kw in supported:
 302         if kw not in kwargs: continue
 303         ### user name
 304         if kw == 'with_username':
 305             try:
 306                 # auto user name ?
 307                 if _try_bool( kwargs[kw] ): filename.append( getUserName() )
 308                 pass
 309             except:
 310                 # user name given as parameter
 311                 filename.append( kwargs[kw] )
 312                 pass
 313             pass
 314         ### host name
 315         elif kw == 'with_hostname':
 316             try:
 317                 # auto host name ?
 318                 if _try_bool( kwargs[kw] ): filename.append( getShortHostName() )
 319                 pass
 320             except:
 321                 # host name given as parameter
 322                 filename.append( kwargs[kw] )
 323                 pass
 324             pass
 325         ### port number
 326         elif kw == 'with_port':
 327             try:
 328                 # auto port number ?
 329                 if _try_bool( kwargs[kw] ): filename.append( str( getPortNumber() ) )
 330                 pass
 331             except:
 332                 # port number given as parameter
 333                 filename.append( str( kwargs[kw] ) )
 334                 pass
 335             pass
 336         ### application name
 337         elif kw == 'with_app':
 338             try:
 339                 # auto application name ?
 340                 if _try_bool( kwargs[kw] ): filename.append( getAppName() )
 341                 pass
 342             except:
 343                 # application name given as parameter
 344                 filename.append( kwargs[kw] )
 345                 pass
 346             pass
 347         pass
 348     # suffix (if specified)
 349     if suffix is not None:
 350         filename.append( str( suffix ) )
 351         pass
 352     # raise an exception if file name is empty
 353     if not filename:
 354         raise Exception("Empty file name")
 355     #
 356     if extension is not None and extension.startswith("."): extension = extension[1:]
 357     #
 358     import os
 359     name = separator.join( filename )
 360     if hidden: name = "." + name                       # add dot for hidden files
 361     if extension: name = name + "." + str( extension ) # add extension if defined
 362     name = os.path.join( dir, name )
 363     if unique:
 364         # create unique file name
 365         index = 0
 366         while os.path.exists( name ):
 367             index = index + 1
 368             name = separator.join( filename ) + separator + str( index )
 369             if hidden: name = "." + name                       # add dot for hidden files
 370             if extension: name = name + "." + str( extension ) # add extension if defined
 371             name = os.path.join( dir, name )
 372             pass
 373         pass
 374     return os.path.normpath(name)
 375
 376 # ---
 377
 378 def makeTmpDir( path, mode=0777 ):
 379     """
 380     Make temporary directory with the specified path.
 381     If the directory exists then clear its contents.
 382
 383     Parameters:
 384     - path : absolute path to the directory to be created.
 385     - mode : access mode
 386     """
 387     import os
 388     if os.path.exists( path ):
 389         import sys
 390         if sys.platform == "win32":
 391             os.system( "rmdir /S /Q " + '"' + path + '"' )
 392             os.system( "mkdir " + '"' + path + '"' )
 393         else:
 394             os.system( "rm -rf " + path + "/*" )
 395     else:
 396         dirs = path.split("/")
 397         shift1 = shift2 = 0
 398         if not dirs[0]: shift1 = 1
 399         if dirs[-1]: shift2 = 1
 400         for i in range(1+shift1,len(dirs)+shift2):
 401             p = "/".join(dirs[:i])
 402             try:
 403                 os.mkdir(p, mode)
 404                 os.chmod(p, mode)
 405             except:
 406                 pass
 407
 408 # ---
 409
 410 def uniteFiles( src_file, dest_file ):
 411     """
 412     Unite contents of the source file with contents of the destination file
 413     and put result of the uniting to the destination file.
 414     If the destination file does not exist then the source file is simply
 415     copied to its path.
 416
 417     Parameters:
 418     - src_file  : absolute path to the source file
 419     - dest_file : absolute path to the destination file
 420     """
 421     import os
 422
 423     if not os.path.exists( src_file ):
 424         return
 425         pass
 426
 427     if os.path.exists( dest_file ):
 428         # add a symbol of new line to contents of the destination file (just in case)
 429         dest = open( dest_file, 'r' )
 430         dest_lines = dest.readlines()
 431         dest.close()
 432
 433         dest_lines.append( "\n" )
 434
 435         dest = open( dest_file, 'w' )
 436         dest.writelines( dest_lines )
 437         dest.close()
 438
 439         import sys
 440         if sys.platform == "win32":
 441             command = "type " + '"' + src_file + '"' + " >> " + '"' + dest_file + '"'
 442         else:
 443             command = "cat " + src_file + " >> " + dest_file
 444             pass
 445         pass
 446     else:
 447         import sys
 448         if sys.platform == "win32":
 449             command = "copy " + '"' + src_file + '"' + " " + '"' + dest_file + '"' + " > nul"
 450         else:
 451             command = "cp " + src_file + " " + dest_file
 452             pass
 453         pass
 454
 455     os.system( command )
 456
 457 # --
 458
 459 _verbose = None
 460
 461 def verbose():
 462     """
 463     Get verbosity level. Default verbosity level is specified via the environment variable
 464     SALOME_VERBOSE, e.g.:
 465     [bash %] export SALOME_VERBOSE=1
 466     The function setVerbose() can be used to change verbosity level explicitly.
 467     """
 468     global _verbose
 469     # verbose has already been called
 470     if _verbose is not None:
 471         return _verbose
 472     # first time
 473     try:
 474         from os import getenv
 475         _verbose = int(getenv('SALOME_VERBOSE'))
 476     except:
 477         _verbose = 0
 478         pass
 479     #
 480     return _verbose
 481
 482 def setVerbose(level):
 483     """
 484     Change verbosity level. The function verbose() can be used to get current verbosity level.
 485     """
 486     global _verbose
 487     _verbose = level
 488     return
 489