]> SALOME platform Git repositories - modules/kernel.git/blob - bin/salome_utils.py
Salome HOME
cb0b454ac429404508acafbef15a8d5ac23f8fe5
[modules/kernel.git] / bin / salome_utils.py
1 #  -*- coding: iso-8859-1 -*-
2 # Copyright (C) 2007-2021  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, or (at your option) any later version.
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     'getLogDir',
43     'getTmpDir',
44     'getHomeDir',
45     'generateFileName',
46     'makeTmpDir',
47     'uniteFiles',
48     ]
49
50 # ---
51
52 def _try_bool( arg ):
53     """
54     Check if specified parameter represents boolean value and returns its value.
55     String values like 'True', 'TRUE', 'YES', 'Yes', 'y', 'NO', 'false', 'n', etc
56     are supported.
57     If <arg> does not represent a boolean, an exception is raised.
58     """
59     if isinstance(arg, bool)  :
60         return arg
61     elif isinstance(arg, (str, bytes)):
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 (USERNAME on windows)
129     2. if fails, try LOGNAME (un*x)
130     3. if fails return 'unknown' as default user name
131     """
132     import os, sys
133     if sys.platform == "win32":
134         return os.getenv("USERNAME", "unknown")
135     else:
136         user = os.getenv("USER")
137         if user:
138             return user
139         return os.getenv("LOGNAME", "unknown")
140 # ---
141
142 def getHostName():
143     """
144     Get host name:
145     1. try socket python module gethostname() function
146     2. if fails, try HOSTNAME environment variable
147     3. if fails, try HOST environment variable
148     4. if fails, return 'unknown' as default host name
149     """
150     try:
151         import socket
152         host = socket.gethostname()
153     except:
154         host = None
155         pass
156     if not host: host = os.getenv("HOSTNAME")
157     if not host: host = os.getenv("HOST")
158     if not host: host = "unknown"           # 'unknown' is default host name
159     try:
160         socket.gethostbyname(host)
161     except:
162         host = "localhost"
163     pass
164     return host
165
166 # ---
167
168 def getShortHostName():
169     """
170     Get short host name:
171     1. try socket python module gethostname() function
172     2. if fails, try HOSTNAME environment variable
173     3. if fails, try HOST environment variable
174     4. if fails, return 'unknown' as default host name
175     """
176     try:
177         return getHostName().split('.')[0]
178     except:
179         pass
180     return "unknown"           # 'unknown' is default host name
181
182 # ---
183
184 def getAppName():
185     """
186     Get application name:
187     1. try APPNAME environment variable
188     2. if fails, return 'SALOME' as default application name
189     """
190     import os
191     return os.getenv( "APPNAME", "SALOME" ) # 'SALOME' is default user name
192
193 # ---
194
195 def getPortNumber(use_default=True):
196     """
197     Get current naming server port number:
198     1. try NSPORT environment variable
199     1. if fails, try to parse config file defined by OMNIORB_CONFIG environment variable
200     2. if fails, return 2809 as default port number (if use_default is True) or None (id use_default is False)
201     """
202     import os
203     try:
204         return int( os.getenv( "NSPORT" ) )
205     except:
206         pass
207     try:
208         port = int( getPortFromORBcfg() )
209         if port is not None: return port
210     except:
211         pass
212     if use_default: return 2809 # '2809' is default port number
213     return None
214
215 # ---
216
217 def getHomeDir():
218     """
219     Get home directory.
220     """
221     import os
222     return os.path.realpath(os.path.expanduser('~'))
223 # ---
224
225 def getLogDir():
226     """
227     Get directory to be used for the log files.
228     """
229     import os
230     return os.path.join(getTmpDir(), "logs", getUserName())
231 # ---
232
233 def getTmpDir():
234     """
235     Get directory to be used for the temporary files.
236     """
237     import os, tempfile
238     f = tempfile.NamedTemporaryFile()
239     tmpdir = os.path.dirname(f.name)
240     f.close()
241     return tmpdir
242 # ---
243
244 def generateFileName( dir, prefix = None, suffix = None, extension = None,
245                       unique = False, separator = "_", hidden = False, **kwargs ):
246     """
247     Generate file name by specified parameters. If necessary, file name
248     can be generated to be unique.
249
250     Parameters:
251     - dir       : directory path
252     - prefix    : file prefix (not added by default)
253     - suffix    : file suffix (not added by default)
254     - extension : file extension (not added by default)
255     - unique    : if this parameter is True, the unique file name is generated:
256     in this case, if the file with the generated name already exists
257     in the <dir> directory, an integer suffix is added to the end of the
258     file name. This parameter is False by default.
259     - separator : separator of the words ('_' by default)
260     - hidden    : if this parameter is True, the file name is prepended by . (dot)
261     symbol. This parameter is False by default.
262
263     Other keyword parameters are:
264     - with_username : 'add user name' flag/option:
265       * boolean value can be passed to determine user name automatically
266       * string value to be used as user name
267     - with_hostname : 'add host name' flag/option:
268       * boolean value can be passed to determine host name automatically
269       * string value to be used as host name
270     - with_port     : 'add port number' flag/option:
271       * boolean value can be passed to determine port number automatically
272       * string value to be used as port number
273     - with_app      : 'add application name' flag/option:
274       * boolean value can be passed to determine application name automatically
275       * string value to be used as application name
276     All <with_...> parameters are optional.
277     """
278     supported = [ 'with_username', 'with_hostname', 'with_port', 'with_app' ]
279     from launchConfigureParser import verbose
280     filename = []
281     # separator
282     if separator is None:
283         separator = ""
284         pass
285     else:
286         separator = str( separator )
287         pass
288     # prefix (if specified)
289     if prefix is not None:
290         filename.append( str( prefix ) )
291         pass
292     # additional keywords
293     ### check unsupported parameters
294     for kw in kwargs:
295         if kw not in supported and verbose():
296             print('Warning! salome_utilitie.py: generateFileName(): parameter %s is not supported' % kw)
297             pass
298         pass
299     ### process supported keywords
300     for kw in supported:
301         if kw not in kwargs: continue
302         ### user name
303         if kw == 'with_username':
304             try:
305                 # auto user name ?
306                 if _try_bool( kwargs[kw] ): filename.append( getUserName() )
307                 pass
308             except:
309                 # user name given as parameter
310                 filename.append( kwargs[kw] )
311                 pass
312             pass
313         ### host name
314         elif kw == 'with_hostname':
315             try:
316                 # auto host name ?
317                 if _try_bool( kwargs[kw] ): filename.append( getShortHostName() )
318                 pass
319             except:
320                 # host name given as parameter
321                 filename.append( kwargs[kw] )
322                 pass
323             pass
324         ### port number
325         elif kw == 'with_port':
326             try:
327                 # auto port number ?
328                 if _try_bool( kwargs[kw] ): filename.append( str( getPortNumber() ) )
329                 pass
330             except:
331                 # port number given as parameter
332                 filename.append( str( kwargs[kw] ) )
333                 pass
334             pass
335         ### application name
336         elif kw == 'with_app':
337             try:
338                 # auto application name ?
339                 if _try_bool( kwargs[kw] ): filename.append( getAppName() )
340                 pass
341             except:
342                 # application name given as parameter
343                 filename.append( kwargs[kw] )
344                 pass
345             pass
346         pass
347     # suffix (if specified)
348     if suffix is not None:
349         filename.append( str( suffix ) )
350         pass
351     # raise an exception if file name is empty
352     if not filename:
353         raise Exception("Empty file name")
354     #
355     if extension is not None and extension.startswith("."): extension = extension[1:]
356     #
357     import os
358     name = separator.join( filename )
359     if hidden: name = "." + name                       # add dot for hidden files
360     if extension: name = name + "." + str( extension ) # add extension if defined
361     name = os.path.join( dir, name )
362     if unique:
363         # create unique file name
364         index = 0
365         while os.path.exists( name ):
366             index = index + 1
367             name = separator.join( filename ) + separator + str( index )
368             if hidden: name = "." + name                       # add dot for hidden files
369             if extension: name = name + "." + str( extension ) # add extension if defined
370             name = os.path.join( dir, name )
371             pass
372         pass
373     return os.path.normpath(name)
374
375 # ---
376
377 def makeTmpDir( path, mode=0o777 ):
378     """
379     Make temporary directory with the specified path.
380     If the directory exists then clear its contents.
381
382     Parameters:
383     - path : absolute path to the directory to be created.
384     - mode : access mode
385     """
386     import os
387     if os.path.exists( path ):
388         import sys
389         if sys.platform == "win32":
390             os.system( "rmdir /S /Q " + '"' + path + '"' )
391             os.system( "mkdir " + '"' + path + '"' )
392         else:
393             os.system( "rm -rf " + path + "/*" )
394     else:
395         dirs = path.split("/")
396         shift1 = shift2 = 0
397         if not dirs[0]: shift1 = 1
398         if dirs[-1]: shift2 = 1
399         for i in range(1+shift1,len(dirs)+shift2):
400             p = "/".join(dirs[:i])
401             try:
402                 os.mkdir(p, mode)
403                 os.chmod(p, mode)
404             except:
405                 pass
406
407 # ---
408
409 def uniteFiles( src_file, dest_file ):
410     """
411     Unite contents of the source file with contents of the destination file
412     and put result of the uniting to the destination file.
413     If the destination file does not exist then the source file is simply
414     copied to its path.
415
416     Parameters:
417     - src_file  : absolute path to the source file
418     - dest_file : absolute path to the destination file
419     """
420     import os
421
422     if not os.path.exists( src_file ):
423         return
424         pass
425
426     if os.path.exists( dest_file ):
427         # add a symbol of new line to contents of the destination file (just in case)
428         dest = open( dest_file, 'r' )
429         dest_lines = dest.readlines()
430         dest.close()
431
432         dest_lines.append( "\n" )
433
434         dest = open( dest_file, 'w' )
435         dest.writelines( dest_lines )
436         dest.close()
437
438         import sys
439         if sys.platform == "win32":
440             command = "type " + '"' + src_file + '"' + " >> " + '"' + dest_file + '"'
441         else:
442             command = "cat " + src_file + " >> " + dest_file
443             pass
444         pass
445     else:
446         import sys
447         if sys.platform == "win32":
448             command = "copy " + '"' + src_file + '"' + " " + '"' + dest_file + '"' + " > nul"
449         else:
450             command = "cp " + src_file + " " + dest_file
451             pass
452         pass
453
454     os.system( command )
455
456 # --
457
458 _verbose = None
459
460 def verbose():
461     """
462     Get verbosity level. Default verbosity level is specified via the environment variable
463     SALOME_VERBOSE, e.g.:
464     [bash %] export SALOME_VERBOSE=1
465     The function setVerbose() can be used to change verbosity level explicitly.
466     """
467     global _verbose
468     # verbose has already been called
469     if _verbose is not None:
470         return _verbose
471     # first time
472     try:
473         from os import getenv
474         _verbose = int(getenv('SALOME_VERBOSE'))
475     except:
476         _verbose = 0
477         pass
478     #
479     return _verbose
480 # --
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 # --
490
491 import signal
492 def killpid(pid, sig = 9):
493     """
494     Send signal sig to the process by pid.
495
496     Parameters:
497     - pid : PID of process
498     - sig : signal for sending
499             Possible values of signals: 
500             9 means kill the process
501             0 only check existing of the process
502             NOTE: Other values are not processed on Windows
503     Returns:
504      1 Success
505      0 Fail, no such process
506     -1 Fail, another reason
507
508     """
509     if not pid: return
510     import os, sys
511     if sig != 0:
512         if verbose(): print("######## killpid pid = ", pid)
513     try:
514         if sys.platform == "win32":
515             import ctypes
516             if sig == 0:
517                 # PROCESS_QUERY_INFORMATION (0x0400)    Required to retrieve certain information about a process
518                 SYNCHRONIZE = 0x100000
519                 handle = ctypes.windll.kernel32.OpenProcess(SYNCHRONIZE, False, int(pid))
520                 waitObj = ctypes.windll.kernel32.WaitForSingleObject(handle, 0)
521                 if waitObj:
522                     ret = 1
523                     ctypes.windll.kernel32.CloseHandle(handle)
524                 else:
525                     ret = 0
526             if sig == 9:
527                 # PROCESS_TERMINATE (0x0001)    Required to terminate a process using TerminateProcess.
528                 handle = ctypes.windll.kernel32.OpenProcess(0x0001, False, int(pid))
529                 ret = ctypes.windll.kernel32.TerminateProcess(handle, -1)
530                 ctypes.windll.kernel32.CloseHandle(handle)
531                 pass
532             pass
533         else:
534             # Default: signal.SIGKILL = 9
535             os.kill(int(pid),sig)
536             ret = 1
537             pass
538         pass
539     except OSError as e:
540         # errno.ESRCH == 3 is 'No such process'
541         if e.errno == 3:
542             ret = 0
543         else:
544             ret = -1
545             pass
546         pass
547     return ret
548 # --
549
550 def getOmniNamesPid(port):
551     """
552     Return OmniNames pid by port number.
553     """
554     import sys,subprocess,re
555     if sys.platform == "win32":
556         # Get process list by WMI Command Line Utility(WMIC)
557         # Output is formatted with each value listed on a separate line and with the name of the property:
558         #   ...
559         #   Caption=<caption0>
560         #   CommandLine=<commandline0>
561         #   ProcessId=<processid0>
562         #
563         #
564         #
565         #   Caption=<caption1>
566         #   CommandLine=<commandline1>
567         #   ProcessId=<processid1>
568         #   ...
569         cmd = 'WMIC PROCESS get Caption,Commandline,Processid /VALUE'
570         proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
571         # Get stdout
572         allProc = proc.communicate()[0].decode()
573         # find Pid of omniNames
574         pid = re.findall(r'Caption=.*omniNames.*\n?CommandLine=.*omniNames.*\D%s\D.*\n?ProcessId=(\d*)'%(port),allProc)[0]
575     else:        
576         cmd = "ps -eo pid,command | grep -v grep | grep -E \"omniNames.*%s\" | awk '{print $1}'"%(port)
577         proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
578         pid = proc.communicate()[0]
579         pass
580
581     return pid
582 # --
583
584 def killOmniNames(port):
585     """
586     Kill OmniNames process by port number.
587     """
588     try:
589         pid = getOmniNamesPid(port)
590         if pid: killpid(pid)
591     except:
592         pass
593     pass
594 # --