def clear_acl(self, acl):
"""Remove all entries from a acl.
:param acl: acl id or a file.
:type acl: ``integer`` or a file path passed as ``string``
:return: True if command succeeds otherwise False
:rtype: bool
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.clear_acl(acl=4)
True
>>> hap.clear_acl(acl='/etc/haproxy/bl_frontend')
True
"""
if isint(acl):
cmd = "clear acl #{}".format(acl)
else:
cmd = "clear acl {}".format(acl)
results = cmd_across_all_procs(self._hap_processes, 'command',
cmd)
return check_command(results)
def add_acl(self, acl, pattern):
"""Add an entry into the acl.
:param acl: acl id or a file.
:type acl: ``integer`` or a file path passed as ``string``
:param pattern: entry to add.
:type pattern: ``string``
:return: ``True`` if command succeeds otherwise ``False``
:rtype: ``bool``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.show_acl(acl=4)
['0x23181c0 /static/css/']
>>> hap.add_acl(acl=4, pattern='/foo/' )
True
>>> hap.show_acl(acl=4)
['0x23181c0 /static/css/', '0x238f790 /foo/']
"""
if isint(acl):
cmd = "add acl #{} {}".format(acl, pattern)
else:
cmd = "add acl {} {}".format(acl, pattern)
results = cmd_across_all_procs(self._hap_processes, 'command',
cmd)
return check_command(results)
def add_map(self, mapid, key, value):
"""Add an entry into the map.
:param mapid: map id or a file.
:type mapid: ``integer`` or a file path passed as ``string``
:param key: key to add.
:type key: ``string``
:param value: Value assciated to the key.
:type value: ``string``
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.show_map(0)
['0x1a78b20 1 www.foo.com-1']
>>> hap.add_map(0, '9', 'foo')
True
>>> hap.show_map(0)
['0x1a78b20 1 www.foo.com-1', '0x1b15c80 9 foo']
"""
if isint(mapid):
cmd = "add map #{} {} {}".format(mapid, key, value)
else:
cmd = "add map {} {} {}".format(mapid, key, value)
results = cmd_across_all_procs(self._hap_processes, 'command',
cmd)
return check_command(results)
def command(self, cmd):
"""Send a command to haproxy process.
This allows a user to send any kind of command to
haproxy. We **do not* perfom any sanitization on input
and on output.
:param cmd: a command to send to haproxy process.
:type cmd: ``string``
:return: list of 2-item tuple
#. HAProxy process number
#. what the method returned
:rtype: ``list``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.command('show stats')
['0x23181c0 /static/css/']
>>> hap.add_acl(acl=4, pattern='/foo/' )
True
>>> hap.show_acl(acl=4)
['0x23181c0 /static/css/', '0x238f790 /foo/']
"""
return cmd_across_all_procs(self._hap_processes,
'command', cmd, full_output=True)
def get_acl(self, acl, value):
"""Lookup the value in the ACL.
:param acl: acl id or a file.
:type acl: ``integer`` or a file path passed as ``string``
:param value: value to lookup
:type value: ``string``
:return: matching patterns associated with ACL.
:rtype: ``string``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.show_acl(acl=4)
['0x2318120 /static/js/', '0x23181c0 /static/css/']
>>> hap.get_acl(acl=4, value='/foo')
'type=beg, case=sensitive, match=no'
>>> hap.get_acl(acl=4, value='/static/js/')
'type=beg, case=sensitive, match=yes, idx=tree, pattern="/static/js/"'
"""
if isint(acl):
cmd = "get acl #{} {}".format(acl, value)
else:
cmd = "get acl {} {}".format(acl, value)
get_results = cmd_across_all_procs(self._hap_processes, 'command', cmd)
get_info_proc1 = get_results[0][1]
if not check_output(get_info_proc1):
raise ValueError(get_info_proc1)
return get_info_proc1
def address(self):
"""The assigned address of server.
:getter: :rtype: ``string``
:setter:
:param address: address to set.
:type address: ``string``
:rtype: ``bool``
"""
values = cmd_across_all_procs(
self._server_per_proc, 'metric', 'addr'
)
try:
value = compare_values(values)
except IncosistentData as exc:
# haproxy returns address:port and compare_values() may raise
# IncosistentData exception because assigned port is different
# per process and not the assigned address.
# Since we want to report the address, we simply catch that case
# and report the assigned address.
addr_across_proc = [value[1].split(':')[0] for value in values]
if not elements_of_list_same(addr_across_proc):
raise exc
else:
return addr_across_proc[0]
else:
return value.split(':')[0]
def get_map(self, mapid, value):
"""Lookup the value in the map.
:param mapid: map id or a file.
:type mapid: ``integer`` or a file path passed as ``string``
:param value: value to lookup.
:type value: ``string``
:return: matching patterns associated with map.
:rtype: ``string``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.show_map(0)
['0x1a78980 11 new2', '0x1b15c00 22 0']
>>> hap.get_map(0, '11')
'type=str, case=sensitive, found=yes, idx=tree, key="11", value="new2", type="str"'
>>> hap.get_map(0, '10')
'type=str, case=sensitive, found=no'
"""
if isint(mapid):
cmd = "get map #{} {}".format(mapid, value)
else:
cmd = "get map {} {}".format(mapid, value)
get_results = cmd_across_all_procs(self._hap_processes, 'command',
cmd)
get_info_proc1 = get_results[0][1]
if not check_output(get_info_proc1):
raise CommandFailed(get_info_proc1[0])
return get_info_proc1
def setmaxconn(self, value):
"""Set maximum connection to the frontend.
:param die: control the handling of errors.
:type die: ``bool``
:param value: max connection value.
:type value: ``integer``
:return: ``True`` if value was set.
:rtype: ``bool``
:raise: If ``die`` is ``True``
:class:`haproxyadmin.exceptions.CommandFailed` or
:class:`haproxyadmin.exceptions.MultipleCommandResults` is raised
when something bad happens otherwise returns ``False``.
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> frontend = hap.frontend('frontend1_proc34')
>>> frontend.maxconn
>>> frontend.setmaxconn(50000)
True
>>> frontend.maxconn
100000
"""
if not isinstance(value, int):
raise ValueError("Expected integer and got {}".format(type(value)))
cmd = "set maxconn frontend {} {}".format(self.name, value)
results = cmd_across_all_procs(self._frontend_per_proc, 'command', cmd)
return check_command(results)
def clear_map(self, mapid):
"""Remove all entries from a mapid.
:param mapid: map id or a file
:type mapid: ``integer`` or a file path passed as ``string``
:return: ``True`` if command succeeds otherwise ``False``
:rtype: ``bool``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.clear_map(0)
True
>>> hap.clear_map(mapid='/etc/haproxy/bl_frontend')
True
"""
if isint(mapid):
cmd = "clear map #{}".format(mapid)
else:
cmd = "clear map {}".format(mapid)
results = cmd_across_all_procs(self._hap_processes, 'command',
cmd)
return check_command(results)
def address(self, address):
"""Set server's address."""
cmd = "set server {}/{} addr {}".format(
self.backendname, self.name, address
)
results = cmd_across_all_procs(self._server_per_proc, 'command', cmd)
return check_command_addr_port('addr', results)
def port(self, port):
"""Set server's port."""
cmd = "set server {}/{} addr {} port {}".format(
self.backendname, self.name, self.address, port
)
results = cmd_across_all_procs(self._server_per_proc, 'command', cmd)
return check_command_addr_port('port', results)
def check_code(self):
"""Return the check code.
:rtype: ``integer``
"""
values = cmd_across_all_procs(
self._server_per_proc, 'metric', 'check_code'
)
return compare_values(values)
def check_status(self):
"""Return the check status.
:rtype: ``string``
"""
values = cmd_across_all_procs(
self._server_per_proc, 'metric', 'check_status'
)
return compare_values(values)
def requests_per_process(self):
"""Return the number of requests for the server per process.
:rtype: A list of tuple, where 1st element is process number and 2nd
element is requests.
"""
results = cmd_across_all_procs(self._server_per_proc, 'metric', 'stot')
return results
def weight(self):
"""Return the weight.
:rtype: ``integer``
:raise: :class:`IncosistentData` exception if weight is different
per process
"""
values = cmd_across_all_procs(self._server_per_proc, 'metric', 'weight')
return compare_values(values)
def last_agent_check(self):
"""Return the last agent check contents or textual error.
:rtype: ``string``
"""
values = cmd_across_all_procs(
self._server_per_proc, 'metric', 'last_agt'
)
return compare_values(values)
def status(self):
"""Return the status of the backend.
:rtype: ``string``
:raise: :class:`IncosistentData` exception if status is different
per process.
"""
results = cmd_across_all_procs(self._backend_per_proc, 'metric', 'status')
return compare_values(results)
def status(self):
"""Return the status of the server.
:rtype: ``string``
:raise: :class:`IncosistentData` exception if status is different
per process
"""
values = cmd_across_all_procs(self._server_per_proc, 'metric', 'status')
return compare_values(values)
def shutdown(self):
"""Terminate all the sessions attached to the specified server.
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
"""
cmd = "shutdown sessions server {b}/{s}".format(b=self.backendname,
s=self.name)
results = cmd_across_all_procs(self._server_per_proc, 'command', cmd)
return check_command(results)
def shutdown(self):
"""Disable the frontend.
.. warning::
HAProxy removes from the running configuration a frontend, so
further operations on the frontend will return an error.
:rtype: ``bool``
"""
cmd = "shutdown frontend {}".format(self.name)
results = cmd_across_all_procs(self._frontend_per_proc, 'command', cmd)
return check_command(results)
def stats_per_process(self):
"""Return all stats of the frontend per process.
:return: a list of tuples with 2 elements
#. process number
#. a dict with all stats
:rtype: ``list``
"""
results = cmd_across_all_procs(self._frontend_per_proc, 'stats')
return results
def setaddress(self, new_address, new_port=None):
"""Set this servers address.
:param new_address: new ip address of server
:param new_port: new port of server (optional)
:rtype: ``string``
"""
values = cmd_across_all_procs(
self._server_per_proc, 'setaddress', new_address=str(new_address), new_port=new_port
)
return compare_values(values)
def requests_per_process(self):
"""Return the number of requests for the backend per process.
:return: a list of tuples with 2 elements
#. process number of HAProxy
#. requests
:rtype: ``list``
"""
results = cmd_across_all_procs(self._backend_per_proc, 'metric', 'stot')
return results
def stats_per_process(self):
"""Return all stats of the server per process.
:return: A list of tuple 2 elements
#. process number
#. a dict with all stats
:rtype: ``list``
"""
values = cmd_across_all_procs(self._server_per_proc, 'stats')
return values
def stats_per_process(self):
"""Return all stats of the backend per process.
:return: a list of tuples with 2 elements
#. process number
#. a dict with all stats
:rtype: ``list``
"""
values = cmd_across_all_procs(self._backend_per_proc, 'stats')
return values
def setstate(self, state):
"""Set the state of a server in the backend.
State can be any of the following
* :const:`haproxyadmin.haproxy.STATE_ENABLE`: Mark the server UP and
checks are re-enabled
* :const:`haproxyadmin.haproxy.STATE_DISABLE`: Mark the server DOWN
for maintenance and checks disabled.
* :const:`haproxyadmin.haproxy.STATE_READY`: Put server in normal
mode.
* :const:`haproxyadmin.haproxy.STATE_DRAIN`: Remove the server from
load balancing.
* :const:`haproxyadmin.haproxy.STATE_MAINT`: Remove the server from
load balancing and health checks are disabled.
:param state: state to set.
:type state: ``string``
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
Usage:
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> server = hap.server('member_bkall', backend='backend_proc1')[0]
>>> server.setstate(haproxy.STATE_DISABLE)
True
>>> server.status
'MAINT'
>>> server.setstate(haproxy.STATE_ENABLE)
True
>>> server.status
'no check'
"""
if state not in VALID_STATES:
states = ', '.join(VALID_STATES)
raise ValueError("Wrong state, allowed states {}".format(states))
if state == 'enable' or state == 'disable':
cmd = "{} server {}/{}".format(state, self.backendname, self.name)
else:
cmd = "set server {}/{} state {}".format(
self.backendname, self.name, state
)
results = cmd_across_all_procs(self._server_per_proc, 'command', cmd)
return check_command(results)
def setstate(self, state):
"""Set the state of a server in the backend.
State can be any of the following
* :const:`haproxyadmin.haproxy.STATE_ENABLE`: Mark the server UP and
checks are re-enabled
* :const:`haproxyadmin.haproxy.STATE_DISABLE`: Mark the server DOWN
for maintenance and checks disabled.
* :const:`haproxyadmin.haproxy.STATE_READY`: Put server in normal
mode.
* :const:`haproxyadmin.haproxy.STATE_DRAIN`: Remove the server from
load balancing.
* :const:`haproxyadmin.haproxy.STATE_MAINT`: Remove the server from
load balancing and health checks are disabled.
:param state: state to set.
:type state: ``string``
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
Usage:
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> server = hap.server('member_bkall', backend='backend_proc1')[0]
>>> server.setstate(haproxy.STATE_DISABLE)
True
>>> server.status
'MAINT'
>>> server.setstate(haproxy.STATE_ENABLE)
True
>>> server.status
'no check'
"""
if state not in VALID_STATES:
states = ', '.join(VALID_STATES)
raise ValueError("Wrong state, allowed states {}".format(states))
if state == 'enable' or state == 'disable':
cmd = "{} server {}/{}".format(state, self.backendname, self.name)
else:
cmd = "set server {}/{} state {}".format(
self.backendname, self.name, state
)
results = cmd_across_all_procs(self._server_per_proc, 'command', cmd)
return check_command(results)
def requests_per_process(self):
"""Return the number of requests for the backend per process.
:return: a list of tuples with 2 elements
#. process number of HAProxy
#. requests
:rtype: ``list``
"""
results = cmd_across_all_procs(self._backend_per_proc, 'metric',
'stot')
return results
def nodename(self):
"""Return nodename of HAProxy
:rtype: ``string``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.nodename
'test.foo.com'
"""
values = cmd_across_all_procs(self._hap_processes, 'metric', 'node')
return compare_values(values)
def setratelimitsslsess(self, value):
"""Set process-wide ssl session rate limit.
:param value: rate ssl session limit.
:type value: ``integer``
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
:raises: ``ValueError`` if value is not an ``integer``.
"""
if not isinstance(value, int):
raise ValueError("Expected integer and got {}".format(type(value)))
cmd = "set rate-limit ssl-sessions global {}".format(value)
results = cmd_across_all_procs(self._hap_processes, 'command', cmd)
return check_command(results)
def enable(self):
"""Enable frontend.
:param die: control the handling of errors.
:type die: ``bool``
:return: ``True`` if frontend is enabled otherwise ``False``.
:rtype: bool
:raise: If ``die`` is ``True``
:class:`haproxyadmin.exceptions.CommandFailed` or
:class:`haproxyadmin.exceptions.MultipleCommandResults` is raised
when something bad happens otherwise returns ``False``.
"""
cmd = "enable frontend {}".format(self.name)
results = cmd_across_all_procs(self._frontend_per_proc, 'command', cmd)
return check_command(results)
def nodename(self):
"""Return nodename of HAProxy
:rtype: ``string``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.nodename
'test.foo.com'
"""
values = cmd_across_all_procs(self._hap_processes, 'metric',
'node')
return compare_values(values)
def enable(self):
"""Enable frontend.
:param die: control the handling of errors.
:type die: ``bool``
:return: ``True`` if frontend is enabled otherwise ``False``.
:rtype: bool
:raise: If ``die`` is ``True``
:class:`haproxyadmin.exceptions.CommandFailed` or
:class:`haproxyadmin.exceptions.MultipleCommandResults` is raised
when something bad happens otherwise returns ``False``.
"""
cmd = "enable frontend {}".format(self.name)
results = cmd_across_all_procs(self._frontend_per_proc, 'command', cmd)
return check_command(results)
def releasedate(self):
"""Return release date of HAProxy
:rtype: ``string``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.releasedate
'2014/10/31'
"""
values = cmd_across_all_procs(self._hap_processes, 'metric',
'Release_date')
return compare_values(values)
def uptime(self):
"""Return uptime of HAProxy process
:rtype: string
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.uptime
'4d 0h16m26s'
"""
values = cmd_across_all_procs(self._hap_processes, 'metric', 'Uptime')
# Just return the uptime of the 1st process
return values[0][1]
def description(self):
"""Return description of HAProxy
:rtype: ``string``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.description
'test'
"""
values = cmd_across_all_procs(self._hap_processes, 'metric',
'description')
return compare_values(values)
def description(self):
"""Return description of HAProxy
:rtype: ``string``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.description
'test'
"""
values = cmd_across_all_procs(self._hap_processes, 'metric',
'description')
return compare_values(values)
def releasedate(self):
"""Return release date of HAProxy
:rtype: ``string``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.releasedate
'2014/10/31'
"""
values = cmd_across_all_procs(self._hap_processes, 'metric',
'Release_date')
return compare_values(values)
def setratelimitsslsess(self, value):
"""Set process-wide ssl session rate limit.
:param value: rate ssl session limit.
:type value: ``integer``
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
:raises: ``ValueError`` if value is not an ``integer``.
"""
if not isinstance(value, int):
raise ValueError("Expected integer and got {}".format(type(value)))
cmd = "set rate-limit ssl-sessions global {}".format(value)
results = cmd_across_all_procs(self._hap_processes, 'command', cmd)
return check_command(results)
def show_acl(self, aclid=None):
"""Dump info about acls.
Without argument, the list of all available acls is returned.
If a aclid is specified, its contents are dumped.
:param aclid: (optional) acl id or a file
:type aclid: ``integer`` or a file path passed as ``string``
:return: a list with the acls
:rtype: ``list``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.show_acl(aclid=6)
['0x1d09730 ver%3A27%3Bvar%3A0']
>>> hap.show_acl()
['# id (file) description',
"1 () acl 'ssl_fc' file '/etc/haproxy/haproxy.cfg' line 83",
"2 () acl 'src' file '/etc/haproxy/haproxy.cfg' line 95",
"3 () acl 'path_beg' file '/etc/haproxy/haproxy.cfg' line 97",
]
"""
if aclid is not None:
if isint(aclid):
cmd = "show acl #{}".format(aclid)
else:
cmd = "show acl {}".format(aclid)
else:
cmd = "show acl"
acl_info = cmd_across_all_procs(self._hap_processes,
'command',
cmd,
full_output=True)
# ACL can't be different per process thus we only return the acl
# content found in 1st process.
acl_info_proc1 = acl_info[0][1]
if not check_output(acl_info_proc1):
raise CommandFailed(acl_info_proc1[0])
if len(acl_info_proc1) == 1 and not acl_info_proc1[0]:
return []
else:
return acl_info_proc1
def show_acl(self, aclid=None):
"""Dump info about acls.
Without argument, the list of all available acls is returned.
If a aclid is specified, its contents are dumped.
:param aclid: (optional) acl id or a file
:type aclid: ``integer`` or a file path passed as ``string``
:return: a list with the acls
:rtype: ``list``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.show_acl(aclid=6)
['0x1d09730 ver%3A27%3Bvar%3A0']
>>> hap.show_acl()
['# id (file) description',
"1 () acl 'ssl_fc' file '/etc/haproxy/haproxy.cfg' line 83",
"2 () acl 'src' file '/etc/haproxy/haproxy.cfg' line 95",
"3 () acl 'path_beg' file '/etc/haproxy/haproxy.cfg' line 97",
]
"""
if aclid is not None:
if isint(aclid):
cmd = "show acl #{}".format(aclid)
else:
cmd = "show acl {}".format(aclid)
else:
cmd = "show acl"
acl_info = cmd_across_all_procs(self._hap_processes, 'command',
cmd,
full_output=True)
# ACL can't be different per process thus we only return the acl
# content found in 1st process.
acl_info_proc1 = acl_info[0][1]
if not check_output(acl_info_proc1):
raise CommandFailed(acl_info_proc1[0])
if len(acl_info_proc1) == 1 and not acl_info_proc1[0]:
return []
else:
return acl_info_proc1
def version(self):
"""Return version of HAProxy
:rtype: ``string``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.version
'1.5.8'
"""
# If multiple version of HAProxy share the same socket directory
# then this wil always raise IncosistentData exception.
# TODO: Document this on README
values = cmd_across_all_procs(self._hap_processes, 'metric', 'Version')
return compare_values(values)
def uptimesec(self):
"""Return uptime of HAProxy process in seconds
:rtype: ``integer``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.uptimesec
346588
"""
values = cmd_across_all_procs(self._hap_processes, 'metric',
'Uptime_sec')
# Just return the uptime of the 1st process
return values[0][1]
def uptime(self):
"""Return uptime of HAProxy process
:rtype: string
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.uptime
'4d 0h16m26s'
"""
values = cmd_across_all_procs(self._hap_processes, 'metric',
'Uptime')
# Just return the uptime of the 1st process
return values[0][1]
def setweight(self, value):
"""Set a weight.
If the value ends with the '%' sign, then the new weight will be
relative to the initially configured weight. Absolute weights
are permitted between 0 and 256.
:param value: Weight to set
:type value: integer or string with '%' sign
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
Usage:
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> server = hap.server('member_bkall', backend='backend_proc1')[0]
>>> server.weight
100
>>> server.setweight('20%')
True
>>> server.weight
20
>>> server.setweight(58)
True
>>> server.weight
58
"""
msg = (
"Invalid weight, absolute weights are permitted between 0 and "
"256 and need to be passed as integers or relative weights "
"are allowed when the value ends with the '%' sign pass as "
"string"
)
if isinstance(value, int) and 0 <= value < 256 or (
isinstance(value, str) and value.endswith('%')):
cmd = "set weight {}/{} {}".format(self.backendname,
self.name,
value)
else:
raise ValueError(msg)
results = cmd_across_all_procs(self._server_per_proc, 'command', cmd)
return check_command(results)
def show_map(self, mapid=None):
"""Dump info about maps.
Without argument, the list of all available maps is returned.
If a mapid is specified, its contents are dumped.
:param mapid: (optional) map id or a file.
:type mapid: ``integer`` or a file path passed as ``string``
:return: a list with the maps.
:rtype: ``list``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.show_map()
['# id (file) description',
"0 (/etc/haproxy/v-m1-bk) pattern loaded ...... line 82",
]
>>> hap.show_map(mapid=0)
['0x1a78ab0 0 www.foo.com-0', '0x1a78b20 1 www.foo.com-1']
"""
if mapid is not None:
if isint(mapid):
cmd = "show map #{}".format(mapid)
else:
cmd = "show map {}".format(mapid)
else:
cmd = "show map"
map_info = cmd_across_all_procs(self._hap_processes,
'command',
cmd,
full_output=True)
# map can't be different per process thus we only return the map
# content found in 1st process.
map_info_proc1 = map_info[0][1]
if not check_output(map_info_proc1):
raise CommandFailed(map_info_proc1[0])
if len(map_info_proc1) == 1 and not map_info_proc1[0]:
return []
else:
return map_info_proc1
def set_map(self, mapid, key, value):
"""Modify the value corresponding to each key in a map.
mapid is the #<id> or <file> returned by
:func:`show_map <haproxyadmin.haproxy.HAProxy.show_map>`.
:param mapid: map id or a file.
:type mapid: ``integer`` or a file path passed as ``string``
:param key: key id
:type key: ``string``
:param value: value to set for the key.
:type value: ``string``
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.show_map(0)
['0x1a78980 11 9', '0x1b15c00 22 0']
>>> hap.set_map(0, '11', 'new')
True
>>> hap.show_map(0)
['0x1a78980 11 new', '0x1b15c00 22 0']
>>> hap.set_map(0, '0x1a78980', 'new2')
True
>>> hap.show_map(0)
['0x1a78980 11 new2', '0x1b15c00 22 0']
"""
if key.startswith('0x'):
key = "#{}".format(key)
if isint(mapid):
cmd = "set map #{} {} {}".format(mapid, key, value)
elif os.path.isfile(mapid):
cmd = "set map {} {} {}".format(mapid, key, value)
else:
raise ValueError("Invalid input")
results = cmd_across_all_procs(self._hap_processes, 'command', cmd)
return check_command(results)
def status(self):
"""Return the status of the frontend.
:rtype: ``string``
:raise: :class:`IncosistentData` exception if status is different
per process
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> frontend = hap.frontend('frontend2_proc34')
>>> frontend.status
'OPEN'
"""
results = cmd_across_all_procs(self._frontend_per_proc, 'metric',
'status')
return compare_values(results)
def del_map(self, mapid, key):
"""Delete all the map entries from the map corresponding to the key.
:param mapid: map id or a file.
:type mapid: ``integer`` or a file path passed as ``string``.
:param key: key to delete
:type key: ``string``
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.show_map(0)
['0x1b15cd0 9 foo', '0x1a78980 11 bar']
>>> hap.del_map(0, '0x1b15cd0')
True
>>> hap.show_map(0)
['0x1a78980 11 bar']
>>> hap.add_map(0, '22', 'bar22')
True
>>> hap.show_map(0)
['0x1a78980 11 bar', '0x1b15c00 22 bar22']
>>> hap.del_map(0, '22')
True
>>> hap.show_map(0)
['0x1a78980 11 bar']
"""
if key.startswith('0x'):
key = "#{}".format(key)
if isint(mapid):
cmd = "del map #{} {}".format(mapid, key)
elif os.path.isfile(mapid):
cmd = "del map {} {}".format(mapid, key)
else:
raise ValueError("Invalid input")
results = cmd_across_all_procs(self._hap_processes, 'command', cmd)
return check_command(results)
def clearcounters(self, all=False):
"""Clear the max values of the statistics counters.
When ``all`` is set to ``True`` clears all statistics counters in
each proxy (frontend & backend) and in each server. This has the same
effect as restarting.
:param all: (optional) clear all statistics counters.
:type all: ``bool``
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
"""
if all:
cmd = "clear counters all"
else:
cmd = "clear counters"
results = cmd_across_all_procs(self._hap_processes, 'command', cmd)
return check_command(results)
def requests_per_process(self):
"""Return the number of requests for the frontend per process.
:return: a list of tuples with 2 elements
#. process number of HAProxy
#. requests
:rtype: ``list``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> frontend = hap.frontend('frontend2_proc34')
>>> frontend.requests_per_process()
[(4, 2), (3, 3)]
"""
results = cmd_across_all_procs(self._frontend_per_proc, 'metric',
'req_tot')
return results
def setmaxconn(self, value):
"""Set maximum connection to the frontend.
:param value: value to set.
:type value: ``integer``
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
Usage:
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.setmaxconn(5555)
True
"""
if not isinstance(value, int):
raise ValueError("Expected integer and got {}".format(type(value)))
cmd = "set maxconn global {}".format(value)
results = cmd_across_all_procs(self._hap_processes, 'command', cmd)
return check_command(results)
def del_acl(self, acl, key):
"""Delete all the acl entries from the acl corresponding to the key.
:param acl: acl id or a file
:type acl: ``integer`` or a file path passed as ``string``
:param key: key to delete.
:type key: ``string``
:return: ``True`` if command succeeds otherwise ``False``.
:rtype: ``bool``
Usage::
>>> from haproxyadmin import haproxy
>>> hap = haproxy.HAProxy(socket_dir='/run/haproxy')
>>> hap.show_acl(acl=4)
['0x23181c0 /static/css/', '0x238f790 /foo/', '0x238f810 /bar/']
>>> hap.del_acl(acl=4, key='/static/css/')
True
>>> hap.show_acl(acl=4)
['0x238f790 /foo/', '0x238f810 /bar/']
>>> hap.del_acl(acl=4, key='0x238f790')
True
>>> hap.show_acl(acl=4)
['0x238f810 /bar/']
"""
if key.startswith('0x'):
key = "#{}".format(key)
if isint(acl):
cmd = "del acl #{} {}".format(acl, key)
elif os.path.isfile(acl):
cmd = "del acl {} {}".format(acl, key)
else:
raise ValueError("Invalid input")
results = cmd_across_all_procs(self._hap_processes, 'command', cmd)
return check_command(results)
def errors(self, iid=None):
"""Dump last known request and response errors.
If <iid> is specified, the limit the dump to errors concerning
either frontend or backend whose ID is <iid>.
:param iid: (optional) ID of frontend or backend.
:type iid: integer
:return: A list of tuples of errors per process.
#. process number
#. ``list`` of errors
:rtype: ``list``
"""
if iid:
cmd = "show errors {}".format(iid)
else:
cmd = "show errors"
return cmd_across_all_procs(self._hap_processes,
'command',
cmd,
full_output=True)
