#!/usr/bin/env python3

# Copyright 2021 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# This is contrib-quality code: not all functions/classes are
# documented.
# pylint: disable=import-error
# pylint: disable=wildcard-import
# pylint: disable=unused-wildcard-import
# pylint: disable=import-outside-toplevel
# pylint: disable=missing-function-docstring
# pylint: disable=input-builtin
# pylint: disable=redefined-outer-name

"""Automatic rebase

This script automates much of the continuous rebase, which is a process
designed for carrying patches from the `living` Chrome OS branch (latest LTS)
to newer upstream kernels.

See go/cont-rebase for details
"""

import os
import re
import sys
import multiprocessing
from multiprocessing import Manager
import pickle
import importlib
import sqlite3
import sh
from logging_console import LoggingConsole
from common import executor_io, rebasedb
from config import *
import rebase_config
# the import is not used directly, but instead intended to be used in the interactive mode
from mailing import Mailing, load_and_notify # pylint: disable=unused-import
from githelpers import *

def call_hook(sha, hook_type):
    if '*' in rebase_config.commit_hooks:
        entry = rebase_config.commit_hooks['*']
        if hook_type in entry['types']:
            hook = entry['hook']
            hook(sha, hook_type)
    if sha in rebase_config.commit_hooks:
        entry = rebase_config.commit_hooks[sha]
        if hook_type in entry['types']:
            hook = entry['hook']
            hook(sha, hook_type)


def branch_name(branch_prefix, target, topic):
    if topic is None:
        topic = ''
    else:
        topic = '-' + topic.replace('/', '_')
    return 'chromeos-' + branch_prefix + '-' + target[1:] + topic


def do_on_cros_sdk_impl(command, ret_by_arg=None):
    result = {'exit_code': None, 'output': None, 'error_line': None}
    os.system("echo '" + command + "' > " + executor_io + '/commands &')
    os.system('cat ' + executor_io + '/output > output.log')
    try:
        with open(executor_io + '/last_exit') as last_exit:
            ec = last_exit.read()
        result['exit_code'] = int(ec[:-1])
    except: # pylint: disable=bare-except
        print('failed to read a valid exit code from last_exit')
        return {}
    try:
        with open('output.log') as output:
            result['output'] = output.read()
        lines = result['output'].splitlines()
        for n in range(len(lines)): # pylint: disable=C0200
            if 'Error 1' in lines[n]:
                result['error_line'] = n + 1
                break
    except: # pylint: disable=bare-except
        print('failed to read output.log')
    if ret_by_arg is not None:
        for k, v in result.items():
            ret_by_arg[k] = v
    return result


def do_on_cros_sdk(command, timeout_s=None):
    if timeout_s is not None:
        manager = Manager()
        result = {}
        shared_dict = manager.dict()
        p = multiprocessing.Process(
            target=do_on_cros_sdk_impl, args=(
                command, shared_dict,))
        p.start()
        p.join(timeout_s)
        if p.is_alive():
            print('execution timed out, is executor.sh running in cros_sdk?')
            p.terminate()
            p.join()
        else:
            for k, v in shared_dict.items():
                result[k] = v
        return result
    return do_on_cros_sdk_impl(command)

