Honcho

https://honcho.readthedocs.io
Admin
Honcho is a Python-based command-line application and library for managing and running...
Tokens:12,023
Snippets:91
Trust Score:8.3
Update:9 months ago
Show doc for...
Tokens:
Raw
### Running Honcho from Command Line

Source: https://honcho.readthedocs.io/en/latest/index

Shows how to start applications defined in a Procfile using the `honcho start` command. It also includes an example of running Honcho using Python's module invocation.

```shell
$ honcho start

```

```shell
$ python -m honcho start

```

--------------------------------

### Honcho Export Examples for supervisord and upstart

Source: https://honcho.readthedocs.io/en/latest/_sources/export.rst

Provides concrete examples of using the `honcho export` command for `supervisord` and `upstart` formats. It shows how to specify the application name, format, and output directory.

```bash
$ honcho export -a myapp supervisord /etc/supervisor/conf.d

```

```bash
$ honcho export -a myapp upstart /etc/init
```

--------------------------------

### Starting Honcho with Custom Directory and Procfile

Source: https://honcho.readthedocs.io/en/latest/using_procfiles

Demonstrates how to launch Honcho with specific configuration, overriding default values. This example shows specifying a different application root directory and Procfile name.

```shell
$ honcho -d .. -f Procfile.dev start
16:14:49 web.1 | started with pid 1234
...

```

--------------------------------

### Honcho Manager Process Execution Example

Source: https://honcho.readthedocs.io/en/latest/api

Demonstrates how to use the Honcho Manager to add and run multiple processes concurrently. It shows the basic setup for managing external processes and their lifecycle events. This example requires the 'honcho' library to be installed.

```python
import sys
from honcho.manager import Manager

m = Manager()
m.add_process('server', 'ruby server.rb')
m.add_process('worker', 'python worker.py')
m.loop()

sys.exit(m.returncode)

```

--------------------------------

### Example Procfile Syntax

Source: https://honcho.readthedocs.io/en/latest/index

Demonstrates the basic syntax of a Procfile, which describes how to run an application. It shows a simple web application and a more complex scenario with multiple worker processes.

```Procfile
web: python myapp.py

```

```Procfile
web: gunicorn -b "0.0.0.0:$PORT" -w 4 myapp:app
worker: python worker.py --priority high,med,low
worker_low: python worker.py --priority med,low

```

--------------------------------

### Honcho Export Examples (supervisord, upstart)

Source: https://honcho.readthedocs.io/en/latest/export

Demonstrates how to use the `honcho export` command to generate configuration files for supervisord and upstart. The `-a` flag specifies the application name.

```shell
$ honcho export -a myapp supervisord /etc/supervisor/conf.d

```

```shell
$ honcho export -a myapp upstart /etc/init

```

--------------------------------

### Start a Procfile application using Python module

Source: https://honcho.readthedocs.io/index

This command allows starting the application defined in the Procfile by invoking Honcho as a Python module directly. It's an alternative to using the globally installed honcho command.

```bash
$ python -m honcho start

```

--------------------------------

### Procfile Basic Syntax Example

Source: https://honcho.readthedocs.io/en/latest/using_procfiles

Demonstrates the fundamental structure of a Procfile, which defines process types and their corresponding shell commands. This file is essential for Honcho to manage application processes.

```shell
<process type>: <command>

```

--------------------------------

### Installing Honcho with Pip

Source: https://honcho.readthedocs.io/en/latest/index

Provides the command to install Honcho using pip, the Python package installer. This is the recommended method for obtaining a working installation.

```shell
pip install honcho

```

--------------------------------

### Start a Procfile application using Honcho

Source: https://honcho.readthedocs.io/index

This command initiates the application defined in the Procfile using the Honcho command-line tool. It starts all the processes specified in the Procfile.

```bash
$ honcho start

```

--------------------------------

### Registering a Custom Honcho Exporter with setuptools (Python)

Source: https://honcho.readthedocs.io/en/latest/_sources/export.rst

