def routeToCSV(lat1,lon1,lat2,lon2, transport):
"""Format a route (as list of nodes)"""
data = LoadOsm(transport)
node1 = data.findNode(lat1,lon1)
node2 = data.findNode(lat2,lon2)
router = Router(data)
result, route = router.doRoute(node1, node2)
if result != 'success':
return("Fail")
output = ''
distance = 0
for i in route:
try:
old_node = new_node
new_node = data.rnodes[i]
distance+=geopy.distance.vincenty((new_node[0], new_node[1]), (old_node[0], old_node[1])).km
print(distance)
except UnboundLocalError:
new_node = data.rnodes[i]
"""output = output + "%d,%f,%f\n" % ( \
i,
node[0],
node[1])"""
return(distance)
class RequestHandler(BaseHTTPRequestHandler):
def __init__(self, request, client_address, server):
routes = [{
'regexp': r'^/$',
'controller': HomeController,
'action': 'indexAction'
}, {
'regexp': r'^/content/',
'controller': ContentController,
'action': 'showAction'
}, {
'regexp': r'^/api/',
'controller': APIController,
'action': 'indexAction'
}]
self.__router = Router(self)
for route in routes:
self.__router.addRoute(route['regexp'], route['controller'],
route['action'])
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def do_GET(self):
self.__router.route(self.path)
def routeToGpx(lat1,
lon1,
lat2,
lon2,
transport,
description="",
style="track"):
"""Format a route (as list of nodes) into a GPX file"""
data = LoadOsm(transport)
node1 = data.findNode(lat1, lon1)
node2 = data.findNode(lat2, lon2)
print("Nodes: {}, {}".format(node1, node2))
router = Router(data)
result, route = router.doRoute(node1, node2)
if result != 'success':
return
output = ''
output = output + "<?xml version='1.0'?>\n"
output = (output + "<gpx version='1.1' creator='pyroute' "
"xmlns='http://www.topografix.com/GPX/1/1' "
"xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' "
"xsi:schemaLocation='http://www.topografix.com/GPX/1/1 "
"http://www.topografix.com/GPX/1/1/gpx.xsd'>\n")
if (style == 'track'):
output = output + " <trk>\n"
output = output + " <name>%s</name>\n" % description
output = output + " <trkseg>\n"
count = 0
for i in route:
node = data.rnodes[i]
output = output + " <trkpt lat='%f' lon='%f'>\n" % (node[0],
node[1])
output = output + " </trkpt>\n"
count = count + 1
output = output + " </trkseg>\n </trk>\n</gpx>\n"
elif (style == 'route'):
output = output + " <rte>\n"
output = output + " <name>%s</name>\n" % description
count = 0
for i in route:
node = data.rnodes[i]
output = output + " <rtept lat='%f' lon='%f'>\n" % (node[0],
node[1])
output = output + " <name>%d</name>\n" % count
output = output + " </rtept>\n"
count = count + 1
output = output + " </rte>\n</gpx>\n"
return (output)
def routeToGpx(lat1,lon1,lat2,lon2, transport, description="", style="track"):
"""Format a route (as list of nodes) into a GPX file"""
data = LoadOsm(transport)
node1 = data.findNode(lat1,lon1)
node2 = data.findNode(lat2,lon2)
router = Router(data)
result, route = router.doRoute(node1, node2)
if result != 'success':
return
output = ''
output = output + "<?xml version='1.0'?>\n";
output = output + "<gpx version='1.1' creator='pyroute' xmlns='http://www.topografix.com/GPX/1/1' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:schemaLocation='http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd'>\n"
if(style == 'track'):
output = output + " <trk>\n"
output = output + " <name>%s</name>\n" % description
output = output + " <trkseg>\n"
count = 0;
for i in route:
node = data.rnodes[i]
output = output + " <trkpt lat='%f' lon='%f'>\n" % ( \
node[0],
node[1])
output = output + " </trkpt>\n"
count = count + 1
output = output + " </trkseg>\n </trk>\n</gpx>\n"
elif(style == 'route'):
output = output + " <rte>\n"
output = output + " <name>%s</name>\n" % description
count = 0;
for i in route:
node = data.rnodes[i]
output = output + " <rtept lat='%f' lon='%f'>\n" % ( \
node[0],
node[1])
output = output + " <name>%d</name>\n" % count
output = output + " </rtept>\n"
count = count + 1
output = output + " </rte>\n</gpx>\n"
return(output)
def __init__(self, catchall=True, autojson=True, config=None):
""" Create a new mole instance.
You usually don't do that. Use `mole.app.push()` instead.
"""
self.routes = [] # List of installed routes including metadata.
self.callbacks = {} # Cache for wrapped callbacks.
self.router = Router() # Maps to self.routes indices.
self.mounts = {}
self.error_handler = {}
self.catchall = catchall
self.config = config or {}
self.serve = True
self.castfilter = []
if autojson and json_dumps:
self.add_filter(dict, dict2json)
self.hooks = {'before_request': [], 'after_request': []}
def __init__(self, url, data):
self.ws = websocket.WebSocketApp(url)
# 存储所有cases
self.cases = CasesStorage()
self.route = Router()
self.data = data
self.url_map = self.route.url_map
self.last_message = None
def doRoute(self, from_lat, from_lon, to_lat, to_lon):
"""Route from one point to another, and set that as the active route"""
data = LoadOsm(self.get('transport', 'cycle'))
node1 = data.findNode(from_lat, from_lon)
node2 = data.findNode(to_lat, to_lon)
print "Routing from node %d to %d..." %(node1,node2)
router = Router(data)
result, route = router.doRoute(node1, node2)
if result == 'success':
self.route = []
for node_id in route:
node = data.rnodes[node_id]
self.route.append((node[0], node[1]))
print "Route discovered"
else:
print "Error in routing: " + result
def __init__(self, *args, **kwargs):
super(JsonProxyRestHandler, self).__init__(*args, **kwargs)
self.router = Router()
self.router.add(
Route('/search/jobs/<sid>/control', {"POST": self.job_control},
'job_control'))
self.router.add(
Route('/search/jobs/<sid>/<data_source>', {"GET": self.job_data},
'job_data'))
self.router.add(
Route('/search/jobs/<sid>', {
"GET": self.eai,
"DELETE": self.delete_job
}, 'job_info'))
self.router.add(
Route('/search/jobs', {
"GET": self.eai,
"POST": self.create_job
}, 'jobs'))
self.router.add(
Route('/search/parser', self.parse_query, 'parse_query'))
self.router.add(Route('/search/typeahead', self.typeahead,
'typeahead'))
self.router.add(
Route(
'/search/tags/<name>', {
"GET": self.eai,
"DELETE": self.modify_or_delete_tag,
"POST": self.modify_or_delete_tag
}, 'tag_info'))
self.router.add(
Route('/properties/<file>/<stanza>', self.properties_stanza,
'properties_stanza_info'))
self.router.add(
Route('/properties/<file>/<stanza>/<key>',
self.properties_stanza_key, 'properties_stanza_key'))
self.router.add(
Route('/receivers/simple', self.http_simple_input,
'http_simple_input'))
self.router.add(Route('/auth/login', {"POST": self.auth}, 'auth'))
self.router.add(Route('/<:.*>', self.eai, 'eai'))
def routeToCSV(lat1,lon1,lat2,lon2, transport):
"""Format a route (as list of nodes)"""
data = LoadOsm(transport)
node1 = data.findNode(lat1,lon1)
node2 = data.findNode(lat2,lon2)
router = Router(data)
result, route = router.doRoute(node1, node2)
if result != 'success':
return("Fail")
output = ''
for i in route:
node = data.rnodes[i]
output = output + "%d,%f,%f\n" % ( \
i,
node[0],
node[1])
return(output)
def routeToCSV(lat1, lon1, lat2, lon2, transport):
"""Format a route (as list of nodes)"""
data = LoadOsm(transport)
node1 = data.findNode(lat1, lon1)
node2 = data.findNode(lat2, lon2)
router = Router(data)
result, route = router.doRoute(node1, node2)
if result != 'success':
return ("Fail")
output = ''
for i in route:
node = data.rnodes[i]
output = output + "%d,%f,%f\n" % ( \
i,
node[0],
node[1])
return (output)
def __init__(self, catchall=True, autojson=True, config=None):
""" Create a new mole instance.
You usually don't do that. Use `mole.app.push()` instead.
"""
self.routes = [] # List of installed routes including metadata.
self.callbacks = {} # Cache for wrapped callbacks.
self.router = Router() # Maps to self.routes indices.
self.mounts = {}
self.error_handler = {}
self.catchall = catchall
self.config = config or {}
self.serve = True
self.castfilter = []
if autojson and json_dumps:
self.add_filter(dict, dict2json)
self.hooks = {'before_request': [], 'after_request': []}
def __init__(self, *args, **kwargs):
super(JsonProxyRestHandler, self).__init__(*args, **kwargs)
self.router = Router()
self.router.add(Route('/search/jobs/<sid>/control', {"POST": self.job_control}, 'job_control'))
self.router.add(Route('/search/jobs/<sid>/<data_source>', {"GET": self.job_data}, 'job_data'))
self.router.add(Route('/search/jobs/<sid>', {"GET": self.eai, "DELETE": self.delete_job}, 'job_info'))
self.router.add(Route('/search/jobs', {"GET": self.eai, "POST": self.create_job}, 'jobs'))
self.router.add(Route('/search/parser', self.parse_query, 'parse_query'))
self.router.add(Route('/search/typeahead', self.typeahead, 'typeahead'))
self.router.add(Route('/search/tags/<name>',
{
"GET": self.eai,
"DELETE": self.modify_or_delete_tag,
"POST": self.modify_or_delete_tag
},
'tag_info'
))
self.router.add(Route('/properties/<file>/<stanza>', self.properties_stanza, 'properties_stanza_info'))
self.router.add(Route('/properties/<file>/<stanza>/<key>', self.properties_stanza_key, 'properties_stanza_key'))
self.router.add(Route('/receivers/simple', self.http_simple_input, 'http_simple_input'))
self.router.add(Route('/auth/login', {"POST": self.auth}, 'auth'))
self.router.add(Route('/<:.*>', self.eai, 'eai'))
class JsonProxyRestHandler(splunk.rest.BaseRestHandler):
def __init__(self, *args, **kwargs):
super(JsonProxyRestHandler, self).__init__(*args, **kwargs)
self.router = Router()
self.router.add(
Route('/search/jobs/<sid>/control', {"POST": self.job_control},
'job_control'))
self.router.add(
Route('/search/jobs/<sid>/<data_source>', {"GET": self.job_data},
'job_data'))
self.router.add(
Route('/search/jobs/<sid>', {
"GET": self.eai,
"DELETE": self.delete_job
}, 'job_info'))
self.router.add(
Route('/search/jobs', {
"GET": self.eai,
"POST": self.create_job
}, 'jobs'))
self.router.add(
Route('/search/parser', self.parse_query, 'parse_query'))
self.router.add(Route('/search/typeahead', self.typeahead,
'typeahead'))
self.router.add(
Route(
'/search/tags/<name>', {
"GET": self.eai,
"DELETE": self.modify_or_delete_tag,
"POST": self.modify_or_delete_tag
}, 'tag_info'))
self.router.add(
Route('/properties/<file>/<stanza>', self.properties_stanza,
'properties_stanza_info'))
self.router.add(
Route('/properties/<file>/<stanza>/<key>',
self.properties_stanza_key, 'properties_stanza_key'))
self.router.add(
Route('/receivers/simple', self.http_simple_input,
'http_simple_input'))
self.router.add(Route('/auth/login', {"POST": self.auth}, 'auth'))
self.router.add(Route('/<:.*>', self.eai, 'eai'))
# UNDONE
# This allows us to use basic auth, but it's not the ideal way to do this.
# The problem is that we want to be able to reuse the code in splunk.rest.simpleRequest,
# but that code does not allow us to set headers. As such, we have to create this wrapper
# class.
def wrap_http(self):
is_basicauth = self.is_basicauth()
basicauth = self.get_authorization()
class Http(httplib2.Http):
def request(self, *args, **kwargs):
if is_basicauth and kwargs.has_key("headers"):
kwargs["headers"]["Authorization"] = basicauth
return super(Http, self).request(*args, **kwargs)
return Http
def extract_path(self):
self.scrubbed_path = self.request['path'].replace(
"/services/json/v1", "")
if re.match(r"^/servicesNS/[^/]*/[^/]*", self.scrubbed_path):
self.scrubbed_path = re.sub(r"^(/servicesNS/[^/]*/[^/]*)(/.*)",
r"\2", self.scrubbed_path)
elif re.match(r"^/services/.*", self.scrubbed_path):
self.scrubbed_path = re.sub(r"^(/services)(/.*)", r"\2",
self.scrubbed_path)
if self.scrubbed_path.endswith("/"):
self.scrubbed_path = self.scrubbed_path[:-1]
if self.scrubbed_path.endswith("?"):
self.scrubbed_path = self.scrubbed_path[:-1]
def extract_sessionKey(self):
self.sessionKey = self.request["headers"].get(
"authorization", "").replace("Splunk", "").strip() or None
def extract_origin(self):
if self.request["headers"].has_key(REMOTEORIGIN_HEADER):
parsed = urlparse(self.request["headers"][REMOTEORIGIN_HEADER])
self.remote_origin = parsed.netloc.replace(":" + str(parsed.port),
"")
else:
self.remote_origin = self.request["remoteAddr"]
def extract_allowed_domains(self):
self.allowed_domains = None
self.settings = splunk.clilib.cli_common.getConfStanza(
CONF_FILE, SETTINGS_STANZA)
self.allowed_domains = map(
lambda s: s.strip(),
self.settings.get(ALLOWED_DOMAINS_KEY).split(","))
def is_basicauth(self):
return self.request["headers"].get("authorization",
"").startswith("Basic ")
def get_authorization(self):
return self.request["headers"].get("authorization", "")
def get_origin_error(self):
output = ODataEntity()
output.messages.append({
"type":
"HTTP",
"text":
"Origin '%s' is not allowed. Please check json.conf" %
self.remote_origin
})
return 403, self.render_odata(output)
def handle(self):
output = ODataEntity()
status = 500
try:
self.extract_path()
self.extract_origin()
self.extract_sessionKey()
self.extract_allowed_domains()
# Get the appropriate handler
handler, args, kwargs = self.router.match(self.scrubbed_path)
# Check to see if we are in the list of allowed domains
if not self.remote_origin in self.allowed_domains:
status, content = self.get_origin_error()
else:
if isinstance(handler, dict):
if handler.has_key(self.method):
handler = handler[self.method]
else:
self.set_response(404, "")
return
status, content = handler(*args, **kwargs)
except splunk.RESTException, e:
responseCode = e.statusCode
output.messages.append({
'type': 'HTTP',
'text': '%s %s' % (e.statusCode, e.msg)
})
if hasattr(e, 'extendedMessages') and e.extendedMessages:
for message in e.extendedMessages:
output.messages.append(message)
content = self.render_odata(output)
except Exception, e:
status = 500
output.messages.append({'type': 'ERROR', 'text': '%s' % e})
content = self.render_odata(output)
raise
def __init__(self, data):
Router.__init__(self,data)
Grower.__init__(self,data)
self.route = {'valid':False}
self.mode = 'direct';
router = Router([
{
'name': 'udpate_svn_and_import'
},
{
'name': 'move_new_data'
},
{
'name': 'make_reduced_data'
},
{
'name': 'pack_txt'
},
{
'name': 'sa_sweeps_tables'
},
{
'name': 'sa_time_tables_cpu',
'spin_flip_rate': 6.5e9
},
{
'name': 'dwave_anneal_time_table'
},
{
'name': 'scaling_ctq'
},
{
'name': 'scaling_dtq'
},
{
'name': 'scaling_dwave'
},
{
'name': 'make_backup_to_archive'
},
{
'name': 'make_backup_to_server'
},
])
class Mole(object):
""" WSGI application or Handler """
def __init__(self, catchall=True, autojson=True, config=None):
""" Create a new mole instance.
You usually don't do that. Use `mole.app.push()` instead.
"""
self.routes = [] # List of installed routes including metadata.
self.callbacks = {} # Cache for wrapped callbacks.
self.router = Router() # Maps to self.routes indices.
self.mounts = {}
self.error_handler = {}
self.catchall = catchall
self.config = config or {}
self.serve = True
self.castfilter = []
if autojson and json_dumps:
self.add_filter(dict, dict2json)
self.hooks = {'before_request': [], 'after_request': []}
def optimize(self, *a, **ka):
utils.depr("Mole.optimize() is obsolete.")
def mount(self, app, script_path):
''' Mount a Mole application to a specific URL prefix '''
if not isinstance(app, Mole):
raise TypeError('Only Mole instances are supported for now.')
script_path = '/'.join(filter(None, script_path.split('/')))
path_depth = script_path.count('/') + 1
if not script_path:
raise TypeError('Empty script_path. Perhaps you want a merge()?')
for other in self.mounts:
if other.startswith(script_path):
raise TypeError('Conflict with existing mount: %s' % other)
@self.route('/%s/:#.*#' % script_path, method="ANY")
def mountpoint():
request.path_shift(path_depth)
return app.handle(request.environ)
self.mounts[script_path] = app
def add_filter(self, ftype, func):
''' Register a new output filter. Whenever mole hits a handler output
matching `ftype`, `func` is applied to it. '''
if not isinstance(ftype, type):
raise TypeError("Expected type object, got %s" % type(ftype))
self.castfilter = [(t, f) for (t, f) in self.castfilter if t != ftype]
self.castfilter.append((ftype, func))
self.castfilter.sort()
def match_url(self, path, method='GET'):
return self.match({'PATH_INFO': path, 'REQUEST_METHOD': method})
def match(self, environ):
""" Return a (callback, url-args) tuple or raise HTTPError. """
target, args = self.router.match(environ)
try:
return self.callbacks[target], args
except KeyError:
callback, decorators = self.routes[target]
wrapped = callback
for wrapper in decorators[::-1]:
wrapped = wrapper(wrapped)
#for plugin in self.plugins or []:
# wrapped = plugin.apply(wrapped, rule)
functools.update_wrapper(wrapped, callback)
self.callbacks[target] = wrapped
return wrapped, args
def get_url(self, routename, **kargs):
""" Return a string that matches a named route """
scriptname = request.environ.get('SCRIPT_NAME', '').strip('/') + '/'
location = self.router.build(routename, **kargs).lstrip('/')
return urljoin(urljoin('/', scriptname), location)
def route(self,
path=None,
method='GET',
no_hooks=False,
decorate=None,
template=None,
template_opts={},
callback=None,
name=None,
static=False):
""" Decorator: Bind a callback function to a request path.
:param path: The request path or a list of paths to listen to. See
:class:`Router` for syntax details. If no path is specified, it
is automatically generated from the callback signature. See
:func:`yieldroutes` for details.
:param method: The HTTP method (POST, GET, ...) or a list of
methods to listen to. (default: GET)
:param decorate: A decorator or a list of decorators. These are
applied to the callback in reverse order (on demand only).
:param no_hooks: If true, application hooks are not triggered
by this route. (default: False)
:param template: The template to use for this callback.
(default: no template)
:param template_opts: A dict with additional template parameters.
:param name: The name for this route. (default: None)
:param callback: If set, the route decorator is directly applied
to the callback and the callback is returned instead. This
equals ``Mole.route(...)(callback)``.
"""
# @route can be used without any parameters
if callable(path): path, callback = None, path
# Build up the list of decorators
decorators = makelist(decorate)
if template: decorators.insert(0, view(template, **template_opts))
if not no_hooks: decorators.append(self._add_hook_wrapper)
#decorators.append(partial(self.apply_plugins, skiplist))
def wrapper(func):
for rule in makelist(path) or yieldroutes(func):
for verb in makelist(method):
if static:
rule = rule.replace(':', '\\:')
utils.depr("Use backslash to escape ':' in routes.")
#TODO: Prepare this for plugins
self.router.add(rule, verb, len(self.routes), name=name)
self.routes.append((func, decorators))
return func
return wrapper(callback) if callback else wrapper
def _add_hook_wrapper(self, func):
''' Add hooks to a callable. See #84 '''
@functools.wraps(func)
def wrapper(*a, **ka):
for hook in self.hooks['before_request']:
hook()
response.output = func(*a, **ka)
for hook in self.hooks['after_request']:
hook()
return response.output
return wrapper
def get(self, path=None, method='GET', **kargs):
""" Decorator: Bind a function to a GET request path.
See :meth:'route' for details. """
return self.route(path, method, **kargs)
def post(self, path=None, method='POST', **kargs):
""" Decorator: Bind a function to a POST request path.
See :meth:'route' for details. """
return self.route(path, method, **kargs)
def put(self, path=None, method='PUT', **kargs):
""" Decorator: Bind a function to a PUT request path.
See :meth:'route' for details. """
return self.route(path, method, **kargs)
def delete(self, path=None, method='DELETE', **kargs):
""" Decorator: Bind a function to a DELETE request path.
See :meth:'route' for details. """
return self.route(path, method, **kargs)
def error(self, code=500):
""" Decorator: Register an output handler for a HTTP error code"""
def wrapper(handler):
self.error_handler[int(code)] = handler
return handler
return wrapper
def hook(self, name):
""" Return a decorator that adds a callback to the specified hook. """
def wrapper(func):
self.add_hook(name, func)
return func
return wrapper
def add_hook(self, name, func):
''' Add a callback from a hook. '''
if name not in self.hooks:
raise ValueError("Unknown hook name %s" % name)
if name in ('after_request'):
self.hooks[name].insert(0, func)
else:
self.hooks[name].append(func)
def remove_hook(self, name, func):
''' Remove a callback from a hook. '''
if name not in self.hooks:
raise ValueError("Unknown hook name %s" % name)
self.hooks[name].remove(func)
def handle(self, environ):
""" Execute the handler bound to the specified url and method and return
its output. If catchall is true, exceptions are catched and returned as
HTTPError(500) objects. """
if not self.serve:
return HTTPError(503, "Server stopped")
try:
handler, args = self.match(environ)
return handler(**args)
except HTTPResponse, e:
return e
except Exception, e:
import traceback
traceback.print_exc()
if isinstance(e, (KeyboardInterrupt, SystemExit, MemoryError))\
or not self.catchall:
raise
return HTTPError(500, 'Unhandled exception', e, format_exc(10))
from client import Client
from route import Router
cli = Client(__name__)
sk = Router()
storage = cli.storage
if __name__ == '__main__':
cli.run()
class Mole(object):
""" WSGI application or Handler """
def __init__(self, catchall=True, autojson=True, config=None):
""" Create a new mole instance.
You usually don't do that. Use `mole.app.push()` instead.
"""
self.routes = [] # List of installed routes including metadata.
self.callbacks = {} # Cache for wrapped callbacks.
self.router = Router() # Maps to self.routes indices.
self.mounts = {}
self.error_handler = {}
self.catchall = catchall
self.config = config or {}
self.serve = True
self.castfilter = []
if autojson and json_dumps:
self.add_filter(dict, dict2json)
self.hooks = {'before_request': [], 'after_request': []}
def optimize(self, *a, **ka):
utils.depr("Mole.optimize() is obsolete.")
def mount(self, app, script_path):
''' Mount a Mole application to a specific URL prefix '''
if not isinstance(app, Mole):
raise TypeError('Only Mole instances are supported for now.')
script_path = '/'.join(filter(None, script_path.split('/')))
path_depth = script_path.count('/') + 1
if not script_path:
raise TypeError('Empty script_path. Perhaps you want a merge()?')
for other in self.mounts:
if other.startswith(script_path):
raise TypeError('Conflict with existing mount: %s' % other)
@self.route('/%s/:#.*#' % script_path, method="ANY")
def mountpoint():
request.path_shift(path_depth)
return app.handle(request.environ)
self.mounts[script_path] = app
def add_filter(self, ftype, func):
''' Register a new output filter. Whenever mole hits a handler output
matching `ftype`, `func` is applied to it. '''
if not isinstance(ftype, type):
raise TypeError("Expected type object, got %s" % type(ftype))
self.castfilter = [(t, f) for (t, f) in self.castfilter if t != ftype]
self.castfilter.append((ftype, func))
self.castfilter.sort()
def match_url(self, path, method='GET'):
return self.match({'PATH_INFO': path, 'REQUEST_METHOD': method})
def match(self, environ):
""" Return a (callback, url-args) tuple or raise HTTPError. """
target, args = self.router.match(environ)
try:
return self.callbacks[target], args
except KeyError:
callback, decorators = self.routes[target]
wrapped = callback
for wrapper in decorators[::-1]:
wrapped = wrapper(wrapped)
#for plugin in self.plugins or []:
# wrapped = plugin.apply(wrapped, rule)
functools.update_wrapper(wrapped, callback)
self.callbacks[target] = wrapped
return wrapped, args
def get_url(self, routename, **kargs):
""" Return a string that matches a named route """
scriptname = request.environ.get('SCRIPT_NAME', '').strip('/') + '/'
location = self.router.build(routename, **kargs).lstrip('/')
return urljoin(urljoin('/', scriptname), location)
def route(self, path=None, method='GET', no_hooks=False, decorate=None,
template=None, template_opts={}, callback=None, name=None,
static=False):
""" Decorator: Bind a callback function to a request path.
:param path: The request path or a list of paths to listen to. See
:class:`Router` for syntax details. If no path is specified, it
is automatically generated from the callback signature. See
:func:`yieldroutes` for details.
:param method: The HTTP method (POST, GET, ...) or a list of
methods to listen to. (default: GET)
:param decorate: A decorator or a list of decorators. These are
applied to the callback in reverse order (on demand only).
:param no_hooks: If true, application hooks are not triggered
by this route. (default: False)
:param template: The template to use for this callback.
(default: no template)
:param template_opts: A dict with additional template parameters.
:param name: The name for this route. (default: None)
:param callback: If set, the route decorator is directly applied
to the callback and the callback is returned instead. This
equals ``Mole.route(...)(callback)``.
"""
# @route can be used without any parameters
if callable(path): path, callback = None, path
# Build up the list of decorators
decorators = makelist(decorate)
if template: decorators.insert(0, view(template, **template_opts))
if not no_hooks: decorators.append(self._add_hook_wrapper)
#decorators.append(partial(self.apply_plugins, skiplist))
def wrapper(func):
for rule in makelist(path) or yieldroutes(func):
for verb in makelist(method):
if static:
rule = rule.replace(':','\\:')
utils.depr("Use backslash to escape ':' in routes.")
#TODO: Prepare this for plugins
self.router.add(rule, verb, len(self.routes), name=name)
self.routes.append((func, decorators))
return func
return wrapper(callback) if callback else wrapper
def _add_hook_wrapper(self, func):
''' Add hooks to a callable. See #84 '''
@functools.wraps(func)
def wrapper(*a, **ka):
for hook in self.hooks['before_request']: hook()
response.output = func(*a, **ka)
for hook in self.hooks['after_request']: hook()
return response.output
return wrapper
def get(self, path=None, method='GET', **kargs):
""" Decorator: Bind a function to a GET request path.
See :meth:'route' for details. """
return self.route(path, method, **kargs)
def post(self, path=None, method='POST', **kargs):
""" Decorator: Bind a function to a POST request path.
See :meth:'route' for details. """
return self.route(path, method, **kargs)
def put(self, path=None, method='PUT', **kargs):
""" Decorator: Bind a function to a PUT request path.
See :meth:'route' for details. """
return self.route(path, method, **kargs)
def delete(self, path=None, method='DELETE', **kargs):
""" Decorator: Bind a function to a DELETE request path.
See :meth:'route' for details. """
return self.route(path, method, **kargs)
def error(self, code=500):
""" Decorator: Register an output handler for a HTTP error code"""
def wrapper(handler):
self.error_handler[int(code)] = handler
return handler
return wrapper
def hook(self, name):
""" Return a decorator that adds a callback to the specified hook. """
def wrapper(func):
self.add_hook(name, func)
return func
return wrapper
def add_hook(self, name, func):
''' Add a callback from a hook. '''
if name not in self.hooks:
raise ValueError("Unknown hook name %s" % name)
if name in ('after_request'):
self.hooks[name].insert(0, func)
else:
self.hooks[name].append(func)
def remove_hook(self, name, func):
''' Remove a callback from a hook. '''
if name not in self.hooks:
raise ValueError("Unknown hook name %s" % name)
self.hooks[name].remove(func)
def handle(self, environ):
""" Execute the handler bound to the specified url and method and return
its output. If catchall is true, exceptions are catched and returned as
HTTPError(500) objects. """
if not self.serve:
return HTTPError(503, "Server stopped")
try:
handler, args = self.match(environ)
return handler(**args)
except HTTPResponse, e:
return e
except Exception, e:
import traceback;traceback.print_exc()
if isinstance(e, (KeyboardInterrupt, SystemExit, MemoryError))\
or not self.catchall:
raise
return HTTPError(500, 'Unhandled exception', e, format_exc(10))
# these have to be loaded in later, because route depends on loadOsm
# which depends on the modified crimeweights dictionary
from route import Router
from loadOsm import *
# load in the given OSM file
data = LoadOsm(sys.argv[1])
start_node = data.findNode(start_lat, start_lon, 'foot')
end_node = data.findNode(end_lat, end_lon, 'foot')
print 'Node IDs: ', start_node, 'to', end_node
print
# do the routing
router = Router(data)
result, route = router.doRouteAsLL(start_node, end_node, 'foot')
abs_dist = dist_miles(router.coords(start_node), router.coords(end_node))
print "Your destination is {0:.3f} miles away.".format(abs_dist)
dist_input = raw_input(
'Please enter, in miles, the maximum distance you want to traverse (leave blank if unnecessary): '
)
max_dist = None
if dist_input == '':
print 'Not accounting for distance.'
elif abs_dist > float(dist_input):
print 'Input distance less than absolute distance between nodes. Ignoring distance input.'
else:
max_dist = float(dist_input)
def __init__(self, data):
Router.__init__(self, data)
Grower.__init__(self, data)
self.route = {'valid': False}
self.mode = 'direct'
# these have to be loaded in later, because route depends on loadOsm
# which depends on the modified crimeweights dictionary
from route import Router
from loadOsm import *
# load in the given OSM file
data = LoadOsm(sys.argv[1])
start_node = data.findNode(start_lat, start_lon, 'foot')
end_node = data.findNode(end_lat, end_lon, 'foot')
print 'Node IDs: ',start_node,'to',end_node
print
# do the routing
router = Router(data)
result, route = router.doRouteAsLL(start_node, end_node, 'foot')
abs_dist = dist_miles(router.coords(start_node),router.coords(end_node))
print "Your destination is {0:.3f} miles away.".format(abs_dist)
dist_input = raw_input('Please enter, in miles, the maximum distance you want to traverse (leave blank if unnecessary): ')
max_dist = None
if dist_input == '':
print 'Not accounting for distance.'
elif abs_dist > float(dist_input):
print 'Input distance less than absolute distance between nodes. Ignoring distance input.'
else:
max_dist = float(dist_input)
# print out the results
def route_geojson(input_f, output_f, mode='foot', local_planet=None):
osmdata = LoadOsm(mode)
if local_planet is not None:
osmdata.getArea = lambda lat, lon: None
osmdata.api = None
print('loading osm data (this may take a while)...')
osmdata.loadOsm(local_planet)
print('starting router...')
router = Router(osmdata)
print('processing shapes...')
# First load up the shapes
layer = geojson.load(input_f)
non_linestring = 0
not_two_points = 0
unsuccessful = 0
successful = 0
very_long = 0
first = True
output_f.write('{"crs": {"type": "name", "properties": '
'{"name": "urn:ogc:def:crs:OGC:1.3:CRS84"}}, '
'"type": "FeatureCollection", "features": [\n')
for feature in layer.features:
if feature.geometry.type != 'LineString':
# Not a LineString, skip!
non_linestring += 1
continue
geometry = list(feature.geometry.coordinates)
if len(geometry) != 2:
# LineString with other than two points, skip!
not_two_points += 1
continue
if pythagoras(*geometry[0] + geometry[1]) > 1.0:
very_long += 1
continue
# Now find a route. Data has x,y coordinates, but function is y,x, so
# reverse the parameters.
start = osmdata.findNode(*geometry[0][::-1])
end = osmdata.findNode(*geometry[1][::-1])
result, route = router.doRoute(start, end)
if result != 'success':
unsuccessful += 1
continue
routed_geometry = []
for node_id in route:
node = osmdata.rnodes[node_id]
routed_geometry.append((node[1], node[0]))
new_feature = geojson.Feature(
geometry=geojson.LineString(coordinates=routed_geometry),
properties=feature.properties,
id=feature.id,
)
if not first:
output_f.write(',\n')
first = False
geojson.dump(new_feature, output_f)
output_f.flush()
successful += 1
output_f.write('\n]}\n')
output_f.close()
print(
'%d LineStrings routed. Errors: %d non-linestring(s), '
'%d linestring(s) with !=2 points, %d very long, '
'%d unsuccessful routings' %
(successful, non_linestring, not_two_points, very_long, unsuccessful))
class JsonProxyRestHandler(splunk.rest.BaseRestHandler):
def __init__(self, *args, **kwargs):
super(JsonProxyRestHandler, self).__init__(*args, **kwargs)
self.router = Router()
self.router.add(Route('/search/jobs/<sid>/control', {"POST": self.job_control}, 'job_control'))
self.router.add(Route('/search/jobs/<sid>/<data_source>', {"GET": self.job_data}, 'job_data'))
self.router.add(Route('/search/jobs/<sid>', {"GET": self.eai, "DELETE": self.delete_job}, 'job_info'))
self.router.add(Route('/search/jobs', {"GET": self.eai, "POST": self.create_job}, 'jobs'))
self.router.add(Route('/search/parser', self.parse_query, 'parse_query'))
self.router.add(Route('/search/typeahead', self.typeahead, 'typeahead'))
self.router.add(Route('/search/tags/<name>',
{
"GET": self.eai,
"DELETE": self.modify_or_delete_tag,
"POST": self.modify_or_delete_tag
},
'tag_info'
))
self.router.add(Route('/properties/<file>/<stanza>', self.properties_stanza, 'properties_stanza_info'))
self.router.add(Route('/properties/<file>/<stanza>/<key>', self.properties_stanza_key, 'properties_stanza_key'))
self.router.add(Route('/receivers/simple', self.http_simple_input, 'http_simple_input'))
self.router.add(Route('/auth/login', {"POST": self.auth}, 'auth'))
self.router.add(Route('/<:.*>', self.eai, 'eai'))
# UNDONE
# This allows us to use basic auth, but it's not the ideal way to do this.
# The problem is that we want to be able to reuse the code in splunk.rest.simpleRequest,
# but that code does not allow us to set headers. As such, we have to create this wrapper
# class.
def wrap_http(self):
is_basicauth = self.is_basicauth()
basicauth = self.get_authorization()
class Http(httplib2.Http):
def request(self, *args, **kwargs):
if is_basicauth and kwargs.has_key("headers"):
kwargs["headers"]["Authorization"] = basicauth
return super(Http,self).request(*args, **kwargs)
return Http
def extract_path(self):
self.scrubbed_path = self.request['path'].replace("/services/json/v1", "")
if re.match(r"^/servicesNS/[^/]*/[^/]*", self.scrubbed_path):
self.scrubbed_path = re.sub(r"^(/servicesNS/[^/]*/[^/]*)(/.*)", r"\2", self.scrubbed_path)
elif re.match(r"^/services/.*", self.scrubbed_path):
self.scrubbed_path = re.sub(r"^(/services)(/.*)", r"\2", self.scrubbed_path)
if self.scrubbed_path.endswith("/"):
self.scrubbed_path = self.scrubbed_path[:-1]
if self.scrubbed_path.endswith("?"):
self.scrubbed_path = self.scrubbed_path[:-1]
def extract_sessionKey(self):
self.sessionKey = self.request["headers"].get("authorization", "").replace("Splunk", "").strip() or None
def extract_origin(self):
if self.request["headers"].has_key(REMOTEORIGIN_HEADER):
parsed = urlparse(self.request["headers"][REMOTEORIGIN_HEADER])
self.remote_origin = parsed.netloc.replace(":" + str(parsed.port), "")
else:
self.remote_origin = self.request["remoteAddr"]
def extract_allowed_domains(self):
self.allowed_domains = None
self.settings = splunk.clilib.cli_common.getConfStanza(CONF_FILE, SETTINGS_STANZA)
self.allowed_domains = map(lambda s: s.strip(), self.settings.get(ALLOWED_DOMAINS_KEY).split(","))
def is_basicauth(self):
return self.request["headers"].get("authorization", "").startswith("Basic ")
def get_authorization(self):
return self.request["headers"].get("authorization", "")
def get_origin_error(self):
output = ODataEntity()
output.messages.append({
"type": "HTTP",
"text": "Origin '%s' is not allowed. Please check json.conf" % self.remote_origin
})
return 403, self.render_odata(output)
def handle(self):
output = ODataEntity()
status = 500
try:
self.extract_path()
self.extract_origin()
self.extract_sessionKey()
self.extract_allowed_domains()
# Get the appropriate handler
handler, args, kwargs = self.router.match(self.scrubbed_path)
# Check to see if we are in the list of allowed domains
if not self.remote_origin in self.allowed_domains:
status, content = self.get_origin_error()
else:
if isinstance(handler, dict):
if handler.has_key(self.method):
handler = handler[self.method]
else:
self.set_response(404, "")
return
status, content = handler(*args, **kwargs)
except splunk.RESTException, e:
responseCode = e.statusCode
output.messages.append({
'type': 'HTTP',
'text': '%s %s' % (e.statusCode, e.msg)
})
if hasattr(e, 'extendedMessages') and e.extendedMessages:
for message in e.extendedMessages:
output.messages.append(message)
content = self.render_odata(output)
except Exception, e:
status = 500
output.messages.append({
'type': 'ERROR',
'text': '%s' % e
})
content = self.render_odata(output)
raise