def normalize():
    def in_linux_chrome(command):
        return 'cd ./data/repositories/linux-chrome/; ' + command
    def in_configs(command):
        return 'cd ./data/repositories/linux-chrome/CONFIGS; ' + command
    def in_knext(command):
        return 'cd kernel-upstream; ' + command

    configs = [
        (
            'arm64-chromiumos-arm64.flavour.config',
            'arm64/chromiumos-arm64.flavour.config'
        ), (
            'arm64-chromiumos-mediatek.flavour.config',
            'arm64/chromiumos-mediatek.flavour.config'
        ), (
            'arm64-chromiumos-qualcomm.flavour.config',
            'arm64/chromiumos-qualcomm.flavour.config'
        ), (
            'arm64-chromiumos-rockchip64.flavour.config',
            'arm64/chromiumos-rockchip64.flavour.config'
        ), (
            'armel-chromiumos-arm.flavour.config',
            'armel/chromiumos-arm.flavour.config'
        ), (
            'armel-chromiumos-rockchip.flavour.config',
            'armel/chromiumos-rockchip.flavour.config'
        ), (
            'x86_64-chromeos-amd-stoneyridge.flavour.config',
            'x86_64/chromeos-amd-stoneyridge.flavour.config'
        ), (
            'x86_64-chromeos-intel-denverton.flavour.config',
            'x86_64/chromeos-intel-denverton.flavour.config'
        ), (
            'x86_64-chromeos-intel-pineview.flavour.config',
            'x86_64/chromeos-intel-pineview.flavour.config'
        ), (
            'x86_64-chromiumos-x86_64.flavour.config',
            'x86_64/chromiumos-x86_64.flavour.config'
        )
    ]
    iwls = [
        'CONFIG_IWLWIFI=m',
        'CONFIG_IWLDVM=m',
        'CONFIG_IWLMVM=m',
        'CONFIG_IWLWIFI_DEBUGFS=y'
    ]
    iwl_fix_configs = [
        'chromeos/config/x86_64/chromeos-intel-denverton.flavour.config',
        'chromeos/config/x86_64/chromeos-intel-pineview.flavour.config'
    ]

    genconfig = in_linux_chrome('chromeos/scripts/kernelconfig genconfig 2>&1')

    commands = [
        in_configs('cp ' + config[0] + ' ../../../../kernel-upstream/chromeos/config/' + config[1] + ' 2>&1')  # pylint: disable=C0301
        for config in configs
    ] + [
        in_knext('echo "' + iwl + '" >> ' + file)
        for iwl in iwls
        for file in iwl_fix_configs
    ] + [
        in_knext('chromeos/scripts/kernelconfig olddefconfig 2>&1'),
        in_knext('git add -A 2>&1'),
        in_knext('git commit -m "kernel-rebase: normalization [autogenerated]" 2>&1')
    ]

    while True:
        print('genconfig')
        res = do_on_cros_sdk(genconfig)
        output = res['output']
        ec = res['exit_code']
        print(output, end='')

        if ec != 0:
            if 'this assembler is not supported' in output:
                print('This failure might be caused be the lack of commit e749464a877aa:')
                print('"CHROMIUM: kernelconfig sets CROSS_COMPILE"')
            return
        break

    for command in commands:
        print('executing', command)
        res = do_on_cros_sdk(command)
        output = res['output']
        ec = res['exit_code']

        print(output, end='')
        if ec != 0:
            print('exit code:', ec)
            return

def verify_build(sha):
    assert not is_dirty(
        'kernel-upstream'), "There's a local diff in kernel repo. Clean it to continue."
    if sha is not None:
        checkout('kernel-upstream', sha)
    return do_on_cros_sdk(
        'emerge-' +
        rebase_config.verify_board +
        ' --color n -B ' + rebase_config.verify_package)