Shows how to register a custom Honcho exporter plugin using setuptools' `entry_points` mechanism. This allows Honcho to discover and use the custom exporter.

```python
from setuptools import setup

setup(
    name='honcho_export_simple',
    ...
    entry_points={
        'honcho_exporters': [
            'simple=honcho_export_simple:SimpleExport',
        ],
    },
)

```

--------------------------------

### Define a web application process in Procfile

Source: https://honcho.readthedocs.io/index

This example demonstrates a basic Procfile entry for running a Python web application. It specifies the command to execute, which in this case is `python myapp.py`.

```Procfile
web: python myapp.py

```

--------------------------------

### Start Process (ProcessManager)

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/manager

Initiates the execution of a managed process. It creates a multiprocessing.Process object with the specified target function and arguments, then starts the process.

```python
def _start(self):
        for name, p in self._processes.items():
            p['process'] = multiprocessing.Process(name=name,
                                                   target=p['obj'].run,
                                                   args=(self.events, True))
            p['process'].start()
```

--------------------------------

### Define and Run a Process with honcho.process

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/process

The Process class wraps subprocess.Popen to manage child processes. It handles command execution, environment setup, signal ignoring, and output streaming. It sends 'start' and 'stop' messages via an event queue.

```python
import datetime
import os
import signal
import subprocess

from .compat import ON_WINDOWS
from .printer import Message



class Process(object):
    """
    A simple utility wrapper around a subprocess.Popen that stores
    a number of attributes needed by Honcho and supports forwarding process
    lifecycle events and output to a queue.
    """
    def __init__(self,
                 cmd,
                 name=None,
                 colour=None,
                 quiet=False,
                 env=None,
                 cwd=None):
        self.cmd = cmd
        self.colour = colour
        self.quiet = quiet
        self.name = name
        self.env = os.environ.copy() if env is None else env
        self.cwd = cwd

        self._clock = datetime.datetime
        self._child = None
        self._child_ctor = Popen


    def run(self, events=None, ignore_signals=False):
        self._events = events
        self._child = self._child_ctor(self.cmd, env=self.env, cwd=self.cwd)
        self._send_message({'pid': self._child.pid}, type='start')

        # Don't pay attention to SIGINT/SIGTERM. The process itself is
        # considered unkillable, and will only exit when its child (the shell
        # running the Procfile process) exits.
        if ignore_signals:
            signal.signal(signal.SIGINT, signal.SIG_IGN)
            signal.signal(signal.SIGTERM, signal.SIG_IGN)

        for line in iter(self._child.stdout.readline, b''):
            if not self.quiet:
                self._send_message(line)
        self._child.stdout.close()
        self._child.wait()

        self._send_message({'returncode': self._child.returncode}, type='stop')


    def _send_message(self, data, type='line'):
        if self._events is not None:
            self._events.put(Message(type=type,
                                     data=data,
                                     time=self._clock.now(),
                                     name=self.name,
                                     colour=self.colour))

```

--------------------------------

### Custom Honcho Exporter Plugin Implementation (Python)

Source: https://honcho.readthedocs.io/en/latest/_sources/export.rst

Illustrates how to create a custom export plugin for Honcho by inheriting from `honcho.export.base.BaseExport`. It includes methods for loading templates and rendering them for processes.

```python
import jinja2

from honcho.export.base import BaseExport

class SimpleExport(BaseExport):
    def get_template_loader(self):
        return jinja2.PackageLoader(package_name=__package__,
                                    package_path='templates')

    def render(self, processes, context):
        tpl = get_template('run.sh')

        for p in processes:
            filename = 'run-{0}.sh'.format(p.name)
            ctx = context.copy()
            ctx['process'] = p
            script = tpl.render(ctx)

```

--------------------------------

### Honcho Export Command Usage

Source: https://honcho.readthedocs.io/en/latest/_sources/export.rst

Demonstrates the basic command structure for exporting Honcho Procfile configurations to different formats and locations. It specifies the format and destination directory.

