openfoam_project/openfoam/run/__main__.py

import sys
import shutil
import argparse
import logging
import configparser
from pprint import pp

from time import time
from datetime import timedelta
from datetime import datetime

from pathlib import Path
import subprocess as sp
import urllib.request
import urllib.parse
import urllib.error
import json


_t0 = time()
parser = argparse.ArgumentParser(
    description='Run the OpenFoam simulation'
)
parser.add_argument('-c', '--config', default='config.ini', type=Path,
    help='Configuration file (default config.ini)')
parser.add_argument('-l', '--log-level', default='INFO', type=str,
    help='Log level')

args = parser.parse_args()

config = configparser.ConfigParser()
config.read(args.config)

logging.basicConfig(
    filename=config.get('main', 'log_file', fallback=None),
    level=args.log_level
)
log = logging.getLogger('openfoam')

log.info('Starting program')

if config.getboolean('grafana', 'pause', fallback=False):
    log.info('Silencing Grafana alert')
    try:
        with urllib.request.urlopen(
            urllib.request.Request(
                urllib.parse.urljoin(
                    config.get('grafana', 'url'),
                    'api/alertmanager/grafana/api/v2/silences',
                ),
                headers={
                    'Authorization':
                        f'Bearer {config.get("grafana", "apikey")}',
                },
            ),
            data=bytes(json.dumps({
                "comment": "Openfoam run",
                "createdBy": "Python OpenFoam run",
                "endsAt": (datetime.utcnow() + timedelta(days=1)).isoformat(),
                "matchers": [
                  {
                    "isEqual": True,
                    "isRegex": False,
                    "name": "alertname",
                    "value": "CPU Usage"
                  }
                ],
                "startsAt": datetime.utcnow().isoformat()
            }), 'utf-8'),
        ) as api_req:
            api_res = api_req.read()
            grafana_alert_id = json.loads(api_res)['id']
    except urllib.error.HTTPError as e:
        log.error(f'Grafana silence returned code {e.code}')
        sys.exit(1)

input_dir = Path(config.get('main', 'input_dir'), config.get('main', 'case'))\
    .expanduser()
work_dir = Path(config.get('main', 'work_dir')).expanduser()

if not work_dir.exists():
    log.error(f'Work directory ({work_dir}) not found')
    sys.exit(1)
    
case_dir = work_dir.joinpath(config.get('main', 'case'))
if case_dir.exists():
    log.info(f'Deleting case ({case_dir})')
    shutil.rmtree(case_dir)

log.info(f'Copying case ({input_dir} -> {case_dir})')
shutil.copytree(input_dir, case_dir)

if config.getboolean('stl', 'copy', fallback=False):
    stl_in = Path(config.get('stl', 'from')).expanduser()
    if not stl_in.exists():
        log.error(f'STL from directory does not exist ({stl_in})')
        sys.exit(1)

    stl_dir = case_dir.joinpath('constant', 'triSurface')
    if stl_dir.exists():
        log.info(f'Deleting stl directory ({stl_dir})')
        shutil.rmtree(stl_dir)

    log.info(f'Copying stl directory ({stl_in} -> {stl_dir})')
    shutil.copytree(stl_in, stl_dir)

if config.getboolean('blockMesh', 'enable', fallback=False):
    log.info('Running blockMesh')
    blockmesh_log = logging.getLogger('blockMesh')
    proc = sp.Popen(
        ('blockMesh'),
        cwd=case_dir,
        stdout=sp.PIPE,
        stderr=sp.PIPE,
        text=True,
    )
    for line in proc.stdout:
        blockmesh_log.info(line[:-1])
    for line in proc.stderr:
        blockmesh_log.error(line[:-1])
    code = proc.wait()
    if code != 0:
        log.error('blockMesh failed')
        sys.exit(code)
    log.info(f'blockMesh finished successfully')