class Rebaser:
    """Keeps all automatic rebase data"""

    def __init__(self, branch_prefix='test'):
        assert not is_dirty(
            'kernel-upstream'), "There's a local diff in kernel repo. Clean it to continue."

        self.db = sqlite3.connect(rebasedb)
        self.cur = self.db.cursor()
        self.branch_prefix = branch_prefix

        # Create topic dict (name->gid)
        self.topics = {}
        self.cur.execute('select topic, name from topics')
        t = self.cur.fetchall()
        for gid, name in t:
            self.topics[name] = gid
        print('Topic dict: ', self.topics)

        self.upstreamed = {
            'upstream': 0,
            'fromlist': 0,
            'fromgit': 0,
            'backport': 0}
        self.total = {
            'upstream': 0,
            'fromlist': 0,
            'fromgit': 0,
            'backport': 0}
        self.cur.execute('select subject, reason from commits')
        t = self.cur.fetchall()
        for subject, reason in t:
            subject_l = subject.lower()
            if 'fromlist:' in subject_l:
                self.total['fromlist'] += 1
                if 'upstream' in reason:
                    self.upstreamed['fromlist'] += 1
            if 'fromgit:' in subject_l:
                self.total['fromgit'] += 1
                if 'upstream' in reason:
                    self.upstreamed['fromgit'] += 1
            if 'upstream:' in subject_l:
                self.total['upstream'] += 1
                if 'upstream' in reason:
                    self.upstreamed['upstream'] += 1
            if 'backport:' in subject_l:
                self.total['backport'] += 1
                if 'upstream' in reason:
                    self.upstreamed['backport'] += 1

        self.kernel = None

        # Pull chromeos-5.4 branch
        print('Fetching cros...')
        fetch('kernel-upstream', 'cros')

        print('Fetching upstream...')
        fetch('kernel-upstream', 'upstream')

        # Checkout to target branch
        print('Checkout to', rebase_target, '...')
        checkout('kernel-upstream', rebase_target)

    def get_topic_dispositions(self, topic_list):
        # reload config to import up-to-date disp_overlay
        importlib.reload(rebase_config)
        from rebase_config import disp_overlay

        gids = []
        for topic in topic_list:
            gids.append(self.topics[topic])
        gids = str(gids).replace('[', '(').replace(']', ')')

        self.cur.execute(
            'select disposition,sha,subject,reason from commits where topic in %s' %
            gids)
        dispositions = self.cur.fetchall()
        for i in range(len(dispositions)): # pylint: disable=C0200
            disp = dispositions[i][0]
            sha = dispositions[i][1]
            subject = dispositions[i][2]
            reason = dispositions[i][3]
            # For now, assume there are only pick / drop / replace dispositions
            assert disp in [
                'pick', 'drop', 'replace'], 'Unrecognized disposition.'
            # Modify dispositions according to overlay
            if sha in disp_overlay:
                dispositions[i] = (disp_overlay[sha], sha, subject, reason)

        return dispositions

    # Rebase many topic branches joining them into one topic branch.
    # end_name: name of the target branch
    # topics: list of source topics
    # is_triage: if set, skip over commits that require manual resolution
    def rebase_multiple(self, end_name, topic_list, is_triage=False):
        # reload config to import up-to-date disp_overlay
        importlib.reload(rebase_config)

        print('Checkout to', rebase_target, '...')
        checkout('kernel-upstream', rebase_target)

        if is_triage:
            topic_branch = branch_name('triage', rebase_target, end_name)
            print('Triage mode on. Using branch %s.' % topic_branch)
            with sh.pushd('kernel-upstream'):
                try:
                    sh.git('branch', '-D', topic_branch)
                except sh.ErrorReturnCode_1 as e:
                    pass
        else:
            topic_branch = branch_name(
                self.branch_prefix, rebase_target, end_name)

        try:
            create_head('kernel-upstream', topic_branch)
        except OSError as err:
            print(err)
            print('Branch already exists?')
            return {}

        print('Rebasing topics %s, branch %s' % (topic_list, end_name))

        print('Checkout to %s...' % topic_branch)
        checkout('kernel-upstream', topic_branch)

        dispositions = self.get_topic_dispositions(topic_list)

        dropped = 0
        noconflicts = 0
        autoresolved = 0
        manual = 0

        dispositions_with_deps = []
        for i in dispositions:
            sha = i[1]
            if sha in rebase_config.patch_deps:
                for dep in rebase_config.patch_deps[sha]:
                    print('Adding dependency', dep, 'for patch', sha)
                    subject = '(fake subject) Dependency of ' + sha
                    dispositions_with_deps.append(['pick', dep, subject, ''])
            dispositions_with_deps.append(i)

        dispositions = dispositions_with_deps
        for i in dispositions:
            disp = i[0]
            sha = i[1]
            subject = i[2]
            reason = i[3]

            if cp_or_am_in_progress('kernel-upstream'):
                print('cherry-pick or am is currently in progress in kernel-upstream')
                print('resolve and press enter to continue')
                input()

            if disp == 'drop':
                print('Drop commit (%s) %s: %s' % (reason, sha, subject))
                # don't count commits dropped because of upstreaming, to be
                # consistent with genspreadsheet.py
                if reason != 'upstream':
                    dropped += 1
                continue
            print('Pick commit %s: %s' % (sha, subject))
            if disp == 'replace':
                # Replace dispositions are treated as 'pick' to avoid the
                # hassle.
                print('WARNING: commit disposition is replace')

            diff = replacement('kernel-upstream', sha)
            if diff is not None:
                print('Patch replaced by previous conflict resolution:', diff)
                # Make the path absolute
                diff = os.getcwd() + '/' + diff

            try:
                call_hook(sha, 'pre')
                if diff is None:
                    cherry_pick('kernel-upstream', sha)
                else:
                    apply_patch('kernel-upstream', diff, sha) # sha is only used for debugs
                noconflicts += 1
                # No conflicts, check rerere and continue
                call_hook(sha, 'post')
                continue
            except Exception as error: # pylint: disable=broad-except
                if debug:
                    sh.mkdir('-p', 'debug/rebase/' + sha)
                    with open('debug/rebase/' + sha + '/cp_am_err', 'w') as f:
                        f.write(str(error))
                call_hook(sha, 'conflict')

            print('Conflicts found.')
            # There were conflicts, check if autoresolved
            # Autostage in git is assumed
            # Files from patches shouldn't be autoresolved, so no path for handling
            # git apply conflicts is added here
            if is_resolved('kernel-upstream'):
                print('All resolved automatically.')
                autoresolved += 1
                with sh.pushd('kernel-upstream'):
                    try:
                        sh.git(
                            '-c',
                            'core.editor=true',
                            'am',
                            '--continue')
                        call_hook(sha, 'post')
                        save_head('kernel-upstream', sha)
                    except sh.ErrorReturnCode_128 as e:
                        am_err = 'No changes - did you forget' in str(e.stdout)
                        if am_err:
                            print(
                                'Cherry-pick/am empty due to conflict resolution. Skip.')
                            sh.git(
                                '-c',
                                'core.editor=true',
                                'am',
                                '--abort')
                            call_hook(sha, 'post_empty')
                            continue
                        raise e
            else:
                # Detect the cases, where deleted file is the only meaningful
                # conflict
                with sh.pushd('kernel-upstream'):
                    status = sh.git('status', '--porcelain')
                if 'DU' in status:
                    status = status.split('\n')
                    status = [line.split(' ') for line in status]
                    # By now, we have such array:
                    # [ ['DU', 'fs/compat_ioctl.c']
                    #   ['M', 'fs/ioctl.c'
                    # ]
                    # The only case where we can help is when conflicts are within
                    # the set (DU, M, ??, A). Check that now
                    conf_types = {a[0] for a in status}
                    if conf_types - set(['', '??', 'DU', 'M', 'A']) == set():
                        # Cool, we can solve that - note the files to remove, others
                        # should autoresolve
                        for entry in status:
                            if entry[0] == 'DU':
                                with sh.pushd('kernel-upstream'):
                                    sh.git('rm', entry[1])
                        with sh.pushd('kernel-upstream'):
                            try:
                                sh.git(
                                    '-c', 'core.editor=true', 'am', '--continue')
                                call_hook(sha, 'post')
                            except Exception as e: # pylint: disable=broad-except
                                print('git am --continue failed:')
                                print(e)
                                print('Fatal? [y/n]')
                                ans = input()
                                if ans in ['y', 'Y']:
                                    return {}
                        print('Applied commit by removing conflicting files.')
                        save_head('kernel-upstream', sha)
                        continue
                if is_triage:
                    # Conflict requires manual resolution - drop and continue
                    print('Commit requires manual resolution. Dropping it for now.')
                    manual += 1
                    with sh.pushd('kernel-upstream'):
                        sh.git('am', '--abort')
                    call_hook(sha, 'post_drop')
                    continue
                print(
                    """
        Conflict requires manual resolution.
        Resolve it in another window, add the changes by git add, then
        type \'continue\' (c) here.
        Or drop this patch by typing \'drop\' (d). It will be recorded in
        rebase_config.py and dropped in subsequent rebases.
        Or stop the rebase altogether (while keeping the changes that
        were already made) by typing \'stop\' (s).
        """)
                cmd = ''
                while cmd not in ['continue', 'drop', 'stop', 's', 'c', 'd']:
                    cmd = input()
                if cmd in ['continue', 'c']:
                    # Commit the change and continue
                    while not is_resolved('kernel-upstream'):
                        print('Something still unresolved. Resolve and hit enter.')
                        input()
                    manual += 1
                    with sh.pushd('kernel-upstream'):
                        try:
                            sh.git(
                                '-c', 'core.editor=true', 'am', '--continue')
                            call_hook(sha, 'post')
                        except Exception as e: # pylint: disable=broad-except
                            print('git am --continue failed:')
                            print(e)
                            print('Fatal? [y/n]')
                            ans = input()
                            if ans in ['y', 'Y']:
                                return {}
                    save_head('kernel-upstream', sha)
                elif cmd in ['drop', 'd']:
                    dropped += 1
                    # Drop the commit and record as dropped in overlay
                    with sh.pushd('kernel-upstream'):
                        sh.git('am', '--abort')
                    with open('rebase_config.py', 'a') as f:
                        f.write(
                            "disp_overlay['%s'] = '%s' # %s\n" %
                            (sha, 'drop', subject))
                else:
                    print(
                        'Stopped. %s commits dropped, %s applied cleanly, %s resolved'
                        ' automatically, %s needing manual resolution' %
                        (dropped, noconflicts, autoresolved, manual))
                    with sh.pushd('kernel-upstream'):
                        sh.git('am', '--abort')
                    return {}

        # Apply global reverts
        for sha in rebase_config.global_reverts:
            with sh.pushd('kernel-upstream'):
                sh.git('-c', 'core.editor=true', 'revert', sha)

        for topic in topic_list:
            if topic in rebase_config.topic_fixups:
                # Apply fixups for this particular topic
                for name in rebase_config.topic_fixups[topic]:
                    try:
                        call_hook('[nosha]', 'pre')
                        patch_short = 'patches/fixups/{}.patch'.format(name)
                        patch = os.getcwd() + '/' + patch_short
                        apply_patch('kernel-upstream', patch, '[nosha]')
                        # No conflicts, check rerere and continue
                        print('Applied ' + patch_short + ' fixup for ' + topic + '.')
                        call_hook('[nosha]', 'post')
                        continue
                    except sh.ErrorReturnCode_128:
                        print('Conflict found')
                        with sh.pushd('kernel-upstream'):
                            sh.git('am', '--abort')
                        call_hook('[nosha]', 'post_drop')

        print('Done. %s commits dropped, %s applied cleanly, %s resolved'
              ' automatically, %s needing manual resolution' %
              (dropped, noconflicts, autoresolved, manual))

        return {'dropped': dropped, 'noconflicts': noconflicts,
                'autoresolved': autoresolved, 'manual': manual}

    # Shorthand for rebase_multiple
    def rebase_one(self, t, is_triage=False):
        return self.rebase_multiple(t, [t], is_triage)

    # Moves commit into topic dst
    # commit - sha string
    # dst - topic name string
    def topic_move(self, commit, dst):
        dst_gid = self.topics[dst]
        query = "select subject, topic from commits where sha='%s'" % commit
        self.cur.execute(query)
        ret = self.cur.fetchall()
        src_gid = ret[0][1]
        src = ''
        for topic_name in self.topics:
            if self.topics[topic_name] == src_gid:
                src = src_gid
        assert src != '', 'No such topic?'
        query = "update commits set topic=%d where sha='%s'" % (
            dst_gid, commit)
        self.cur.execute(query)
        query = "select subject, topic from commits where sha='%s'" % commit
        self.cur.execute(query)
        ret = self.cur.fetchall()
        assert dst_gid == ret[0][1]
        print('Commit', ret[0][0], 'moved from', src, 'to', dst)

    def topic_list(self, topic):
        dst_gid = self.topics[topic]
        query = "select sha, subject from commits where topic=%d and disposition='pick'" % dst_gid
        self.cur.execute(query)
        ret = self.cur.fetchall()
        for i in ret:
            print(i[0], i[1])