```bash
$ honcho export FORMAT LOCATION
```

--------------------------------

### Define a multi-process Procfile for complex applications

Source: https://honcho.readthedocs.io/index

This Procfile example illustrates how to define multiple processes for a complex application, including a web server and different types of worker processes. It utilizes environment variables like $PORT for configuration.

```Procfile
web: gunicorn -b "0.0.0.0:$PORT" -w 4 myapp:app
worker: python worker.py --priority high,med,low
worker_low: python worker.py --priority med,low

```

--------------------------------

### Expand Process Definitions - Python

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/environ

Generates a list of process parameters to be started based on provided process definitions, concurrency settings, environment variables, and port numbers. It handles default concurrency and increments port numbers for each instance of a process type.

```python
from collections import defaultdict, namedtuple

ProcessParams = namedtuple("ProcessParams", "name cmd quiet env")

def expand_processes(processes, concurrency=None, env=None, quiet=None, port=None):
    """
    Get a list of the processes that need to be started given the specified
    list of process types, concurrency, environment, quietness, and base port
    number.

    Returns a list of ProcessParams objects, which have `name`, `cmd`, `env`,
    and `quiet` attributes, corresponding to the parameters to the constructor
    of `honcho.process.Process`.
    """
    if env is not None and env.get("PORT") is not None:
        port = int(env.get("PORT"))

    if quiet is None:
        quiet = []

    con = defaultdict(lambda: 1)
    if concurrency is not None:
        con.update(concurrency)

    out = []

    for name, cmd in processes.items():
        for i in range(con[name]):
            n = "{0}.{1}".format(name, i + 1)
            c = cmd
            q = name in quiet
            e = {'HONCHO_PROCESS_NAME': n}
            if env is not None:
                e.update(env)
            if port is not None:
                e['PORT'] = str(port + i)

            params = ProcessParams(n, c, q, e)
            out.append(params)
        if port is not None:
            port += 100

    return out

```

--------------------------------

### Default Jinja2 Environment Setup in Honcho

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/export/base

Configures and returns a default Jinja2 environment with specific filters applied. It uses a provided loader and adds filters for shell quoting (`shlex.quote`), dash replacement (`dashrepl`), and percent escaping (`percentescape`).

```python
def _default_template_env(loader):
    env = jinja2.Environment(loader=loader)
    env.filters['shellquote'] = shlex.quote
    env.filters['dashrepl'] = dashrepl
    env.filters['percentescape'] = percentescape
    return env
```

--------------------------------

### Manager Loop for Process Execution and Event Handling (Python)

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/manager

Documents the `loop` method of the Manager class, which is responsible for starting all added processes, multiplexing their output to a printer, and handling lifecycle events. It also manages termination signals (SIGTERM, SIGINT) and gracefully shuts down processes if one terminates unexpectedly or after a timeout.

```python
    def loop(self):
        """
        Start all the added processes and multiplex their output onto the bound
        printer (which by default will print to STDOUT).

        If one process terminates, all the others will be terminated by
        Honcho, and :func:`~honcho.manager.Manager.loop` will return.

        This method will block until all the processes have terminated.
        """
        def _terminate(signum, frame):
            self._system_print("%s received\n" % SIGNALS[signum]['name'])
            self.returncode = SIGNALS[signum]['rc']
            self.terminate()

        signal.signal(signal.SIGTERM, _terminate)
        signal.signal(signal.SIGINT, _terminate)

        self._start()

        exit = False
        exit_start = None

        while 1:
            try:
                msg = self.events.get(timeout=0.1)
            except queue.Empty:
                if exit:
                    break
            else:
                if msg.type == 'line':
                    self._printer.write(msg)
                elif msg.type == 'start':
                    self._processes[msg.name]['pid'] = msg.data['pid']
                    self._system_print("%s started (pid=%s)\n"
                                       % (msg.name, msg.data['pid']))
                elif msg.type == 'stop':
                    self._processes[msg.name]['returncode'] = msg.data['returncode']
                    self._system_print("%s stopped (rc=%s)\n"
                                       % (msg.name, msg.data['returncode']))
                    if self.returncode is None:
                        self.returncode = msg.data['returncode']

            if self._all_started() and self._all_stopped():
                exit = True

            if exit_start is None and self._all_started() and self._any_stopped():
                exit_start = self._clock.now()
                self.terminate()

            if exit_start is not None:
                # If we've been in this loop for more than KILL_WAIT seconds,
                # it's time to kill all remaining children.
                waiting = self._clock.now() - exit_start
                if waiting > datetime.timedelta(seconds=KILL_WAIT):
                    self.kill()

```

