# -*- coding: utf-8 -*- # # pylint: disable=superfluous-parens # """ haproxyadmin.server ~~~~~~~~~~~~~~~~~~~~~~~ This module provides the :class:`Server <.Server>` class which allows to run operation for a server. """ from haproxyadmin.utils import (calculate, cmd_across_all_procs, compare_values, should_die, check_command, converter, check_command_addr_port, elements_of_list_same) from haproxyadmin.exceptions import IncosistentData STATE_ENABLE = 'enable' STATE_DISABLE = 'disable' STATE_READY = 'ready' STATE_DRAIN = 'drain' STATE_MAINT = 'maint' VALID_STATES = [ STATE_ENABLE, STATE_DISABLE, STATE_MAINT, STATE_DRAIN, STATE_READY, ] SERVER_METRICS = [ 'act', 'bck', 'bin', 'bout', 'check_duration', 'chkdown', 'chkfail', 'cli_abrt', 'ctime', 'downtime', 'dresp', 'econ', 'eresp', 'hrsp_1xx', 'hrsp_2xx', 'hrsp_3xx', 'hrsp_4xx', 'hrsp_5xx', 'hrsp_other', 'lastchg', 'lastsess', 'lbtot', 'qcur', 'qlimit', 'qmax', 'qtime', 'rate', 'rate_max', 'rtime', 'scur', 'slim', 'smax', 'srv_abrt', 'stot', 'throttle', 'ttime', 'weight', 'wredis', 'wretr', ] class Server: """Build a user-created :class:`Server` for a single server. :param _server_per_proc: list of :class:`._Server` objects. :type _server_per_proc: ``list`` :rtype: a :class:`Server`. """ def __init__(self, server_per_proc, backendname): self._server_per_proc = server_per_proc self.backendname = backendname self._name = self._server_per_proc[0].name # built-in comparison operator is adjusted def __eq__(self, other): if isinstance(other, Server): return (self.name == other.name) elif isinstance(other, str): return (self.name == other) else: return False def __ne__(self, other): return (not self.__eq__(other)) @property def sid(self): """Return the unique proxy server ID of the server. .. note:: Because server ID is the same across all processes, we return the proxy ID from the 1st process. :rtype: ``int`` """ return int(self._server_per_proc[0].sid) @property 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) @property 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) @property def port(self): """The assigned port of server. :getter: :rtype: ``string`` :setter: :param port: port to set. :type port: ``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 address is different # per process and not the assigned port. # Since we want to report the port, we simply catch that case and # report the assigned port. ports_across_proc = [value[1].split(':')[1] for value in values] if not elements_of_list_same(ports_across_proc): raise exc else: return ports_across_proc[0] else: return value.split(':')[1] @port.setter 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) @property 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] @address.setter 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) @property def last_status(self): """Return the last health check contents or textual error. :rtype: ``string`` """ values = cmd_across_all_procs( self._server_per_proc, 'metric', 'last_chk' ) return compare_values(values) @property 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 metric(self, name): """Return the value of a metric. Performs a calculation on the metric across all HAProxy processes. The type of calculation is either sum or avg and defined in :data:`haproxyadmin.utils.METRICS_SUM` and :data:`haproxyadmin.utils.METRICS_AVG`. :param name: The name of the metric :type name: any of :data:`haproxyadmin.haproxy.SERVER_METRICS` :rtype: number, integer :raise: ``ValueError`` when a given metric is not found """ if name not in SERVER_METRICS: raise ValueError("{} is not valid metric".format(name)) metrics = [x.metric(name) for x in self._server_per_proc] # num_metrics = filter(None, map(converter, metrics)) metrics[:] = (converter(x) for x in metrics) metrics[:] = (x for x in metrics if x is not None) return calculate(name, metrics) @property def name(self): """Return the name of the server. :rtype: ``string`` """ return self._name @property def requests(self): """Return the number of requests. :rtype: ``integer`` """ return self.metric('stot') 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 @property def process_nb(self): """Return a list of process number in which backend server is configured. :return: a list of process numbers. :rtype: ``list`` """ process_numbers = [] for server in self._server_per_proc: process_numbers.append(server.process_nb) return process_numbers @should_die def setstate(self, state): """Set the state of a server in the backend. State can be any of the following * :const:`haproxyadmin.STATE_ENABLE`: Mark the server UP and checks are re-enabled * :const:`haproxyadmin.STATE_DISABLE`: Mark the server DOWN for maintenance and checks disabled. * :const:`haproxyadmin.STATE_READY`: Put server in normal mode. * :const:`haproxyadmin.STATE_DRAIN`: Remove the server from load balancing. * :const:`haproxyadmin.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, STATE_DISABLE, STATE_ENABLE >>> 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 in ('enable', '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 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 @property 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) @property 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) @should_die 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) @should_die 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)