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
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
# This file is part of GlusterFS.
#
# This file is licensed to you under your choice of the GNU Lesser
# General Public License, version 3 or any later version (LGPLv3 or
# later), or the GNU General Public License, version 2 (GPLv2), in all
# cases as published by the Free Software Foundation.
#
from __future__ import print_function
import sys
import signal
import SocketServer
import socket
from argparse import ArgumentParser, RawDescriptionHelpFormatter
from eventtypes import all_events
import handlers
import utils
from eventsapiconf import SERVER_ADDRESS, PID_FILE
from eventsapiconf import AUTO_BOOL_ATTRIBUTES, AUTO_INT_ATTRIBUTES
from utils import logger, PidFile, PidFileLockFailed, boolify
class GlusterEventsRequestHandler(SocketServer.BaseRequestHandler):
def handle(self):
data = self.request[0].strip()
logger.debug("EVENT: {0} from {1}".format(repr(data),
self.client_address[0]))
try:
# Event Format <TIMESTAMP> <TYPE> <DETAIL>
ts, key, value = data.split(" ", 2)
except ValueError:
logger.warn("Invalid Event Format {0}".format(data))
return
data_dict = {}
try:
# Format key=value;key=value
data_dict = dict(x.split('=') for x in value.split(';'))
except ValueError:
logger.warn("Unable to parse Event {0}".format(data))
return
for k, v in data_dict.iteritems():
try:
if k in AUTO_BOOL_ATTRIBUTES:
data_dict[k] = boolify(v)
if k in AUTO_INT_ATTRIBUTES:
data_dict[k] = int(v)
except ValueError:
# Auto Conversion failed, Retain the old value
continue
try:
# Event Type to Function Map, Recieved event data will be in
# the form <TIMESTAMP> <TYPE> <DETAIL>, Get Event name for the
# recieved Type/Key and construct a function name starting with
# handle_ For example: handle_event_volume_create
func_name = "handle_" + all_events[int(key)].lower()
except IndexError:
# This type of Event is not handled?
logger.warn("Unhandled Event: {0}".format(key))
func_name = None
if func_name is not None:
# Get function from handlers module
func = getattr(handlers, func_name, None)
# If func is None, then handler unimplemented for that event.
if func is not None:
func(ts, int(key), data_dict)
else:
# Generic handler, broadcast whatever received
handlers.generic_handler(ts, int(key), data_dict)
def signal_handler_sigusr2(sig, frame):
utils.load_all()
def init_event_server():
utils.setup_logger()
utils.load_all()
port = utils.get_config("port")
if port is None:
sys.stderr.write("Unable to get Port details from Config\n")
sys.exit(1)
# Start the Eventing Server, UDP Server
try:
server = SocketServer.ThreadingUDPServer(
(SERVER_ADDRESS, port),
GlusterEventsRequestHandler)
except socket.error as e:
sys.stderr.write("Failed to start Eventsd: {0}\n".format(e))
sys.exit(1)
server.serve_forever()
def get_args():
parser = ArgumentParser(formatter_class=RawDescriptionHelpFormatter,
description=__doc__)
parser.add_argument("-p", "--pid-file", help="PID File",
default=PID_FILE)
return parser.parse_args()
def main():
args = get_args()
try:
with PidFile(args.pid_file):
init_event_server()
except PidFileLockFailed as e:
sys.stderr.write("Failed to get lock for pid file({0}): {1}".format(
args.pid_file, e))
except KeyboardInterrupt:
sys.exit(1)
if __name__ == "__main__":
signal.signal(signal.SIGUSR2, signal_handler_sigusr2)
main()
|
