File: PKG-INFO

package info (click to toggle)
policyd-rate-limit 1.0.0-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 388 kB
  • sloc: python: 1,175; sh: 149; makefile: 58
file content (200 lines) | stat: -rw-r--r-- 10,784 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
Metadata-Version: 1.1
Name: policyd-rate-limit
Version: 1.0.0
Summary: Postfix rate limit policy server implemented in Python3.
Home-page: https://github.com/nitmir/policyd-rate-limit
Author: Valentin Samir
Author-email: valentin.samir@crans.org
License: GPLv3
Download-URL: https://github.com/nitmir/policyd-rate-limit/releases/latest
Description: Policyd rate limit
        ==================
        
        |travis| |coverage| |github_version| |pypi_version| |license|
        
        Postfix policyd server allowing to limit the number of mails accepted by
        postfix over several time periods, by sasl usernames and/or ip addresses.
        
        
        Installation
        ------------
        
        First, create the user that will run the daemon::
        
            adduser --system --group --home /run/policyd-rate-limit --no-create-home policyd-rate-limit
        
        Since version 0.6.0, the configuration file is written using the yaml, so you need the following
        package:
        
        * `pyyaml <https://pypi.python.org/pypi/PyYAML>`_
          (``sudo apt-get install python3-yaml`` on debian like systems)
        
        Depending of the backend storage you planning to use, you may need to install additional packages.
        (The default settings use the sqlite3 bakends and do not need extra packages).
        
        * `mysqldb <https://pypi.python.org/pypi/MySQL-python>`_
          (``sudo apt-get install python3-mysqldb`` on debian like systems) for the mysql backend.
        * `psycopg2 <https://pypi.python.org/pypi/psycopg2>`_
          (``sudo apt-get install python3-psycopg2`` on debian like systems) fot the postgresql backend
        
        Install with pip::
        
            sudo pip3 install policyd-rate-limit
        
        or from source code::
        
            sudo make install
        
        This will install the ``policyd_rate_limit`` module, the ``policyd-rate-limit`` binary,
        copy the default config to ``/etc/policyd-rate-limit.conf`` if the file do not exists,
        copy an init script to ``/etc/init.d/policyd-rate-limit`` and an unit file to
        ``/etc/systemd/system/policyd-rate-limit.service``.
        
        After the installation, you may need to run ``sudo systemctl daemon-reload`` for make the unit
        file visible by systemd.
        
        You should run ``policyd-rate-limit --clean`` on a regular basis to delete old records from the
        database. It could be wise to put it in a daily cron, for example::
        
            0 0 * * * policyd-rate-limit /usr/local/bin/policyd-rate-limit --clean >/dev/null
        
        
        Options of the ``policyd-rate-limit`` binary
        --------------------------------------------
        
        * ``-h``, ``--help``: show the help message and exit
        * ``--clean``: clean old records from the database
        * ``--get-config PARAMETER_NAME`` return the value of a config parameter
        * ``--file CONFIG_PATH``, ``-f CONFIG_PATH``: path to a config file
        
        Settings
        --------
        
        If the option ``--file`` is not specified, ``policyd-rate-limit`` try to read its configuration from
        the following path and choose the first existing file:
        
        * ~/.config/policyd-rate-limit.conf
        * ~/.config/policyd-rate-limit.yaml
        * /etc/policyd-rate-limit.conf
        * /etc/policyd-rate-limit.yaml
        
        The ``.conf`` are the old configuration format. It was a python module and should not be used.
        The ``.yaml`` are the new configuration format using the YAML syntax.
        
        
        * ``debug``: make ``policyd-rate-limit`` output logs to stderr.
          The default is ``True``.
        * ``user``: The user ``policyd-rate-limit`` will use to drop privileges.
          The default is ``"policyd-rate-limit"``.
        * ``group``: The group ``policyd-rate-limit`` will use to drop privileges.
          The defaut is ``"policyd-rate-limit"``.
        * ``pidfile``: path where the program will try to write its pid to.
          The default is ``"/var/run/policyd-rate-limit/policyd-rate-limit.pid"``.
          ``policyd-rate-limit`` will try to create the parent directory and chown it if it do not exists.
        * ``mysql_config``: The config to connect to a mysql server
        * ``pgsql_config``: The config to connect to a postgresql server
        * ``sqlite_config``: The config to connect to a sqlite3 database.
        * ``backend``: Which data backend to use. Possible values are ``0`` for sqlite3, ``1`` for mysql
          and ``2`` for postgresql. The default is ``0``, use the sqlite3 backend.
        * ``SOCKET``: The socket to bind to. Can be a path to an unix socket or a couple [ip, port].
          The default is ``"/var/spool/postfix/ratelimit/policy"``.
          ``policyd-rate-limit`` will try to create the parent directory and chown it if it do not exists.
        * ``socket_permission``: Permissions on the unix socket (if unix socket used).
          The default is ``0o666``.
        * ``limits``: A list of couple [number of emails, number of seconds]. If one of the element of the
          list is exeeded (more than 'number of emails' on 'number of seconds' for an ip address or an sasl
          username), postfix will return a temporary failure.
        * ``limits_by_id``: A dictionary of id -> limit list (see limits). Used to override limits and use
          custom limits for a particular id. Use an empty list for no limits for a particular id.
          Ids are sasl usernames or ip addresses. The default is ``{}``.
        * ``limit_by_sasl``: Apply limits by sasl usernames. The default is ``True``.
        * ``limit_by_sender``: Apply limits by sender addresses if sasl username is not found.
          The defaut is ``False``.
        * ``limit_by_ip``: Apply limits by ip addresses if sasl username and sender address are not found.
          The default is ``False``.
        * ``limited_networks``: A list of ip networks in cidr notation on which limits are applied. An empty
          list is equal to ``limit_by_ip = False``, put ``"0.0.0.0/0"`` and ``::/0`` for every ip addresses.
        * ``success_action``: If not limits are reach, which action postfix should do. The default is
          ``"dunno"``. See http://www.postfix.org/access.5.html for possible actions.
        * ``fail_action``: If a limit is reach, which action postfix should do. The default is
          ``"defer_if_permit Rate limit reach, retry later"``.
        * ``db_error_action`` : If we are unable to to contect the database backend, which action postfix
          should do. The default is ``"dunno"``. See http://www.postfix.org/access.5.html for possible
          actions.
          See http://www.postfix.org/access.5.html for possible actions.
        * ``config_file``: This parameter is automatically set to the path of the configuration file
          currently in use. You can call it conjunction with **--get-config** to known which configuration
          file is used.
        
        
        * ``report``: if ``True``, send a report to ``report_to`` about users reaching limits each time
          --clean is called. The default is ``False``.
        * ``report_from``: From who to send emails reports. It must be defined when ``report`` is ``True``.
        * ``report_to``: Address to send emails reports to. It must be defined when ``report`` is ``True``.
          It can be a single email address or a list of email adresses.
        * ``report_subject``: Subject of the report email. The default is ``"policyd-rate-limit report"``.
        * ``report_limits``: List of number of seconds from the limits list for which you want to be reported.
          The default is ``[86400]``.
        * ``report_only_if_needed``: Only send a report if some users have reach a reported limit.
          The default is ``True``.
        
        
        * ``smtp_server``: The smtp server to use to send emails ``["host", port]``.
          The default is ``["localhost", 25]``.
        * ``smtp_starttls``: Should we use starttls to send mails ? (you should set this to ``True`` if
          you use ``smtp_credentials``). The default is ``False``.
        * ``smtp_credentials``: Should we use credentials to connect to smtp_server ?
          if yes set ``["user", "password"]``, else ``null``. The default is ``null``.
        
        
        Postfix settings
        ----------------
        
        For postfix 3.0 and later I recommend using the example below. It ensure that if policyd-rate-limit
        become unavailable for any reason, postfix will ignore it and keep accepting mail as if the rule
        was not here. I find it nice has in my opinion, policyd-rate-limit is a "non-critical" policy
        service.
        
            /etc/postfix/main.cf::
        
                smtpd_recipient_restrictions =
                    ...,
                    check_policy_service { unix:ratelimit/policy, default_action=DUNNO },
                    ...
        
        
        On previous postfix versions, you must use:
        
            /etc/postfix/main.cf::
        
                smtpd_recipient_restrictions =
                    ...,
                    check_policy_service unix:ratelimit/policy,
                    ...
        
        
        .. |travis| image:: https://badges.genua.fr/travis/nitmir/policyd-rate-limit/master.svg
            :target: https://travis-ci.org/nitmir/policyd-rate-limit
        
        .. |coverage| image:: https://badges.genua.fr/coverage/badge/policyd-rate-limit/master.svg
            :target: https://badges.genua.fr/coverage/policyd-rate-limit/
        
        .. |pypi_version| image:: https://badges.genua.fr/pypi/v/policyd-rate-limit.svg
            :target: https://pypi.python.org/pypi/policyd-rate-limit
        
        .. |github_version| image:: https://badges.genua.fr/github/tag/nitmir/policyd-rate-limit.svg?label=github
            :target: https://github.com/nitmir/policyd-rate-limit/releases/latest
        
        .. |license| image:: https://badges.genua.fr/pypi/l/policyd-rate-limit.svg
            :target: https://www.gnu.org/licenses/gpl-3.0.html
        
Keywords: Postfix,rate,limit,email
Platform: UNKNOWN
Classifier: Environment :: No Input/Output (Daemon)
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
Classifier: Operating System :: POSIX
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Communications :: Email :: Mail Transport Agents
Classifier: Topic :: Communications :: Email :: Filters