def triage():
    # Check if executor is alive, we'll need it for verifying build
    if do_on_cros_sdk('true', 1) == {}:
        print('Is executor running?')
        return None
    r = Rebaser()
    topic_stats = r.topics
    upstream_stats = r.upstreamed
    total_stats = r.total
    topic_stderr = {}
    for topic in topic_stats:
        topic_branch = branch_name('triage', rebase_target, topic)
        ret = r.rebase_one(topic, is_triage=True)
        topic_stats[topic] = [
            ret['dropped'] +
            ret['noconflicts'] +
            ret['autoresolved'] +
            ret['manual'],
            ret['dropped'] +
            ret['autoresolved'] +
            ret['noconflicts'],
            ret['manual'],
            False]
        print('Verifying build...')
        ret = verify_build(topic_branch)
        if ret['exit_code'] == 0:
            print('Built %s succesfully.' % topic)
            topic_stats[topic][3] = True
        else:
            print('Error building %s:' % topic)
            if ret['error_line'] is not None:
                l = ret['error_line']
                reg = re.compile('\x1b\\[[0-9;]*m')
                topic_stderr[topic] = reg.sub(
                    '', '\n'.join(
                        ret['output'].split('\n')[
                            l - 7:l]))
                print(topic_stderr[topic])
            else:
                print('(No error line.)')
            f = open(
                'log/triage/' +
                topic_branch.replace(
                    '.',
                    '_').replace(
                    '/',
                    '-') +
                '.txt',
                'w')
            f.write(ret['output'])

    # Pickle the topic stats. Those can be loaded later by
    # Mailing::load_and_notify()
    with open('topic_stats.bin', 'wb') as f:
        pickle.dump(topic_stats, f)
    with open('topic_stderr.bin', 'wb') as f:
        pickle.dump(topic_stderr, f)
    with open('upstream_stats.bin', 'wb') as f:
        pickle.dump(upstream_stats, f)
    with open('total_stats.bin', 'wb') as f:
        pickle.dump(total_stats, f)
    return (topic_stats, topic_stderr)


