142 lines
4.7 KiB
Python
142 lines
4.7 KiB
Python
#!/usr/bin/python
|
|
|
|
# ex:ts=4:sw=4:sts=4:et
|
|
# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
|
|
#
|
|
# Copyright (C) 2015 Alexandru Damian for Intel Corp.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License version 2 as
|
|
# published by the Free Software Foundation.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along
|
|
# with this program; if not, write to the Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
# Utilities shared by tests and other common bits of code.
|
|
|
|
import sys, os, subprocess, fcntl, errno
|
|
import config
|
|
from config import logger
|
|
|
|
|
|
# License warning; this code is copied from the BitBake project, file bitbake/lib/bb/utils.py
|
|
# The code is originally licensed GPL-2.0, and we redistribute it under still GPL-2.0
|
|
|
|
# End of copy is marked with #ENDOFCOPY marker
|
|
|
|
def mkdirhier(directory):
|
|
"""Create a directory like 'mkdir -p', but does not complain if
|
|
directory already exists like os.makedirs
|
|
"""
|
|
|
|
try:
|
|
os.makedirs(directory)
|
|
except OSError as exc:
|
|
if exc.errno != errno.EEXIST:
|
|
raise exc
|
|
|
|
def lockfile(name, shared=False, retry=True):
|
|
"""
|
|
Use the file fn as a lock file, return when the lock has been acquired.
|
|
Returns a variable to pass to unlockfile().
|
|
"""
|
|
config.logger.debug("take lockfile %s", name)
|
|
dirname = os.path.dirname(name)
|
|
mkdirhier(dirname)
|
|
|
|
if not os.access(dirname, os.W_OK):
|
|
logger.error("Unable to acquire lock '%s', directory is not writable",
|
|
name)
|
|
sys.exit(1)
|
|
|
|
operation = fcntl.LOCK_EX
|
|
if shared:
|
|
operation = fcntl.LOCK_SH
|
|
if not retry:
|
|
operation = operation | fcntl.LOCK_NB
|
|
|
|
while True:
|
|
# If we leave the lockfiles lying around there is no problem
|
|
# but we should clean up after ourselves. This gives potential
|
|
# for races though. To work around this, when we acquire the lock
|
|
# we check the file we locked was still the lock file on disk.
|
|
# by comparing inode numbers. If they don't match or the lockfile
|
|
# no longer exists, we start again.
|
|
|
|
# This implementation is unfair since the last person to request the
|
|
# lock is the most likely to win it.
|
|
|
|
# pylint: disable=broad-except
|
|
# we disable the broad-except because we want to actually catch all possible exceptions
|
|
try:
|
|
lock_file = open(name, 'a+')
|
|
fileno = lock_file.fileno()
|
|
fcntl.flock(fileno, operation)
|
|
statinfo = os.fstat(fileno)
|
|
if os.path.exists(lock_file.name):
|
|
statinfo2 = os.stat(lock_file.name)
|
|
if statinfo.st_ino == statinfo2.st_ino:
|
|
return lock_file
|
|
lock_file.close()
|
|
except Exception as exc:
|
|
try:
|
|
lock_file.close()
|
|
except Exception as exc2:
|
|
config.logger.error("Failed to close the lockfile: %s", exc2)
|
|
config.logger.error("Failed to acquire the lockfile: %s", exc)
|
|
if not retry:
|
|
return None
|
|
|
|
def unlockfile(lock_file):
|
|
"""
|
|
Unlock a file locked using lockfile()
|
|
"""
|
|
try:
|
|
# If we had a shared lock, we need to promote to exclusive before
|
|
# removing the lockfile. Attempt this, ignore failures.
|
|
fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX|fcntl.LOCK_NB)
|
|
os.unlink(lock_file.name)
|
|
except (IOError, OSError):
|
|
pass
|
|
fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
|
|
lock_file.close()
|
|
|
|
#ENDOFCOPY
|
|
|
|
|
|
def mk_lock_filename():
|
|
our_name = os.path.basename(__file__)
|
|
our_name = ".%s" % ".".join(reversed(our_name.split(".")))
|
|
return config.LOCKFILE + our_name
|
|
|
|
|
|
|
|
class ShellCmdException(Exception):
|
|
pass
|
|
|
|
def run_shell_cmd(command, cwd=None):
|
|
if cwd is None:
|
|
cwd = os.getcwd()
|
|
|
|
config.logger.debug("_shellcmd: (%s) %s", cwd, command)
|
|
process = subprocess.Popen(command, cwd=cwd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
(out, err) = process.communicate()
|
|
process.wait()
|
|
if process.returncode:
|
|
if len(err) == 0:
|
|
err = "command: %s \n%s" % (command, out)
|
|
else:
|
|
err = "command: %s \n%s" % (command, err)
|
|
config.logger.warning("_shellcmd: error \n%s\n%s", out, err)
|
|
raise ShellCmdException(err)
|
|
else:
|
|
#config.logger.debug("localhostbecontroller: shellcmd success\n%s" % out)
|
|
return out
|
|
|