if config.getboolean('snappyHexMesh', 'enable', fallback=False):
    log.info('Running snappyHexMesh')
    snappy_log = logging.getLogger('snappyHexMesh')
    proc = sp.Popen(
        ('snappyHexMesh', '-overwrite'),
        cwd=case_dir,
        stdout=sp.PIPE,
        stderr=sp.PIPE,
        text=True,
    )
    for line in proc.stdout:
        snappy_log.info(line[:-1])
    for line in proc.stderr:
        snappy_log.error(line[:-1])
    code = proc.wait()
    if code != 0:
        log.error('snappyHexMesh failed')
        sys.exit(code)
    log.info(f'snappyHexMesh finished successfully')

log.info('Copying 0.org -> 0')
shutil.copytree(
    case_dir.joinpath('0.org'),
    case_dir.joinpath('0'),
)

if config.getboolean('setFields', 'enable', fallback=False):
    log.info('Running setFields')
    setfields_log = logging.getLogger('setFields')
    proc = sp.Popen(
        ('setFields'),
        cwd=case_dir,
        stdout=sp.PIPE,
        stderr=sp.PIPE,
        text=True,
    )
    for line in proc.stdout:
        setfields_log.info(line[:-1])
    for line in proc.stderr:
        setfields_log.info(line[:-1])
    code = proc.wait()
    if code != 0:
        log.error('setFields failed')
        sys.exit(code)
    log.info(f'setFields finished successfully')

if config.getboolean('olaFlow', 'enable', fallback=False):
    cmd = ('olaFlow')
    if config.getboolean('parallel', 'enable', fallback=False):
        cmd = (
            'mpirun',
            '-np', config.get('parallel', 'threads'),
            'olaFlow', '-parallel'
        )
        decpar_log = logging.getLogger('decomposePar')
        proc = sp.Popen(
            ('decomposePar'),
            cwd=case_dir,
            stdout=sp.PIPE,
            stderr=sp.PIPE,
            text=True,
        )
        for line in proc.stdout:
            decpar_log.info(line[:-1])
        for line in proc.stderr:
            decpar_log.error(line[:-1])
        code = proc.wait()
        if code != 0:
            log.error('decomposePar failed')
            sys.exit(code)
        log.info(f'decomposePar finished successfully')

    log.info('Running olaFlow')
    olaflow_log = logging.getLogger('olaFlow')
    proc = sp.Popen(
        cmd,
        cwd=case_dir,
        stdout=sp.PIPE,
        stderr=sp.PIPE,
        text=True,
    )
    for line in proc.stdout:
        olaflow_log.info(line[:-1])
    for line in proc.stderr:
        olaflow_log.error(line[:-1])
    code = proc.wait()
    if code != 0:
        log.error('olaFlow failed')
        sys.exit(code)
    log.info(f'olaFlow finished successfully')

    if config.getboolean('parallel', 'enable', fallback=False) \
        and config.getboolean('reconstructPar', 'enable', fallback=False):
        recpar_log = logging.getLogger('reconstructPar')
        proc = sp.Popen(
            ('reconstructPar'),
            cwd=case_dir,
            stdout=sp.PIPE,
            stderr=sp.PIPE,
            text=True,
        )
        for line in proc.stdout:
            recpar_log.info(line[:-1])
        for line in proc.stderr:
            recpar_log.error(line[:-1])
        code = proc.wait()
        if code != 0:
            log.error('reconstructPar failed')
            sys.exit(code)
        log.info(f'reconstructPar finished successfully')

        log.info(f'Deleting processor directories')
        for proc_dir in case_dir.glob(r'processor*'):
            log.info(f'Deleting {proc_dir}')
            shutil.rmtree(proc_dir)

if config.getboolean('grafana', 'pause', fallback=False):
    log.info('Unsilencing Grafana alert')
    try:
        with urllib.request.urlopen(
            urllib.request.Request(
                urllib.parse.urljoin(
                    config.get('grafana', 'url'),
                    'api/alertmanager/grafana/api/v2/silence/'
                    f'{grafana_alert_id}',
                ),
                headers={
                    'Authorization':
                        f'Bearer {config.get("grafana", "apikey")}',
                },
                method='DELETE',
            ),
        ) as api_req:
            api_res = api_req.read()
    except urllib.error.HTTPError as e:
        log.error(f'Grafana unsilence returned code {e.code}')
        sys.exit(1)

_t1 = time()
log.info(f'Program ended successfully after {timedelta(seconds=_t1-_t0)}')