lorax/src/pylorax/sysutils.py

#
# sysutils.py
#
# Copyright (C) 2009-2019 Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# 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, see <http://www.gnu.org/licenses/>.
#
# Red Hat Author(s):  Martin Gracik <mgracik@redhat.com>
#

__all__ = ["joinpaths", "touch", "replace", "chown_", "chmod_", "remove",
           "linktree"]

import sys
import os
import re
import fileinput
import pwd
import grp
import glob
import shutil
import shlex
from configparser import ConfigParser

from pylorax.executils import runcmd

def joinpaths(*args, **kwargs):
    path = os.path.sep.join(args)

    if kwargs.get("follow_symlinks"):
        return os.path.realpath(path)
    else:
        return path


def touch(fname):
    with open(fname, "w") as f:
        f.write("")


def replace(fname, find, sub):
    fin = fileinput.input(fname, inplace=1)
    pattern = re.compile(find)

    for line in fin:
        line = pattern.sub(sub, line)
        sys.stdout.write(line)

    fin.close()


def chown_(path, user=None, group=None, recursive=False):
    uid = gid = -1

    if user is not None:
        uid = pwd.getpwnam(user)[2]
    if group is not None:
        gid = grp.getgrnam(group)[2]

    for fname in glob.iglob(path):
        os.chown(fname, uid, gid)

        if recursive and os.path.isdir(fname):
            for nested in os.listdir(fname):
                nested = joinpaths(fname, nested)
                chown_(nested, user, group, recursive)


def chmod_(path, mode, recursive=False):
    for fname in glob.iglob(path):
        os.chmod(fname, mode)

        if recursive and os.path.isdir(fname):
            for nested in os.listdir(fname):
                nested = joinpaths(fname, nested)
                chmod_(nested, mode, recursive)


def cpfile(src, dst):
    shutil.copy2(src, dst)
    if os.path.isdir(dst):
        dst = joinpaths(dst, os.path.basename(src))

    return dst

def mvfile(src, dst):
    if os.path.isdir(dst):
        dst = joinpaths(dst, os.path.basename(src))
    os.rename(src, dst)
    return dst

def remove(target):
    if os.path.isdir(target) and not os.path.islink(target):
        shutil.rmtree(target)
    else:
        os.unlink(target)

def linktree(src, dst):
    runcmd(["/bin/cp", "-alx", src, dst])

def unquote(s):
    return ' '.join(shlex.split(s))

class UnquotingConfigParser(ConfigParser):
    """A ConfigParser, only with unquoting of the values."""
    # pylint: disable=arguments-differ
    def get(self, *args, **kwargs):
        ret = super().get(*args, **kwargs)
        if ret:
            ret = unquote(ret)
        return ret

def flatconfig(filename):
    """Use UnquotingConfigParser to read a flat config file (without
    section headers) by adding a section header.
    """
    with open (filename, 'r') as conffh:
        conftext = "[main]\n" + conffh.read()
    config = UnquotingConfigParser()
    config.read_string(conftext)
    return config['main']

def read_tail(path, size):
    """Read up to `size` kibibytes from the end of a file"""

    # NOTE: In py3 text files are unicode, not bytes so we have to open it as bytes
    with open(path, "rb") as f:
        return _read_file_end(f, size)

def _read_file_end(f, size):
    """Read the end of a file

    This skips to the next line to avoid starting in the middle of a unicode character.
    And returns "" in the case of a UnicodeDecodeError
    """
    f.seek(0, 2)
    end = f.tell()
    if end < 1024 * size:
        f.seek(0, 0)
    else:
        f.seek(end - (1024 * size))
    data = f.read()
    try:
        # Find the first newline in the block
        newline = min(1+data.find(b'\n'), len(data))
        text = data[newline:].decode("UTF-8")
    except UnicodeDecodeError:
        return ""
    return text