--------------------------------

### Setting Environment Variables with .env File

Source: https://honcho.readthedocs.io/en/latest/using_procfiles

Illustrates how to create a .env file to define environment variables that will be accessible to all processes managed by Honcho. This is a common way to configure application settings.

```shell
$ cat >.env <<EOF
RACK_ENV=production
ASSET_ROOT=https://myapp.s3.amazonaws.com/assets
PROCFILE=Procfile
EOF

```

--------------------------------

### Honcho Command-Line Help

Source: https://honcho.readthedocs.io/en/latest/using_procfiles

Displays the usage and available arguments for the Honcho command-line interface. This output shows various options for controlling Honcho's behavior, such as specifying environment files and directories.

```shell
$ honcho --help
usage: honcho [-h] [-e ENV] [-d DIR] [--no-colour] [--no-prefix] [-f FILE] [-v]
              {check,export,help,run,start,version} ...

Manage Procfile-based applications

optional arguments:
  -h, --help            show this help message and exit
  -e ENV, --env ENV     environment file[,file] (default: .env)
  -d DIR, --app-root DIR
                        procfile directory (default: .)
  --no-colour           disable coloured output
  --no-prefix           disable logging prefix
  -f FILE, --procfile FILE
                        procfile path (default: Procfile)
  -v, --version         show program's version number and exit

tasks:
  {check,export,help,run,start,version}
    check               validate a Procfile
    export              export a Procfile to another format
    help                describe available tasks or one specific task
    run                 run a command using your application's environment
    start               start the application (or a specific PROCESS)
    version             display honcho version


```

--------------------------------

### Merging Multiple Environment Files

Source: https://honcho.readthedocs.io/en/latest/using_procfiles

Shows how Honcho can merge environment variables from multiple .env files when specified with the -e option. This allows for more granular control over environment configurations.

```shell
$ echo 'ANIMAL_1=giraffe' >.env.one
$ echo 'ANIMAL_2=elephant' >.env.two
$ honcho -e .env.one,.env.two run sh -c 'env | grep -i animal'
ANIMAL_1=giraffe
ANIMAL_2=elephant


```

--------------------------------

### Manager Class Initialization and Process Addition (Python)

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/manager

Documents the initialization of the Manager class and the `add_process` method. The `Manager` class orchestrates the execution of multiple external processes, handling their output and lifecycle events. The `add_process` method allows adding new processes to be managed, specifying command, name, and optional environment or working directory.

