calculate-utils-2.2-lib/pym/cl_utils.py

#-*- coding: utf-8 -*-

# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

import subprocess
import string
from random import choice
import os
import types
import stat


def _toUNICODE(val):
    """перевод текста в юникод"""
    if type(val) == types.UnicodeType:
        return val
    else:
        return str(val).decode('UTF-8')

def runOsCommand(cmd, inStr=None, ret_first=None, env_dict=None):
    """Выполняет внешнюю программу

    Параметры:
    cmd            внешняя программа
    inStr          данные передаваемые программе на страндартный вход.
    ret_first      вернуть только первую строку
    env_dict       словарь переменных окружения
    Возвращаемые параметры:
    строка/строки которую выведет внешняя программа
    Возвращает код возврата, stdout+stderr
    """
    pipe = subprocess.Popen(cmd, stdin=subprocess.PIPE,
                            stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE,
                            env=env_dict,
                            close_fds=True,
                            shell=True)
    fout, fin, ferr = (pipe.stdout, pipe.stdin, pipe.stderr)
    # если есть данные на вход, передать их
    if inStr:
        fin.write(inStr)
    fin.close()
    # Код возврата
    retcode = pipe.wait()
    res = fout.readlines()
    fout.close()
    res += ferr.readlines()
    ferr.close()
    if res:
        if len(res) == 1 or ret_first:
            return retcode, res[0].strip()
        else:
            return retcode, res
    return retcode, None

def getpathenv():
    """вернуть пути для запуска программ"""
    bindir=['/sbin','/bin','/usr/sbin','/usr/bin']
    env=os.environ
    if env and env.has_key('PATH'):
        lpath=env['PATH'].split(":")
        npath=[]
        for dirname in bindir:
            if os.path.exists(dirname) and dirname not in lpath:
                npath.append(dirname)
        lpath=npath+lpath
        return ":".join(lpath)

def genpassword(passlen=9):
    '''Вернуть случайный пароль указанной длины

    Параметры:
    passlen     длина пароля который нужно сгенерировать

    Возвращаемые параметры:
    Сгенерированный пароль указанной длины
    '''
    res=''.join([choice(string.ascii_letters+string.digits)\
        for i in xrange(passlen)])
    return res

def fillstr(char, width):
    '''Заполнить строку указанным числом символов. Псеводоним символ*кол-во'''
    return str(char) * width


def list2str(list):
    '''Функция переводит список в строку'''
    return '['+','.join(list)+']'

def str2list(s):
    '''Функция переводит строку в список'''
    return s[1:-1].split(',')

def dict2str(dict):
    '''Функция перводит словарь в строку'''
    return '{'+','.join(["%s:%s" % (str(k),str(v)) \
            for (k,v) in dict.items()])+'}' #:

def str2dict(s):
    '''Функция переводит строку в словарь'''
    dict = {}
    for i in  s[1:-1].split(','):
        k,v = i.split(':')
        dict[k] = v
    return dict

def convertStrListDict(val):
    '''Функция определеяется что на входе (строка, список, словарь)
    и переводит их в строку и обратно'''
    # если подан список
    if type(val) == types.ListType:
        return list2str(val)
    # если подан словарь
    elif type(val) == types.DictType:
        return dict2str(val)
    # если подана строка
    else:
        # если поданная строка содержит словарь
        if ':' in val and '{' in val:
            return str2dict(val)
        # если поданная строка содержит список
        elif ',' in val and '[' in val:
            return str2list(val)
        # если это просто строка
        else:
            return val

def getdirlist(s_path):
    """Получить список директорий по указаному пути"""
    return filter(lambda x: os.path.isdir(x), os.listdir(s_path))

class _error:
    # Здесь ошибки, если они есть
    error = []
    def getError(self):
        """Выдать ошибки"""
        if not self.error:
            return False
        error = ""
        for e in self.error:
            error += e + "\n"
        return error

    def setError(self, error):
        """Установка ошибки"""
        if not error in self.error:
            self.error.append(error)
        return True

class scan:
    """Класс для сканирования директорий"""
    class _dir:
        """Класс для хранения директорий"""
        def __init__(self):
            # Базовая директория
            self.baseDir = False
            # Все директории в базовой включая вложенные
            self.dirs = []
            # Все файлы внутри базовой директории
            self.files = []
            # Все ссылки внутри базовой директории
            self.links = []
            # Все сокеты внутри базовой директории
            self.sockets = []


    def __scanDir(self, scanDir, dirObj, flagDir=False):
        """Сканирование одной директории"""
        if flagDir or stat.S_ISDIR(os.lstat(scanDir)[stat.ST_MODE]):
            for fileOrDir in os.listdir(scanDir):
                absPath = os.path.join(scanDir,fileOrDir)
                statInfo = os.lstat(absPath)[stat.ST_MODE]
                if stat.S_ISDIR(statInfo):
                    dirObj.dirs.append(absPath)
                    self.__scanDir(absPath, dirObj, True)
                elif stat.S_ISLNK(statInfo):
                    dest = absPath
                    src = os.readlink(absPath)
                    dirObj.links.append((src,dest))
                elif stat.S_ISREG(statInfo):
                    dirObj.files.append(absPath)
                elif stat.S_ISSOCK(statInfo):
                    dirObj.sockets.append(absPath)
        return dirObj

    def scanDirs(self, scanDirs):
        """Сканирование директорий на вход список

        Выход список объктов _dirProf
        """
        dirs = []
        for scanDir in scanDirs:
            dirP = scan._dir()
            try:
                self.__scanDir(scanDir, dirP)
            except OSError, e:
                print e.strerror, e.filename
                return []
            dirP.baseDir = scanDir
            dirs.append(dirP)
        return dirs

def removeDir(rmDir):
    """Рекурсивное удаление директории

    входной параметр директория для удаления

    Ошибки по except
    """
    if not os.path.exists(rmDir):
        raise Exception(_("Not found remove dir %s") %rmDir)
    fileObj = scan()
    # Сканируем директорию
    scanObjs = fileObj.scanDirs([rmDir])
    for socketRm in scanObjs[0].sockets:
        # Удаляем сокеты
        if os.path.exists(socketRm):
            os.remove(socketRm)
    for linkRm in scanObjs[0].links:
        # Удаляем ссылки
        os.unlink(linkRm[1])
    for fileRm in scanObjs[0].files:
        # Удаляем файлы
        os.remove(fileRm)
    scanObjs[0].dirs.sort(lambda x, y: cmp(len(y), len(x)))
    for dirRm in scanObjs[0].dirs:
        # Удаляем директории
        os.rmdir(dirRm)
    if os.path.exists(rmDir):
        os.rmdir(rmDir)
    return True

def getModeFile(nameFile):
        """Выдает информацию о файле

        права файла, владелец, группа файла (777,test, group)
        """
        fd = os.open(nameFile, os.O_RDONLY)
        fst = os.fstat(fd)
        uid = fst.st_uid
        gid = fst.st_gid
        mode = stat.S_IMODE(fst.st_mode)
        os.close(fd)
        return (mode,uid,gid)