functional tests: versions

[pmachines.git] / lib / engine / log.py

from logging import basicConfig, info, INFO, DEBUG, getLogger
from configparser import ConfigParser
from sys import platform, argv
from platform import system
from pathlib import Path
from glob import glob
from json import load, dumps
#from datetime import datetime
from pprint import pprint
from os import getcwd, environ
from os.path import exists, dirname
from traceback import print_stack
from sys import version_info
# from platform import system, release, architecture, platform, processor, \
#     version, machine
# from multiprocessing import cpu_count
from panda3d.core import Filename, GraphicsWindow, PandaSystem
from panda3d.bullet import get_bullet_version
from lib.gameobject import Colleague
from lib.lib.builder import LibP3d
import sys


lev = INFO
opt_path = ''
if platform in ['win32', 'linux'] and not exists('main.py'):
    # it is the deployed version for windows
    opt_path = str(Filename.get_user_appdata_directory()) + '/pmachines'
opath = LibP3d.fixpath(opt_path + '/options.ini') if opt_path else \
        'options.ini'
if exists(opath):
    with open(opath) as json_file:
        #optfile = load(json_file)
        optfile = ConfigParser()
        optfile.read(opath)
        # optfile['development']['verbose'] and int(optfile['development']['verbose']) or \
        if optfile['development']['verbose_log'] and int(optfile['development']['verbose_log']):
            lev = DEBUG

basicConfig(level=lev, format='%(asctime)s %(message)s', datefmt='%H:%M:%S')
getLogger().setLevel(lev)  # it doesn't work otherwise


class LogMgrBase(Colleague):  # headless log manager

    @staticmethod
    def init_cls():
        return LogMgr if base.win else LogMgrBase

    def __init__(self, mediator):
        Colleague.__init__(self, mediator)
        self.log_cfg()

    def log(self, msg, verbose=False):
        if verbose and not self.eng.cfg.dev_cfg.verbose_log: return
        info(msg)

    @property
    def is_appimage(self):
        par_path = str(Path(__file__).parent.absolute())
        is_appimage = par_path.startswith('/tmp/.mount_Pmachi')
        return is_appimage and par_path.endswith('/usr/bin')

    @property
    def curr_path(self):
        # this is different from the music's one since it does not work
        # with the version in windows
        if sys.platform == 'darwin':
            return dirname(__file__) + '/../Resources/'
        # return dirname(__file__)
        par_path = str(Path(__file__).parent.absolute())
        if self.is_appimage:
            return str(Path(par_path).absolute())
        is_snap = par_path.startswith('/snap/')
        is_snap = is_snap and par_path.endswith('/x1')
        if is_snap:
            return str(Path(par_path).absolute())
        #return getcwd()
        curr_path = dirname(__file__)
        info('current path: %s' % curr_path)
        return curr_path

    @property
    def build_version(self):
        appimg_mnt = glob('/tmp/.mount_Pmachi*')
        if appimg_mnt:
            #with open(appimg_mnt[0] + '/usr/bin/appimage_version.txt') as fver:
            with open(self.curr_path + '/assets/bld_version.txt') as fver:
                return fver.read().strip()
        try:
            with open(self.curr_path + '/assets/bld_version.txt') as fver:
                return fver.read().strip()
        except FileNotFoundError:
            info('not found ' + self.curr_path + '/assets/bld_version.txt')
            return 'notfound'

    def log_cfg(self):
        if '--version' in argv:
            path = str(Filename.get_user_appdata_directory())
            home = '/home/flavio'  # we must force this for wine
            if path.startswith('/c/users/') and exists(home + '/.wine/'):
                path = home + '/.wine/drive_' + path[1:]
            info('writing %s' % path + '/pmachines/obs_version.txt')
            with open(path + '/pmachines/obs_version.txt', 'w') as f:
                #f.write(self.eng.logic.version)
                f.write(self.build_version)
            if not platform.startswith('win'):
                from os import ttyname  # here because it doesn't work on windows
                import sys
                with open(ttyname(0), 'w') as fout:
                    sys.stdout = fout
                    print('version: ' + self.build_version)  # self.eng.logic.version)
        messages = ['version: ' + self.build_version]  # self.eng.logic.version]
        messages += ['argv[0]: %s' % argv[0]]
        messages += ['getcwd: %s' % getcwd()]
        messages += ['__file__: %s' % __file__]
        for elm in environ.items():
            messages += ['env::%s: %s' % elm]
        # os_info = (system(), release(), version())
        # messages += ['operative system: %s %s %s' % os_info]
        # messages += ['architecture: ' + str(architecture())]
        # messages += ['machine: ' + machine()]
        # messages += ['platform: ' + platform()]
        # messages += ['processor: ' + processor()]
        # try:
        #     messages += ['cores: ' + str(cpu_count())]
        # except NotImplementedError:  # on Windows
        #     messages += ['cores: not implemented']
        lib_ver = PandaSystem.get_version_string()
        try:
            import psutil
            mem = psutil.virtual_memory().total / 1000000000.0
            messages += ['memory: %s GB' % round(mem, 2)]
        except ImportError: info("can't import psutil")  # windows
        lib_commit = PandaSystem.get_git_commit()
        py_ver = [str(elm) for elm in version_info[:3]]
        messages += ['python version: %s' % '.'.join(py_ver)]
        messages += ['panda version: %s %s' % (lib_ver, lib_commit)]
        messages += ['bullet version: ' + str(get_bullet_version())]
        messages += ['appdata: ' + str(Filename.get_user_appdata_directory())]
        if base.win and isinstance(base.win, GraphicsWindow):  # not headless
            print(base.win.get_keyboard_map())
        list(map(self.log, messages))

    @staticmethod
    def log_tasks():
        info('tasks: %s' % taskMgr.getAllTasks())
        info('do-laters: %s' % taskMgr.getDoLaters())

    @staticmethod
    def plog(obj):
        print('\n\n')
        print_stack()
        pprint(obj)
        print('\n\n')


class LogMgr(LogMgrBase):

    def log_cfg(self):
        LogMgrBase.log_cfg(self)
        messages = [base.win.get_gsg().get_driver_vendor()]
        messages += [base.win.get_gsg().get_driver_renderer()]
        shad_maj = base.win.get_gsg().get_driver_shader_version_major()
        shad_min = base.win.get_gsg().get_driver_shader_version_minor()
        messages += ['shader: {maj}.{min}'.format(maj=shad_maj, min=shad_min)]
        messages += [base.win.get_gsg().get_driver_version()]
        drv_maj = base.win.get_gsg().get_driver_version_major()
        drv_min = base.win.get_gsg().get_driver_version_minor()
        drv = 'driver version: {maj}.{min}'
        messages += [drv.format(maj=drv_maj, min=drv_min)]
        fullscreen = None
        if isinstance(base.win, GraphicsWindow):
            fullscreen = base.win.get_properties().get_fullscreen()
        messages += ['fullscreen: ' + str(fullscreen)]
        def resolution():
            if not isinstance(base.win, GraphicsWindow):
                return 800, 600
            win_prop = base.win.get_properties()
            return win_prop.get_x_size(), win_prop.get_y_size()
        res_x, res_y = resolution()
        res_tmpl = 'resolution: {res_x}x{res_y}'
        messages += [res_tmpl.format(res_x=res_x, res_y=res_y)]
        list(map(self.log, messages))