def __init__(self, aSantiago, **kwargs):
santiago.debug_log("Creating Monitor.")
super(Monitor, self).__init__(aSantiago, **kwargs)
try:
d = cherrypy.tree.apps[""].config["/"]["request.dispatch"]
except KeyError:
d = cherrypy.dispatch.RoutesDispatcher()
root = HttpRoot(self.santiago)
routing_pairs = (
('/hosting/:client/:service', HttpHostedService(self.santiago)),
('/hosting/:client', HttpHostedClient(self.santiago)),
('/hosting', HttpHosting(self.santiago)),
('/consuming/:host/:service', HttpConsumedService(self.santiago)),
('/consuming/:host', HttpConsumedHost(self.santiago)),
('/consuming', HttpConsuming(self.santiago)),
('/learn/:host/:service', HttpLearn(self.santiago)),
("/stop", HttpStop(self.santiago)),
("/freedombuddy", root),
)
for location, handler in routing_pairs:
Monitor.rest_connect(d, location, handler)
cherrypy.tree.mount(root, "", {"/": {"request.dispatch": d}})
santiago.debug_log("Monitor Created.")
def index(self):
"""Receive an incoming Santiago request from another Santiago client."""
try:
body = cherrypy.request.body.read()
santiago.debug_log("Received request {0}".format(str(body)))
kwargs = urlparse.parse_qs(body)
self.incoming_request(kwargs["request"])
except Exception as e:
logging.exception(e)
def allow_requests(requests = None):
"""Refuse non-whitelisted request types.
Defaults to "GET"
"""
if requests is None:
requests = [ "GET" ]
# just in case they entered a single allowed type, like "POST"
if not hasattr(requests, "__iter__"):
requests = [requests]
if cherrypy.request.method not in requests:
santiago.debug_log("Request of improper type. Forbidden.")
raise cherrypy.HTTPError(405)
def allow_ips(ips = None):
"""Refuse connections from non-whitelisted IPs.
Defaults to the localhost.
Hook documentation is available in:
http://docs.cherrypy.org/dev/progguide/extending/customtools.html
"""
if ips == None:
ips = [ "127.0.0.1" ]
if cherrypy.request.remote.ip not in ips:
santiago.debug_log("Request from non-local IP. Forbidden.")
raise cherrypy.HTTPError(403)
def __init__(self, my_santiago, socket_port=0,
ssl_certificate="", ssl_private_key="", **kwargs):
santiago.debug_log("Creating Listener.")
super(santiago.SantiagoListener, self).__init__(my_santiago, **kwargs)
cherrypy.server.socket_port = int(socket_port)
cherrypy.server.ssl_certificate = ssl_certificate
cherrypy.server.ssl_private_key = ssl_private_key
d = cherrypy.dispatch.RoutesDispatcher()
d.connect("index", "/", self.index)
cherrypy.tree.mount(cherrypy.Application(self), "",
{"/": {"request.dispatch": d}})
santiago.debug_log("Listener Created.")
def outgoing_request(self, request, destination):
"""Send an HTTPS request to each Santiago client.
Don't queue, just immediately send the reply to each location we know.
It's both simple and as reliable as possible.
``request`` is literally the request's text. It needs to be wrapped for
transport across the protocol.
"""
santiago.debug_log("request {0}".format(str(request)))
body = urllib.urlencode({ "request": request })
if self.proxy:
destination = str(destination)
connection = httplib2.Http(proxy_info = self.proxy)
connection.request(destination, "POST", body)
(mykey, protocols, connectors, force_sender) = load_config(options)
# create listeners and senders
listeners, senders, monitors = configure_connectors(protocols, connectors)
# services to host and consume
url = "https://localhost:8080"
# configure system
# TODO Set this automatically when no relevant data/(keyid).dat file exists.
if options.default_services:
service = "freedombuddy"
hosting = { mykey: { service: [url],
service + "-monitor" : [url + "/freedombuddy"] } }
consuming = { mykey: { service: [url],
service + "-monitor" : [url + "/freedombuddy"] } }
else:
hosting = consuming = None
freedombuddy = santiago.Santiago(listeners, senders, hosting, consuming,
me=mykey, monitors=monitors,
save_dir="../data",
force_sender=force_sender)
# run
with freedombuddy:
if "https" in protocols:
webbrowser.open_new_tab(url + "/freedombuddy")
santiago.debug_log("Santiago finished!")