```python
import datetime
import multiprocessing
import queue
import signal
import sys

from .colour import get_colours
from .compat import ProcessManager
from .printer import Message, Printer
from .process import Process

KILL_WAIT = 5
SIGNALS = {
    signal.SIGINT: {
        'name': 'SIGINT',
        'rc': 130,
    },
    signal.SIGTERM: {
        'name': 'SIGTERM',
        'rc': 143,
    },
}
SYSTEM_PRINTER_NAME = 'system'



class Manager(object):
    """
    Manager is responsible for running multiple external processes in parallel
    managing the events that result (starting, stopping, printing). By default
    it relays printed lines to a printer that prints to STDOUT.

    Example::

        import sys
        from honcho.manager import Manager

        m = Manager()
        m.add_process('server', 'ruby server.rb')
        m.add_process('worker', 'python worker.py')
        m.loop()

        sys.exit(m.returncode)
    """

    #: After :func:`~honcho.manager.Manager.loop` finishes,
    #: this will contain a return code that can be used with `sys.exit`.
    returncode = None

    def __init__(self, printer=None):
        self.events = multiprocessing.Queue()
        self.returncode = None

        self._colours = get_colours()
        self._clock = datetime.datetime
        self._procmgr = ProcessManager()

        self._printer = printer if printer is not None else Printer(sys.stdout)
        self._printer.width = len(SYSTEM_PRINTER_NAME)

        self._process_ctor = Process
        self._processes = {}

        self._terminating = False


    def add_process(self, name, cmd, quiet=False, env=None, cwd=None):
        """
        Add a process to this manager instance. The process will not be started
        until :func:`~honcho.manager.Manager.loop` is called.
        """
        assert name not in self._processes, "process names must be unique"
        proc = self._process_ctor(cmd,
                                  name=name,
                                  quiet=quiet,
                                  colour=next(self._colours),
                                  env=env,
                                  cwd=cwd)
        self._processes[name] = {}
        self._processes[name]['obj'] = proc

        # Update printer width to accommodate this process name
        self._printer.width = max(self._printer.width, len(name))

        return proc

```

--------------------------------

### Define and Load Procfile Content - Python

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/environ

Parses the content of a Procfile, extracting process names and their corresponding commands. It uses regular expressions to match lines in the format 'NAME: COMMAND' and stores them in an ordered dictionary.

```python
import os
import re
from collections import OrderedDict, defaultdict, namedtuple

PROCFILE_LINE = re.compile(r'^([A-Za-z0-9_-]+):\s*(.+)$')


class Procfile:
    """A data structure representing a Procfile"""

    def __init__(self):
        self.processes = OrderedDict()

    def add_process(self, name, command):
        assert name not in self.processes,
            "process names must be unique within a Procfile"
        self.processes[name] = command


def parse_procfile(contents):
    p = Procfile()
    for line in contents.splitlines():
        m = PROCFILE_LINE.match(line)
        if m:
            p.add_process(m.group(1), m.group(2))
    return p


class Env:

    def __init__(self, config):
        self._c = config

    @property
    def port(self):
        try:
            return int(self._c['port'])
        except ValueError:
            raise ValueError(f"invalid value for port: '{self._c['port']}'")

    @property
    def procfile(self):
        return os.path.join(self._c['app_root'], self._c['procfile'])


    def load_procfile(self):
        with open(self.procfile) as f:
            content = f.read()

        return parse_procfile(content)

```

--------------------------------

### Basic Honcho Export Command

Source: https://honcho.readthedocs.io/en/latest/export

This is the basic command structure for exporting Honcho Procfile configurations. It takes the desired format and the output location as arguments.

```shell
$ honcho export FORMAT LOCATION

```

--------------------------------

### Check Process Status (ProcessManager)

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/manager

Provides methods to check the overall status of managed processes. _all_started verifies if all processes have been initiated, _all_stopped checks if all have terminated, and _any_stopped determines if at least one process has stopped.

```python
def _all_started(self):
        return all(p.get('pid') is not None for _, p in self._processes.items())
```

```python
def _all_stopped(self):
        return all(p.get('returncode') is not None for _, p in self._processes.items())
```

```python
def _any_stopped(self):
        return any(p.get('returncode') is not None for _, p in self._processes.items())
```

--------------------------------

### Upstart Export Class for Honcho

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/export/upstart

The Export class in honcho.export.upstart inherits from BaseExport and is responsible for rendering process configurations into Upstart (.conf) files. It uses Jinja2 templating to generate master configuration files and individual process configuration files based on provided process definitions and context.

