# patroni.config_generator module

patroni `--generate-config` machinery.

class patroni.config_generator.AbstractConfigGenerator(output_file: str | None)

  Bases: `ABC`

  Object representing the generated Patroni config.

  Variables:

    - output_file – full path to the output file to be used.

    - pg_major – integer representation of the major PostgreSQL version.

    - config – dictionary used for the generated configuration storage.

  _HOSTNAME = 'lcy02-amd64-006'
  _IP = '127.0.1.1'
  __init__(output_file: str | None) → None

    Set up the output file (if passed), helper vars and the minimal config structure.

    Parameters:

      output_file – full path to the output file to be used.

  _abc_impl = <_abc._abc_data object>
  static _format_block(block: Any, line_prefix: str = '') → str

    Format a single YAML block.

    Note

    Optionally the formatted block could be indented with the line_prefix

    Parameters:

      - block – the object that should be formatted to YAML.

      - line_prefix – is used for indentation.

    Returns:

      a formatted and indented block.

  _format_config() → Iterator[str]

    Format current `config` and enrich it with some comments.

    Yields:

      formatted lines or blocks that represent a text output of the YAML document.

  _format_config_section(section_name: str) → Iterator[str]

    Format and yield as single section of the current `config`.

    Note

    If the section is a `dict` object we put an empty line before it.

    Parameters:

      section_name – a section name in the `config`.

    Yields:

      a formatted section in case if it exists in the `config`.

  _write_config_to_fd(fd: TextIO) → None

    Format and write current `config` to provided file descriptor.

    Parameters:

      fd – where to write the config file. Could be `sys.stdout` or the real file.

  abstract generate() → None

    Generate config and store in `config`.

  classmethod get_template_config() → Dict[str, Any]

    Generate a template config for further extension (e.g. in the inherited classes).

    Returns:

      dictionary with the values gathered from Patroni env, hopefully defined hostname and ip address (otherwise set to `NO_VALUE_MSG`), and some sane defaults.

  write_config() → None

    Write current `config` to the output file if provided, to stdout otherwise.

class patroni.config_generator.RunningClusterConfigGenerator(output_file: str | None = None, dsn: str | None = None)

  Bases: `AbstractConfigGenerator`

  Object representing the Patroni config generated using information gathered from the running instance.

  Variables:

    - dsn – DSN string for the local instance to get GUC values from (if provided).

    - parsed_dsn – DSN string parsed into a dictionary (see `parse_dsn()`).

  __init__(output_file: str | None = None, dsn: str | None = None) → None

    Additionally store the passed dsn (if any) in both original and parsed version and run config generation.

    Parameters:

      - output_file – full path to the output file to be used.

      - dsn – DSN string for the local instance to get GUC values from.

    Raises:

      `PatroniException`: if DSN parsing failed.

  _abc_impl = <_abc._abc_data object>
  _enrich_config_from_running_instance() → None

    Extend `config` with the values gathered from the running instance.

    Retrieve the following information from the running PostgreSQL instance:

    - superuser auth parameters (see `_set_su_params()`);

    - some GUC values (see `_set_pg_params()`);

    - `postgresql.connect_address`, `postgresql.listen`;

    - `postgresql.pg_hba` and `postgresql.pg_ident` (see `_set_conf_files()`)

    And redefine `scope` with the `cluster_name` GUC value if set.

    Raises:

      `PatroniException`: if the provided user doesn’t have superuser privileges.

  _get_bin_dir_from_running_instance() → str

    Define the directory postgres binaries reside using postmaster’s pid executable.

    Returns:

      path to the PostgreSQL binaries directory.

    Raises:

      `PatroniException`: if:

      > - pid could not be obtained from the `postmaster.pid` file; or

      > - `OSError` occured during `postmaster.pid` file handling; or

      > - the obtained postmaster pid doesn’t exist.

  _get_connection_cursor() → Iterator[cursor | Cursor[Any]]

    Get cursor for the PG connection established based on the stored information.

    Raises:

      `PatroniException`: if `psycopg.Error` occured.

  property _get_hba_conn_types: Tuple[str, ...]

    Return the connection types allowed.

    If `pg_major` is defined, adds additional parameters for PostgreSQL version >=16.

    Returns:

      tuple of the connection methods allowed.

  property _required_pg_params: List[str]

    PG configuration prameters that have to be always present in the generated config.

    Returns:

      list of the parameter names.

  _set_conf_files() → None

    Extend `config` with `pg_hba.conf` and `pg_ident.conf` content.

    Note

    This function only defines `postgresql.pg_hba` and `postgresql.pg_ident` when `hba_file` and `ident_file` are set to the defaults. It may happen these files are located outside of `PGDATA` and Patroni doesn’t have write permissions for them.

    Raises:

      `PatroniException`: if `OSError` occured during the conf files handling.

  _set_pg_params(cur: cursor | Cursor[Any]) → None

    Extend `config` with the actual PG GUCs values.

    THe following GUC values are set:

    > - Non-internal having configuration file, postmaster command line or environment variable as a source.

    > - List of the always required parameters (see `_required_pg_params()`).

    Parameters:

      cur – connection cursor to use.

  _set_su_params() → None

    Extend `config` with the superuser auth information.

    Information set is based on the options used for connection.

  generate() → None

    Generate config using the info gathered from the specified running PG instance.

    Result is written to `config`.

class patroni.config_generator.SampleConfigGenerator(output_file: str | None)

  Bases: `AbstractConfigGenerator`

  Object representing the generated sample Patroni config.

  Sane defults are used based on the gathered PG version.

  _abc_impl = <_abc._abc_data object>
  _get_int_major_version() → int

    Get major PostgreSQL version from the binary as an integer.

    Returns:

      an integer PostgreSQL major version representation gathered from the PostgreSQL binary. See `postgres_major_version_to_int()` and `get_major_version()`.

  generate() → None

    Generate sample config using some sane defaults and update `config`.

  property get_auth_method: str

    Return the preferred authentication method for a specific PG version if provided or the default `md5`.

    Returns:

      `str` value for the preferred authentication method.

patroni.config_generator.generate_config(output_file: str, sample: bool, dsn: str | None) → None

  Generate Patroni configuration file.

  Parameters:

    - output_file – Full path to the configuration file to be used. If not provided, result is sent to `stdout`.

    - sample – Optional flag. If set, no source instance will be used - generate config with some sane defaults.

    - dsn – Optional DSN string for the local instance to get GUC values from.

patroni.config_generator.get_address() → Tuple[str, str]

  Try to get hostname and the ip address for it returned by `gethostname()`.

  Note

  Can also return local ip.

  Returns:

    tuple consisting of the hostname returned by `gethostname()` and the first element in the sorted list of the addresses returned by `getaddrinfo()`. Sorting guarantees it will prefer IPv4. If an exception occured, hostname and ip values are equal to `NO_VALUE_MSG`.