def fixup():
    print('Current HEAD:')
    sha = head_sha('kernel-upstream')
    print(commit_message('kernel-upstream', sha))
    print('This will record the current HEAD as a fixup.')

    name = input('patch name: ')
    if '/' in name:
        print("patch name can't contains forward slashes!")
        return
    path = 'patches/fixups/{}.patch'.format(name)
    if os.path.isfile(path):
        print('Path exists!')
        yn = input('proceed [y/n]:')
        if yn.lower() not in ['y', 'yes']:
            print('aborting')
            return
    save_head('kernel-upstream', sha, path_override=path)


def merge_topic_branches():
    r = Rebaser()
    topic_dict = r.topics
    topic_list = rebase_config.merge_order_override
    for from_config in rebase_config.merge_order_override:
        if from_config not in topic_dict:
            print(
                "merge_order_override contains topics that aren't in line with topiclist")
            sys.exit()
    for topic in topic_dict:
        if topic not in topic_list:
            topic_list.append(topic)

    topic_branches = [
        branch_name(
            'kernelupstream',
            rebase_target,
            topic) for topic in topic_list]
    merged_branch = branch_name('kernelupstream', rebase_target, None)

    print('checking out to ', rebase_target)
    checkout('kernel-upstream', rebase_target)

    try:
        print('creating head', merged_branch)
        create_head('kernel-upstream', merged_branch)
    except OSError as err:
        print(err)
        print('Branch already exists?')
        return

    print('checking out to ', merged_branch)
    checkout('kernel-upstream', merged_branch)

    for topic_branch in topic_branches:
        print('Merging', topic_branch)
        try:
            with sh.pushd('kernel-upstream'):
                sh.git('merge', '--no-edit', topic_branch)
            continue
        except sh.ErrorReturnCode_1 as error:
            if 'not something we can merge' in str(error):
                print(
                    'topic has no corresponding branch (' +
                    topic_branch +
                    '), skipping')
                continue
        print('Conflict found')
        if is_resolved('kernel-upstream'):
            print('Resolved automatically')
            with sh.pushd('kernel-upstream'):
                sh.git('-c', 'core.editor=/bin/true', 'merge', '--continue')
        else:
            print('Verify automatic resolution or resolve manually')
            print('Enter [s]top to exit or c[ontinue] to proceed')
            cmd = ''
            while cmd not in ['continue', 'stop', 's', 'c']:
                cmd = input()
            if cmd in ['stop', 's']:
                print('Exiting¡¬')
                return
    for fu in rebase_config.merge_fixups:
        print('Applying fixup', fu)
        try:
            patch = 'patches/fixups/{}.patch'.format(fu)
            patch = os.getcwd() + '/' + patch
            apply_patch('kernel-upstream', patch, '[merge]')
        except sh.ErrorReturnCode_128:
            print('Conflict found')
            with sh.pushd('kernel-upstream'):
                sh.git('am', '--abort')
            call_hook('[nosha]', 'post_drop')
        except Exception as err: # pylint: disable=broad-except
            print('Uknown error occured:')
            print(err)
            print('Enter [s]top to exit or c[ontinue] to proceed')

# The script only performs basic setup by itself. Specific actions
# are done via an interactive Python shell.
lc = LoggingConsole(local=dict(globals(), **locals()))
lc.interact()