```python
from itertools import groupby

import jinja2

from honcho.export.base import BaseExport, File, dashrepl



[docs]
class Export(BaseExport):

[docs]
    def get_template_loader(self):
        return jinja2.PackageLoader(__name__, 'templates/upstart')



[docs]
    def render(self, processes, context):
        master_tpl = self.get_template('master.conf')
        process_master_tpl = self.get_template('process_master.conf')
        process_tpl = self.get_template('process.conf')

        groups = groupby(processes, lambda p: p.name.split('.')[0])

        master = "{0}.conf".format(context['app'])
        yield File(master, master_tpl.render(context))

        for name, procs in groups:
            group_name = "{0}-{1}".format(context['app'], name)

            ctx = context.copy()
            ctx.update({'group_name': group_name})

            process_master = "{0}.conf".format(group_name)
            yield File(process_master, process_master_tpl.render(ctx))

            for p in procs:
                ctx = context.copy()
                ctx.update({'group_name': group_name,
                            'process': p})
                process = "{0}-{1}.conf".format(context['app'],
                                                dashrepl(p.name))
                yield File(process, process_tpl.render(ctx))


```

--------------------------------

### Supervisord Export Class in Python

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/export/supervisord

Defines the Export class for generating supervisord configuration files. It utilizes Jinja2 for templating and requires 'jinja2' and 'honcho.export.base' as dependencies. The 'render' method takes process and context data to produce a list of File objects, each containing a supervisord configuration file.

```python
import jinja2

from honcho.export.base import BaseExport, File



class Export(BaseExport):


    def get_template_loader(self):
        return jinja2.PackageLoader(__name__, 'templates/supervisord')



    def render(self, processes, context):
        context['processes'] = processes
        filename = "{0}.conf".format(context['app'])
        template = self.get_template('supervisord.conf')
        return [File(filename, template.render(context))]
```

--------------------------------

### Manager Termination and Kill Methods (Python)

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/manager

Documents the `terminate` and `kill` methods of the Manager class. The `terminate` method initiates a graceful shutdown of all managed processes, while the `kill` method forcefully terminates any remaining processes, typically used after a timeout during graceful termination.

```python
    def terminate(self):
        """
        Terminate all processes managed by this ProcessManager.
        """
        if self._terminating:
            return
        self._terminating = True
        self._killall()


    def kill(self):
        """

```

--------------------------------

### Honcho Environment Variable Parsing

Source: https://honcho.readthedocs.io/en/latest/api

Provides functions for parsing environment files and procfiles. `parse` converts .env file content into a dictionary, while `parse_procfile` handles procfile content.

```python
def parse(_content_):
    """Parse the content of a .env file (a line-delimited KEY=value format) into a dictionary mapping keys to values."""
    pass

def parse_procfile(_contents_):
    pass

```

--------------------------------

### Honcho Upstart Export Class

Source: https://honcho.readthedocs.io/en/latest/api

Implements the export functionality for the Upstart service manager. It inherits from `BaseExport` and provides specific template loading and rendering for Upstart configuration files.

```python
class Export(BaseExport):
    """Honcho exporter for Upstart."""
    def get_template_loader(self):
        pass

    def render(self, processes , context):
        pass

```

--------------------------------

### Utility Functions for String Manipulation in Honcho

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/export/base

Provides utility functions for string manipulation used in template rendering. `dashrepl` replaces non-word characters with dashes, and `percentescape` doubles any percent signs, useful for safe string formatting within templates.

```python
[docs] def dashrepl(value):
    """
    Replace any non-word characters with a dash.
    """
    patt = re.compile(r'\W', re.UNICODE)
    return re.sub(patt, '-', value)



[docs] def percentescape(value):
    """
    Double any % signs.
    """
    return value.replace('%', '%%')
```

--------------------------------

### Custom Popen Implementation for honcho.process

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/process

A custom Popen class used by honcho.process. It configures subprocesses to pipe stdout to stderr, use the shell, and control window creation on Windows. It also manages session creation for better process group handling.

