development.rst

$ make
$ make help
$ aptitude install make
# Activate virtual environment before any development work:
$ . venv/bin/activate

# Deactivate virtual environment when it is not needed anymore with:
(venv) $ deactivate
# Check for presence of all prerequisites:
$ make deps-prerequisites
# Install library locally:
(venv) $ pip install flask

# Get the version of the library:
(venv) $ pip freeze | grep -i flask

# Now write the library name with version to `conf/requirements.pip` and
# without version to `conf/requirements-latest.pip`.

# In case the library is required only for development write the library name
# with version to `conf/requirements-dev.pip` and without version to
# `conf/requirements-latest-dev.pip`.

# Make sure the dependency gets installed also using the makefile target:
(venv) $ make deps-python
(venv) $ make deps-python-dev
# Install dependency with yarn:
(venv) $ yarn add jquery

# Install development dependency with yarn:
(venv) $ yarn add grunt --dev

# Make sure the dependency gets installed also using the makefile target:
(venv) $ make deps-webui
# Activate virtual environment before any development work:
$ . venv/bin/activate

(venv) $ make deps-python-upgrade
(venv) $ make deps-python-upgrade-dev
(venv) $ make deps-webui-upgrade
# A: Use it manually, be carefull to provide the APP_ROOR_PATH as absolute path:
(venv) $ APP_ROOT_PATH=$(realpath ./chroot) mentat-controller.py --command start

# B: For your convenience there is also a makefile target:
(venv) $ make run-mentat-dev
# This:
(venv) $ make ctrl-mentat-dev COMMAND=start
# Is same as this:
(venv) $ APP_ROOT_PATH=$(realpath ./chroot) mentat-controller.py --command start

# This:
(venv) $ make ctrl-mentat-dev COMMAND=status
# Is same as this:
(venv) $ APP_ROOT_PATH=$(realpath ./chroot) mentat-controller.py --command status

# This:
(venv) $ make ctrl-mentat-dev COMMAND=stop
# Is same as this:
(venv) $ APP_ROOT_PATH=$(realpath ./chroot) mentat-controller.py --command stop
# A: You may use the Flask built-in command in a following way:
(venv) $ APP_ROOT_PATH=$(realpath ./chroot) FLASK_APP=hawat FLASK_ENV=development FLASK_CONFIG=development FLASK_CONFIG_FILE=$(realpath ./hawat.local.conf) flask run

# B: You may custom command line interface to launch webserver in development
# mode and with development configuration:
(venv) $ APP_ROOT_PATH=$(realpath ./chroot) FLASK_ENV=development FLASK_CONFIG=development FLASK_CONFIG_FILE=$(realpath ./hawat.local.conf) hawat-cli run

# C: Use following makefile target to do the same as the three above with less
# typing:
(venv) $ make run-webui-dev
# Always make sure your virtual environment is activated:
$ . venv/bin/activate

# Run tests:
(venv) $ pydoc3 ./path/to/module.py
# Always make sure your virtual environment is activated:
$ . venv/bin/activate

# Run tests:
(venv) $ make docs

# View the documentation in your default web browser:
(venv) $ make docs-view

# When necessary you may also remove all documentation related artifacts and
# rebuild:
(venv) $ make clean-build-docs
(venv) $ make docs
(venv) $ make docs-view
# Pull (extract and update) all translation strings into message catalogs:
(venv) $ make hpybabel-update

# Now please edit the translation files. For example for czech locale please
# edit file ``lib/hawat/translations/cs/messages.po``.

# When you are happy with your translations compile the message catalogs with:
(venv) $ make hpybabel-compile
# Always make sure your virtual environment is activated:
$ . venv/bin/activate

# Run tests:
(venv) $ make pyflakes
# Always make sure your virtual environment is activated:
$ . venv/bin/activate

# Run tests:
(venv) $ cd lib
(venv) $ pyflakes path/to/module.py
# Always make sure your virtual environment is activated:
$ . venv/bin/activate

