-
Notifications
You must be signed in to change notification settings - Fork 20
/
Copy pathneca.py
executable file
·150 lines (121 loc) · 4.88 KB
/
neca.py
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
#!/usr/bin/env python3
import argparse
import threading
import importlib
import os.path
import sys
import logging
import json
from eca import *
import eca.httpd
import eca.http
# logging
logger = logging.getLogger(__name__)
def _hr_items(seq):
"""Creates a more readable comma-separated list of things."""
return ', '.join("'{}'".format(e) for e in seq)
def log_level(level):
"""argparse type to allow log level to be set directly."""
numeric_level = getattr(logging, level.upper(), None)
if not isinstance(numeric_level, int):
message_template = "'{}' is not a valid logging level. Choose from {}"
message = message_template.format(level, _hr_items(log_level.allowed))
raise argparse.ArgumentTypeError(message)
return numeric_level
# the following are allowed names for log levels
log_level.allowed = ['debug', 'info', 'warning', 'error', 'critical']
def main_server(args, rules_module):
"""HTTP server entry point."""
# determine initial static content path
rules_path = os.path.dirname(os.path.abspath(rules_module.__file__))
rules_file = os.path.basename(os.path.abspath(rules_module.__file__))
rules_file, rules_ext = os.path.splitext(rules_file)
root_path = os.path.join(rules_path, "{}_static".format(rules_file))
# see if an override has been given (absolute or relative)
if hasattr(rules_module, 'root_content_path'):
if os.path.isabs(rules_module.root_content_path):
root_path = rules_module.root_content_path
else:
root_path = os.path.join(rules_path, rules_module.root_content_path)
# configure http server
httpd = eca.httpd.HTTPServer((args.ip, args.port))
# default root route
httpd.add_content('/', root_path)
# default events route
httpd.add_route('/events', eca.http.EventStream)
# default handlers for cookies and sessions
httpd.add_filter('/', eca.http.Cookies)
httpd.add_filter('/', eca.http.SessionManager('eca-session'))
# invoke module specific configuration
if hasattr(rules_module, 'add_request_handlers'):
rules_module.add_request_handlers(httpd)
# start serving
httpd.serve_forever()
def main_engine(args, rules_module):
"""
Rules engine only entry point.
"""
# create context
context = Context(init_data={'name': '__main__'})
context.start(daemon=False)
# attach printing emit listener to context
def emitter(name, event):
print("emit '{}': {}".format(event.name, json.loads(event.get('json'))))
context.channel.subscribe(emitter, 'emit')
# fire main event
with context_switch(context):
logger.info("Starting module '{}'...".format(args.file))
fire('main')
# then read each line and process
for line in sys.stdin:
fire('line', line)
fire('end-of-input')
def main():
"""
Main program entry point.
"""
parser = argparse.ArgumentParser(description='The Neca HTTP server.')
parser.set_defaults(entry_point=main_engine)
parser.add_argument('file',
default='simple.py',
help="The rules file to load (defaults to %(default)s).",
nargs='?')
parser.add_argument('-t', '--trace',
default=False,
action='store_true',
help='Trace the execution of rules.')
parser.add_argument('-l', '--log',
default='warning',
help="The log level to use. One of {} (defaults to '%(default)s')".format(_hr_items(log_level.allowed)),
metavar='LEVEL',
type=log_level)
parser.add_argument('-s', '--server',
dest='entry_point',
action='store_const',
const=main_server,
help='Start HTTP server instead of directly executing the module.')
parser.add_argument('-p', '--port',
default=8080,
help="The port to bind the HTTP server to (default to '%(default)s')",
type=int)
parser.add_argument('-i', '--ip',
default='localhost',
help="The IP to bind the HTTP server to (defaults to '%(default)s'")
args = parser.parse_args()
# set logging level
logging.basicConfig(level=args.log)
# enable trace logger if requested
if args.trace:
logging.getLogger('trace').setLevel(logging.DEBUG)
# load module
rules_dir, rules_file = os.path.split(args.file)
rules_name = os.path.splitext(rules_file)[0]
old_path = list(sys.path)
sys.path.insert(0, rules_dir)
try:
rules_module = importlib.import_module(rules_name)
finally:
sys.path[:] = old_path
args.entry_point(args, rules_module)
if __name__ == "__main__":
main()