```python
class Popen(subprocess.Popen):

    def __init__(self, cmd, **kwargs):
        start_new_session = kwargs.pop('start_new_session', True)
        options = {
            'stdout': subprocess.PIPE,
            'stderr': subprocess.STDOUT,
            'shell': True,
            'close_fds': not ON_WINDOWS,
        }
        options.update(**kwargs)

        if ON_WINDOWS:
            # MSDN reference:
            #   http://msdn.microsoft.com/en-us/library/windows/desktop/ms684863%28v=vs.85%29.aspx
            create_no_window = 0x08000000
            options.update(creationflags=create_no_window)
        elif start_new_session:
            options.update(start_new_session=True)

        super(Popen, self).__init__(cmd, **options)

```

--------------------------------

### Honcho Process Expansion

Source: https://honcho.readthedocs.io/en/latest/api

Expands a list of process types into a detailed list of `ProcessParams` objects. This function considers concurrency, environment variables, quiet settings, and base port numbers.

```python
def expand_processes(_processes_ , _concurrency =None, _env =None, _quiet =None, _port =None):
    """Get a list of the processes that need to be started given the specified list of process types, concurrency, environment, quietness, and base port number. Returns a list of ProcessParams objects..."""
    pass

```

--------------------------------

### System Print Message (ProcessManager)

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/manager

Handles the printing of system-level messages. It formats the message with type, data, timestamp, name, and color, then writes it using the internal printer object.

```python
def _system_print(self, data):
        self._printer.write(Message(type='line',
                                    data=data,
                                    time=self._clock.now(),
                                    name=SYSTEM_PRINTER_NAME,
                                    colour=None))
```

--------------------------------

### Honcho Process Class Definition

Source: https://honcho.readthedocs.io/en/latest/api

Defines the `Process` class in Honcho, which acts as a utility wrapper around `subprocess.Popen`. It stores attributes necessary for Honcho and handles process lifecycle events and output forwarding.

```python
class Process(object):
    """A simple utility wrapper around a subprocess.Popen that stores a number of attributes needed by Honcho and supports forwarding process lifecycle events and output to a queue."""
    def __init__(self, cmd , name =None, colour =None, quiet =False, env =None, cwd =None):
        pass

    def run(self, events =None, ignore_signals =False):
        pass

```

--------------------------------

### Honcho Supervisord Export Class

Source: https://honcho.readthedocs.io/en/latest/api

Implements the export functionality for the Supervisord service manager. It inherits from `BaseExport` and provides specific template loading and rendering for Supervisord configuration files.

```python
class Export(BaseExport):
    """Honcho exporter for Supervisord."""
    def get_template_loader(self):
        pass

    def render(self, processes , context):
        pass

```

--------------------------------

### BaseExport Class for Template-Based Export in Honcho

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/export/base

The BaseExport class provides a foundation for creating export functionalities using Jinja2 templates. It handles template environment initialization, retrieval of templates, and rendering of process data. Subclasses must implement `get_template_loader` and `render` methods.

```python
[docs] class BaseExport(object):
    def __init__(self, template_dir=None, template_env=None):
        if template_env is not None:
            self._template_env = template_env
            return

        if template_dir is not None:
            loader = jinja2.FileSystemLoader([template_dir])
        else:
            loader = self.get_template_loader()

        self._template_env = _default_template_env(loader)


[docs]    def get_template(self, path):
        """
        Retrieve the template at the specified path. Returns an instance of
        :py:class:`Jinja2.Template` by default, but may be overridden by
        subclasses.
        """
        return self._template_env.get_template(path)



[docs]    def get_template_loader(self):
        raise NotImplementedError("You must implement a get_template_loader "
                                  "method.")



[docs]    def render(self, processes, context):
        raise NotImplementedError("You must implement a render method.")
```

--------------------------------

### File Class for Representing Exported Files

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/export/base

The File class is a simple data structure to hold information about a file that will be exported. It stores the file's name, content, and an optional flag indicating if the file should be executable.

```python
[docs] class File(object):
    def __init__(self, name, content, executable=False):
        self.name = name
        self.content = content
        self.executable = executable
```

--------------------------------

### Honcho Procfile Data Structure