# Run tests:
(venv) $ make pylint
# Always make sure your virtual environment is activated:
$ . venv/bin/activate

# Run tests:
(venv) $ cd lib
(venv) $ pylint --rcfile=../.pylintrc-lib path/to/module.py
# Always make sure your virtual environment is activated:
$ . venv/bin/activate

# Run tests:
(venv) $ make test
# Always make sure your virtual environment is activated:
$ . venv/bin/activate

# Run tests:
(venv) $ make build-webui
cd migrations-events
alembic revision -m "revision description"
cd migrations-events
alembic upgrade head
alembic history
/etc/mentat/scripts/sqldb-migrate-e.sh upgrade head
/etc/mentat/scripts/sqldb-migrate-e.sh history
# List all existing tags
git tag -l -n999

# Create new annotated tag and provide message
git tag -a v2.0.0

# Push tags to remote servers (if you are permitted to do so)
git push origin v2.0.0
git push buildbot v2.0.0

# Number of commits between last two versions:
$ git rev-list --count v1.0.0..v0.0.1

# Total changes between last two versions:
$ git log --numstat --pretty="%H" v1.0.0..v0.0.1 | awk 'NF==3 {plus+=$1; minus+=$2} END {printf("+%d, -%d\n", plus, minus)}'
# Always make sure your virtual environment is activated:
$ . venv/bin/activate

# Run tests:
(venv) $ make build-whl
# Always make sure your virtual environment is activated:
$ . venv/bin/activate

# Run tests:
(venv) $ make build-deb
import pyzenkit
import mentat.const
import mentat.daemon.piper

class DemoPrintComponent(pyzenkit.zendaemon.ZenDaemonComponent):

    def get_events(self):
        return [
            {
                'event': 'message_process',
                'callback': self.cbk_event_message_process,
                'prepend': False
            }
        ]

    def cbk_event_message_process(self, daemon, args):
        daemon.logger.info(
            "Processing message: '{}': '{}'".format(
                args['id'], str(args['data']).strip()
            )
        )
        daemon.queue.schedule('message_commit', args)
        self.inc_statistic('cnt_printed')
        return (daemon.FLAG_CONTINUE, None)

class DemoPiperDaemon(mentat.daemon.piper.PiperDaemon):

    def __init__(self):
        super().__init__(
            name        = 'mentat-demopiper.py',
            description = 'DemoPiperDaemon - Demonstration daemon',
            path_bin    = '/usr/local/bin',
            path_cfg    = '/tmp',
            path_log    = '/var/mentat/log',
            path_run    = '/var/mentat/run',
            path_tmp    = '/tmp',

            default_config_dir    = None,
            default_queue_in_dir  = '/var/mentat/spool/mentat-demopiper.py',
            default_queue_out_dir = None,

            schedule = [
                ('message_enqueue', {'data': '{"testA1": 1, "testA2": 2}'}),
                ('message_enqueue', {'data': '{"testB1": 1, "testB2": 2}'}),
                (mentat.const.DFLT_EVENT_START,)
            ],
            schedule_after = [
                (mentat.const.DFLT_INTERVAL_STATISTICS, mentat.const.DFLT_EVENT_LOG_STATISTICS)
            ],

            components = [
                DemoPrintComponent()
            ]
        )

if __name__ == "__main__":
DemoPiperDaemon().run()
# Configuration for module
{}
"queue_out_dir": "/var/mentat/spool/mentat-demopiper.py",
    {
    "exec": "mentat-demopiper.py",
    "args": [
        # Enable debug information before daemonization
        "--debug"
        # Force logging level ['debug', 'info', 'warning', 'error', 'critical']
        "--log-level=debug"
    ]
},
# Create symlink to example
ln -s /etc/mentat/examples/mentat-demopiper.py /usr/local/bin/mentat-demopiper.py
# Stop all currently running components
mentat-controller.py --command stop
# Start all currently components
mentat-controller.py --command start
# Generate test messages
mentat-ideagen.py --count 10
# View log file
tail -f /var/mentat/log/mentat-demopiper.py.log