def main():
arguments = docopt(__doc__)
if (arguments['--socket']):
try:
hap = haproxy.HAProxy(socket_file=arguments['--socket'])
except (SocketApplicationError, SocketConnectionError,
SocketPermissionError) as error:
print(error)
sys.exit(1)
except ValueError as error:
print(error)
sys.exit(1)
else:
try:
hap = haproxy.HAProxy(socket_dir=arguments['--socket-dir'])
except (SocketApplicationError, SocketConnectionError,
SocketPermissionError) as error:
print(error)
sys.exit(1)
except ValueError as error:
print(error)
sys.exit(1)
cmd = BackendCommand(hap, arguments)
method = get_arg_option(arguments)
getattr(cmd, method)()
def main():
arguments = docopt(__doc__)
if (arguments['--socket']):
try:
hap = haproxy.HAProxy(socket=arguments['--socket'])
except (SocketApplicationError,
SocketConnectionError,
SocketPermissionError) as error:
print(error)
sys.exit(1)
except ValueError as error:
print(error)
sys.exit(1)
else:
try:
hap = haproxy.HAProxy(socket_dir=arguments['--socket-dir'])
except (SocketApplicationError,
SocketConnectionError,
SocketPermissionError) as error:
print(error)
sys.exit(1)
except ValueError as error:
print(error)
sys.exit(1)
cmd = HAProxyCommand(hap, arguments)
method = get_arg_option(arguments)
try:
getattr(cmd, method)()
except CommandFailed as error:
sys.exit("failed with error: {err}".format(err=error))
def __init__(self,
metric,
frontend=None,
backend=None,
server=None,
hasocketdir=None,
hasocketfile=None,
nozerocounters=False,
min=None,
max=None,
scan=False):
self.haadmin = hapm.HAProxy(socket_dir=hasocketdir,
socket_file=hasocketfile)
self.metric = metric
self.frontend = frontend
self.backend = backend
self.server = server
self.set_mode()
self.nozerocounters = nozerocounters
self.min = min
self.max = max
if scan:
self.scan()
exit()
else:
if not self.get_ha_resource():
raise ValueError(
"HA resource was not found. Use --scan to check for resources."
)
def get_server(backend_name, server_name):
hap = haproxy.HAProxy(socket_file=HAPROXY_SOCKET_FILE)
servers = hap.server(server_name, backend=backend_name)
if (len(servers) > 0):
return ServerSchema().dump(servers[0]).data
else:
return None
def __init__(self):
self.hap = haproxy.HAProxy(socket_dir='/run/haproxy')
self.frontend_metrics = {}
self.backend_metrics = {}
self.server_metrics = {}
self.FRONTEND = "frontend"
self.BACKEND = "backend"
self.SERVER = "server"
def fetch_backend_sockets(data):
"""
Function to fetch data from haproxy sockets
"""
hap = haproxy.HAProxy(socket_dir="/var/lib/haproxy")
backends = hap.backends()
for backend in backends:
if backend.name == data:
print backend.process_nb
def del_ip():
if 'ipaddress' in request.form and request.form['ipaddress']:
ip=request.form['ipaddress'].strip()
if ipFormatChk(ip):
hap=haproxy.HAProxy(socket_dir='/var/run/',socket_file='haproxy.sock')
for x in hap.show_acl(0):
if x.split()[1] == ip :
hap.del_acl(0,ip)
return redirect(url_for('dashboard'))
return redirect(url_for('dashboard'))
def add_ip():
if not 'ipaddress' in request.form or not request.form['ipaddress']:
ip=get_x_ip()
else:
ip=request.form['ipaddress']
ip=ip.strip()
if ipFormatChk(ip):
hap=haproxy.HAProxy(socket_dir='/var/run/',socket_file='haproxy.sock')
acls=[ x.split()[1] for x in hap.show_acl(0) ]
if not ip in acls:
hap.add_acl(0,ip)
return redirect(url_for('dashboard'))
def start(self):
self.stop()
os.system(' '.join([
"haproxy",
"-f",
self.config,
"-p",
self.pid_file, # PID
"-sf",
_read_file(self.pid_file),
]))
self.socket = haproxy.HAProxy(socket_dir=self.socket_path)
for tor_group in self.tor_groups:
for tor in tor_group.instances.values():
tor.update_haproxy()
tor.enable()
def haproxy_object(arguments):
"""Return a HAProxy object.
:param arguments: Arguments of the progam
:type arguments: ``dict``
:return: A HAProxy object or exit main program in case of failure
:rtype: ``haproxy.HAProxy``
"""
if arguments['--file'] is not None:
arguments['--socket-dir'] = None
try:
hap = haproxy.HAProxy(socket_file=arguments['--file'],
socket_dir=arguments['--socket-dir'])
except (SocketApplicationError, SocketConnectionError,
SocketPermissionError) as error:
sys.exit(1)
except ValueError as error:
sys.exit(error)
else:
return hap
def fetch_haproxy_data():
"""
Function to fetch server state and
current connections from haproxy
"""
data = {}
hap = haproxy.HAProxy(socket_dir=config.get('haproxy', 'socket_dir'))
backends = hap.backends()
for backend in backends:
data[backend.name] = {}
data[backend.name]['bind-process'] = backend.process_nb
data[backend.name]['servers'] = {}
data[backend.name]['requests'] = {}
servers = backend.servers()
for server in servers:
try:
data[backend.name]['servers'][server.name] = server.status
except:
data[backend.name]['servers'][server.name] = "INCONSISTENT"
data[backend.name]['requests'][server.name] = server.metric('scur')
return data
def __init__(self, socket, config_file, haproxy_file):
"""Parse the config file and create corresponding watchers and pools"""
self._watchers = []
self._orchestrators = []
# Config parser
self._configurator = configurator.Configurator(socket, config_file,
haproxy_file)
# Get list of services and their configs
services = self._configurator.parse_config()
# Write the initial configuration to file
self._configurator.config_write()
# If there is an existing HAProxy running that is using the same
# pid file, take over the existing to avoid conflicts
if haproxy_cmd.haproxy_proc():
haproxy_cmd.restart_haproxy()
else:
haproxy_cmd.start_haproxy()
# Instantiate initial connection to haproxy socket only once
haproxy_sock = haproxy.HAProxy(socket_dir=socket)
# Share the single instance of haproxy socket and config parser for
# efficiency
for service_name, service in services.items():
self._watchers.append(
watcher.Watcher(service_name, service, self._configurator))
# Only create orchestrators when the config is present
if 'elasticity' in service:
self._orchestrators.append(
orchestrator.Orchestrator(service_name, service,
haproxy_sock))
# Run self._cleanup on exit
atexit.register(self._cleanup)
from flask_restplus import Resource
from base import api, STATUS_CODES
from haproxyadmin import haproxy
import config
hap = haproxy.HAProxy(socket_dir=config.haproxy_socket['DIR'],
socket_file=config.haproxy_socket['FILE'])
@api.route("/api/v1/errors", methods=['GET'])
class Errors(Resource):
def get(self):
return hap.errors()
from haproxyadmin import haproxy
hap = haproxy.HAProxy(socket_dir='/var/run/haproxy')
frontends = hap.frontends()
for frontend in frontends:
print(frontend.name, frontend.requests, frontend.process_nb)
FRONTEND_METRICS = ['scur', 'stot']
for m in FRONTEND_METRICS:
print("name {} value {}".format(m, frontend.metric(m)))
backends = hap.backends()
for backend in backends:
print(backend.name, backend.requests, backend.process_nb)
BACKEND_METRICS = ['scur', 'stot']
for m in BACKEND_METRICS:
print("name {} value {}".format(m, backend.metric(m)))
servers = backend.servers()
for server in servers:
print(" ", server.name, server.requests)
def main(args):
critical_level = 0.4 #default percentage of offline servers for critical
haproxy_socket = '/var/run/haproxy.sock'
critical_frontends = []
critical_backends = []
critical_servers = []
try:
opts, args = getopt.getopt(sys.argv[1:], "c:", ["climit="])
for opt, arg in opts:
if opt in ('-c', '--climit'):
critical_level = float(arg)
if opt in ('-s', '--socket'):
haproxy_socket = arg
except:
print 'Incorrect arguments.'
return UNKNOWN
if critical_level > 1:
critical_level = critical_level / 100
hap = haproxy.HAProxy(socket_file=haproxy_socket)
frontend_list = hap.frontends()
backend_list = hap.backends()
for frontend in frontend_list:
if frontend.status != 'OPEN':
critical_frontends.append((frontend.name, frontend.status))
for backend in backend_list:
if backend.status != 'UP':
critical_backends.append((backend.name, backend.status))
else:
server_list = backend.servers()
if len(server_list) == 0:
continue
for server in server_list:
if server.status != 'UP' and server.status != 'no check':
critical_servers.append(
(backend.name, server.name, server.status))
if (count_backend(critical_servers, backend.name) /
len(server_list)) >= critical_level:
critical_backends.append((backend.name, backend.status))
message = []
for frontend in critical_frontends:
message.append(frontend[0] + ' frontend is in ' + frontend[1] +
' state.')
for backend in critical_backends:
if backend[1] == 'UP':
message.append(backend[0] + ' backend has >' +
str(critical_level * 100) + '\% of servers down.')
else:
message.append(backend[0] + ' backend is in ' + backend[1] +
' state.')
if len(message) == 0:
if len(critical_servers) == 0:
print 'All frontends, backends, and attached servers are running and enabled.'
return OK
else:
for server in critical_servers:
message.append(server[1] + ' server of ' + server[0] +
' backend is in ' + server[2] + ' state.')
print '; '.join(message)
return WARNING
else:
print '; '.join(message)
return CRITICAL
def main():
parser = optparse.OptionParser(
description=
"Simply Nagios plugin to check HAProxy backends and frontends state",
version="0.0.1",
usage="usage: %prog -s /var/run/haproxy/ -t backends")
parser.add_option(
"-s",
"--sockets_path",
dest="sockets_path",
help="Enter path to the HAProxy sockets",
)
parser.add_option(
"-t",
"--section_type",
dest="section_type",
help="Select backends or frontends!",
)
(opts, args) = parser.parse_args()
try:
if not opts.sockets_path or not opts.section_type:
parser.print_help()
raise SystemExit(int(SIGNALS["ERROR"]))
elif opts.sockets_path is None:
parser.error('Please enter the path to HAProxy sockets!')
elif opts.section_type is None:
parser.error('Please select backends or frontends!')
elif opts.section_type not in ["backends", "frontends"]:
parser.error(
'Bad value! Possible values are backends or frontends!')
elif opts.section_type:
pass
except Exception as e:
logger.error(
'There was a problem parsing the arguments passed to the script! - {}'
.format(str(e)))
sys.exit(int(SIGNALS["ERROR"]))
try:
h = haproxy.HAProxy(socket_dir=opts.sockets_path)
pass
except Exception as e:
logger.error('Unable to connect to the HAProxy socket! - {}'.format(
str(e)))
sys.exit(int(SIGNALS["ERROR"]))
if opts.section_type == "backends":
try:
backendy = _getBackends(socket=h)
if backendy:
pass
else:
sys.exit(int(SIGNALS["UNKNOWN"]))
except Exception as e:
logger.error('Unable to retrieve backends data! - {}'.format(
str(e)))
sys.exit(int(SIGNALS["ERROR"]))
if opts.section_type == "frontends":
try:
frontendy = _getFrontends(socket=h)
if frontendy:
pass
else:
sys.exit(int(SIGNALS["UNKNOWN"]))
except Exception as e:
logger.error('Unable to retrieve frontends data! - {}'.format(
str(e)))
sys.exit(int(SIGNALS["ERROR"]))
if opts.section_type == "frontends":
filtered_frontends = {
k: v
for k, v in frontendy.items() if k not in exclude_app
}
else:
filtered_backends = {
k: v
for k, v in backendy.items() if k not in exclude_app
}
try:
other_backend = {}
down_backend = {}
up_backend = {}
if opts.section_type == "frontends":
for k, v in filtered_frontends.items():
if v == "DOWN":
down_backend[k] = v
elif v == "OPEN":
up_backend[k] = v
else:
other_backend.append(k)
elif opts.section_type == "backends":
for k, v in filtered_backends.items():
if v == "DOWN":
down_backend[k] = v
elif v == "UP":
up_backend[k] = v
else:
other_backend[k] = v
if down_backend and not other_backend:
raise ExceptionDownBackend
if other_backend:
raise ExceptionOtherBackend
if up_backend:
raise ExceptionUpBackend
except ExceptionDownBackend:
logger.error('Some {} has DOWN state: {}'.format(
opts.section_type, down_backend))
raise SystemExit(int(SIGNALS["ERROR"]))
except ExceptionOtherBackend:
logger.error('UNKNOW status of {}: - {}'.format(
opts.section_type, other_backend))
raise SystemExit(int(SIGNALS["UNKNOWN"]))
except ExceptionUpBackend:
logger.info('OK: All {} {} are right state'.format(
len(up_backend), opts.section_type))
raise SystemExit(int(SIGNALS["OK"]))
except Exception as e:
logger.error('Error processing or parsing output! - {}'.format(str(e)))
sys.exit(int(SIGNALS["ERROR"]))
finally:
if down_backend and other_backend:
error_backend = {**down_backend, **other_backend}
logger.error('Some {} has DOWN or UNKNOWN state: {}'.format(
opts.section_type, error_backend))
raise SystemExit(int(SIGNALS["ERROR"]))
else:
pass
import os
from flask import Flask, render_template, redirect, url_for, g
from haproxyadmin import haproxy, server
app = Flask(__name__)
config = os.environ.get('HAPLO_CONFIG', 'config.DevelopmentConfig')
app.config.from_object(config)
hap = haproxy.HAProxy(uris=app.config['HAPROXY_URIS'],
socket_dir=app.config['HAPROXY_SOCKET_DIR'],
socket_file=app.config['HAPROXY_SOCKET_FILE'])
@app.route('/')
def index():
refresh_servers()
return render_template('index.html.j2')
@app.route('/disable_server/<backend>/<s_name>')
def disable_server(backend=None, s_name=None):
b = hap.backend(backend)
s = b.server(s_name)
s.setstate(server.STATE_DISABLE)
return redirect(url_for('index'))
@app.route('/enable_server/<backend>/<s_name>')
def enable_server(backend=None, s_name=None):
b = hap.backend(backend)
def set_server_state(backend_name, server_name, state):
hap = haproxy.HAProxy(socket_file=HAPROXY_SOCKET_FILE)
servers = hap.server(server_name, backend=backend_name)
if (len(servers) > 0):
servers[0].setstate(state)
def dashboard():
ip=get_x_ip()
hap=haproxy.HAProxy(socket_dir='/var/run/',socket_file='haproxy.sock')
acls=[ x.split()[1] for x in hap.show_acl(0) ]
#hap.add_acl(0,'111.47.27.238/32') ##ref: http://haproxyadmin.readthedocs.io/en/latest/user/haproxy.html?highlight=acl
return render_template('dashboard.html', name=current_user.username, user_ip=ip, acls=acls)
def list_backends():
hap = haproxy.HAProxy(socket_file=config.haproxy.unix_socket)
backends = hap.backends()
return BackendSchema().dump(backends, many=True).data
def list_servers(backend_name):
hap = haproxy.HAProxy(socket_file=HAPROXY_SOCKET_FILE)
backend = hap.backend(backend_name)
servers = backend.servers()
return ServerSchema().dump(servers, many=True).data