Source: https://honcho.readthedocs.io/en/latest/api

Represents a Procfile data structure in Honcho. It allows for adding processes with their names and commands.

```python
class Procfile(object):
    """A data structure representing a Procfile."""
    def add_process(self, name , command):
        pass

```

--------------------------------

### Kill All Processes (ProcessManager)

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/manager

Terminates all processes managed by the ProcessManager. Supports forceful termination using SIGKILL or graceful termination using SIGTERM. It iterates through managed processes, checks if they are running (no return code), and sends the appropriate signal.

```python
def killall(self):
        """Kill all processes managed by this ProcessManager.
        """
        self._killall(force=True)
```

```python
def _killall(self, force=False):
        """Kill all remaining processes, forcefully if requested."""
        for_termination = []

        for n, p in self._processes.items():
            if 'returncode' not in p:
                for_termination.append(n)

        for n in for_termination:
            p = self._processes[n]
            signame = 'SIGKILL' if force else 'SIGTERM'
            self._system_print("sending %s to %s (pid %s)\n" %
                               (signame, n, p['pid']))
            if force:
                self._procmgr.kill(p['pid'])
            else:
                self._procmgr.terminate(p['pid'])
```

--------------------------------

### Parse .env File Content - Python

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/environ

Parses the content of a .env file, which is expected to be in a line-delimited KEY=value format. It returns a dictionary where keys are environment variable names and values are their corresponding string values. Special characters like \n and \t are correctly interpreted.

```python
import re
import shlex

def parse(content):
    """
    Parse the content of a .env file (a line-delimited KEY=value format) into a
    dictionary mapping keys to values.
    """
    values = {}
    for line in content.splitlines():
        lexer = shlex.shlex(line, posix=True)
        tokens = list(lexer)

        # parses the assignment statement
        if len(tokens) < 3:
            continue

        name, op = tokens[:2]
        value = ''.join(tokens[2:])

        if op != '=':
            continue
        if not re.match(r'[A-Za-z_][A-Za-z_0-9]*', name):
            continue

        value = value.replace(r'\n', '\n')
        value = value.replace(r'\t', '\t')
        values[name] = value

    return values

```

--------------------------------

### Honcho Environment Class Definition

Source: https://honcho.readthedocs.io/en/latest/api

Defines the `Env` class for managing environment variables within Honcho. It facilitates loading process file configurations and provides access to port and procfile properties.

```python
class Env(object):
    """Manages environment variables and loads procfile configurations."""
    def __init__(self, config):
        pass

    def load_procfile(self):
        pass

    @property
    def port(self):
        pass

    @property
    def procfile(self):
        pass

```

--------------------------------

### Import and Jinja2 Dependency Check for Honcho Export

Source: https://honcho.readthedocs.io/en/latest/_modules/honcho/export/base

Imports necessary modules like re, shlex, and sys. It checks for the jinja2 package, which is a hard requirement for honcho's 'export' command. If jinja2 is not found, it prints an informative error message to stderr and exits.

```python
import re
import shlex
import sys

try:
    import jinja2
except ImportError:
    print("honcho's 'export' command requires the jinja2 package,\n"
          "which you don't appear to have installed.\n"
          "\n"
          "To fix this, install honcho with the 'export' extra selected:\n"
          "\n"
          "    pip install honcho[export]\n",
          file=sys.stderr)
    sys.exit(1)
```

--------------------------------

### Honcho Base Export Class

Source: https://honcho.readthedocs.io/en/latest/api

The base class for export functionalities in Honcho. It provides methods for retrieving templates and rendering them with process context.

```python
class BaseExport(object):
    """Base class for exporting configurations to various service managers."""
    def __init__(self, template_dir =None, template_env =None):
        pass

    def get_template(self, path):
        """Retrieve the template at the specified path. Returns an instance of `Jinja2.Template` by default..."""
        pass

    def get_template_loader(self):
        pass

    def render(self, processes , context):
        pass

```
Tokens:
Raw