def test_renderWithHost(self):
"""
L{NameVirtualHost.render} returns the result of rendering the resource
which is the value in the instance's C{host} dictionary corresponding
to the key indicated by the value of the I{Host} header in the request.
"""
virtualHostResource = NameVirtualHost()
virtualHostResource.addHost('example.org', Data("winner", ""))
request = DummyRequest([''])
request.headers['host'] = 'example.org'
d = _render(virtualHostResource, request)
def cbRendered(ignored, request):
self.assertEqual(''.join(request.written), "winner")
d.addCallback(cbRendered, request)
# The port portion of the Host header should not be considered.
requestWithPort = DummyRequest([''])
requestWithPort.headers['host'] = 'example.org:8000'
dWithPort = _render(virtualHostResource, requestWithPort)
def cbRendered(ignored, requestWithPort):
self.assertEqual(''.join(requestWithPort.written), "winner")
dWithPort.addCallback(cbRendered, requestWithPort)
return gatherResults([d, dWithPort])
def test_renderWithHost(self):
"""
L{NameVirtualHost.render} returns the result of rendering the resource
which is the value in the instance's C{host} dictionary corresponding
to the key indicated by the value of the I{Host} header in the request.
"""
virtualHostResource = NameVirtualHost()
virtualHostResource.addHost(b'example.org', Data(b"winner", ""))
request = DummyRequest([b''])
request.requestHeaders.addRawHeader(b'host', b'example.org')
d = _render(virtualHostResource, request)
def cbRendered(ignored, request):
self.assertEqual(b''.join(request.written), b"winner")
d.addCallback(cbRendered, request)
# The port portion of the Host header should not be considered.
requestWithPort = DummyRequest([b''])
requestWithPort.requestHeaders.addRawHeader(b'host', b'example.org:8000')
dWithPort = _render(virtualHostResource, requestWithPort)
def cbRendered(ignored, requestWithPort):
self.assertEqual(b''.join(requestWithPort.written), b"winner")
dWithPort.addCallback(cbRendered, requestWithPort)
return gatherResults([d, dWithPort])
def test_getChild(self):
"""
L{NameVirtualHost.getChild} returns correct I{Resource} based off
the header and modifies I{Request} to ensure proper prepath and
postpath are set.
"""
virtualHostResource = NameVirtualHost()
leafResource = Data(b"leaf data", "")
leafResource.isLeaf = True
normResource = Data(b"norm data", "")
virtualHostResource.addHost(b'leaf.example.org', leafResource)
virtualHostResource.addHost(b'norm.example.org', normResource)
request = DummyRequest([])
request.requestHeaders.addRawHeader(b'host', b'norm.example.org')
request.prepath = [b'']
self.assertIsInstance(virtualHostResource.getChild(b'', request),
NoResource)
self.assertEqual(request.prepath, [b''])
self.assertEqual(request.postpath, [])
request = DummyRequest([])
request.requestHeaders.addRawHeader(b'host', b'leaf.example.org')
request.prepath = [b'']
self.assertIsInstance(virtualHostResource.getChild(b'', request),
Data)
self.assertEqual(request.prepath, [])
self.assertEqual(request.postpath, [b''])
def test_getChild(self):
"""
L{_HostResource.getChild} returns the proper I{Resource} for the vhost
embedded in the URL. Verify that returning the proper I{Resource}
required changing the I{Host} in the header.
"""
bazroot = Data(b'root data', "")
bazuri = Data(b'uri data', "")
baztest = Data(b'test data', "")
bazuri.putChild(b'test', baztest)
bazroot.putChild(b'uri', bazuri)
hr = _HostResource()
root = NameVirtualHost()
root.default = Data(b'default data', "")
root.addHost(b'baz.com', bazroot)
request = DummyRequest([b'uri', b'test'])
request.prepath = [b'bar', b'http', b'baz.com']
request.site = Site(root)
request.isSecure = lambda: False
request.host = b''
step = hr.getChild(b'baz.com', request) # Consumes rest of path
self.assertIsInstance(step, Data)
request = DummyRequest([b'uri', b'test'])
step = root.getChild(b'uri', request)
self.assertIsInstance(step, NoResource)
def test_renderWithoutHost(self):
"""
L{NameVirtualHost.render} returns the result of rendering the
instance's C{default} if it is not C{None} and there is no I{Host}
header in the request.
"""
virtualHostResource = NameVirtualHost()
virtualHostResource.default = Data("correct result", "")
request = DummyRequest([""])
self.assertEqual(virtualHostResource.render(request), "correct result")
def test_renderWithoutHost(self):
"""
L{NameVirtualHost.render} returns the result of rendering the
instance's C{default} if it is not C{None} and there is no I{Host}
header in the request.
"""
virtualHostResource = NameVirtualHost()
virtualHostResource.default = Data("correct result", "")
request = DummyRequest([''])
self.assertEqual(virtualHostResource.render(request), "correct result")
def test_renderWithUnknownHost(self):
"""
L{NameVirtualHost.render} returns the result of rendering the
instance's C{default} if it is not C{None} and there is no host
matching the value of the I{Host} header in the request.
"""
virtualHostResource = NameVirtualHost()
virtualHostResource.default = Data(b"correct data", "")
request = DummyRequest([b''])
request.requestHeaders.addRawHeader(b'host', b'example.com')
d = _render(virtualHostResource, request)
def cbRendered(ignored):
self.assertEqual(b''.join(request.written), b"correct data")
d.addCallback(cbRendered)
return d
def test_renderWithUnknownHost(self):
"""
L{NameVirtualHost.render} returns the result of rendering the
instance's C{default} if it is not C{None} and there is no host
matching the value of the I{Host} header in the request.
"""
virtualHostResource = NameVirtualHost()
virtualHostResource.default = Data("correct data", "")
request = DummyRequest([''])
request.headers['host'] = 'example.com'
d = _render(virtualHostResource, request)
def cbRendered(ignored):
self.assertEqual(''.join(request.written), "correct data")
d.addCallback(cbRendered)
return d
def test_getChild(self):
"""
L{_HostResource.getChild} returns the proper I{Resource} for the vhost
embedded in the URL. Verify that returning the proper I{Resource}
required changing the I{Host} in the header.
"""
bazroot = Data(b"root data", "")
bazuri = Data(b"uri data", "")
baztest = Data(b"test data", "")
bazuri.putChild(b"test", baztest)
bazroot.putChild(b"uri", bazuri)
hr = _HostResource()
root = NameVirtualHost()
root.default = Data(b"default data", "")
root.addHost(b"baz.com", bazroot)
request = DummyRequest([b"uri", b"test"])
request.prepath = [b"bar", b"http", b"baz.com"]
request.site = Site(root)
request.isSecure = lambda: False
request.host = b""
step = hr.getChild(b"baz.com", request) # Consumes rest of path
self.assertIsInstance(step, Data)
request = DummyRequest([b"uri", b"test"])
step = root.getChild(b"uri", request)
self.assertIsInstance(step, NoResource)
def test_getChild(self):
"""
L{NameVirtualHost.getChild} returns correct I{Resource} based off
the header and modifies I{Request} to ensure proper prepath and
postpath are set.
"""
virtualHostResource = NameVirtualHost()
leafResource = Data(b"leaf data", "")
leafResource.isLeaf = True
normResource = Data(b"norm data", "")
virtualHostResource.addHost(b"leaf.example.org", leafResource)
virtualHostResource.addHost(b"norm.example.org", normResource)
request = DummyRequest([])
request.requestHeaders.addRawHeader(b"host", b"norm.example.org")
request.prepath = [b""]
self.assertIsInstance(virtualHostResource.getChild(b"", request),
NoResource)
self.assertEqual(request.prepath, [b""])
self.assertEqual(request.postpath, [])
request = DummyRequest([])
request.requestHeaders.addRawHeader(b"host", b"leaf.example.org")
request.prepath = [b""]
self.assertIsInstance(virtualHostResource.getChild(b"", request), Data)
self.assertEqual(request.prepath, [])
self.assertEqual(request.postpath, [b""])
def setupSite(self):
html.WebStatus.setupSite(self)
resource = self.site.resource
docdevPath = os.path.join(self.master.basedir, "doc-dev")
docdev = File(docdevPath)
File.contentTypes[".py,cover"] = "text/plain"
File.contentTypes[".svg"] = "image/svg+xml"
File.contentTypes[".json"] = "application/json"
# Historical name
resultsPath = os.path.join(self.master.basedir, "private_html")
results = File(resultsPath)
resource.putChild(b'results', results)
resource.putChild(b'metrics', PrometheusMetrics())
vhost = NameVirtualHost()
vhost.default = resource
vhost.addHost('doc-dev.clusterhq.com', docdev)
self.site.resource = vhost
def test_renderWithoutHostNoDefault(self):
"""
L{NameVirtualHost.render} returns a response with a status of I{NOT
FOUND} if the instance's C{default} is C{None} and there is no I{Host}
header in the request.
"""
virtualHostResource = NameVirtualHost()
request = DummyRequest([''])
d = _render(virtualHostResource, request)
def cbRendered(ignored):
self.assertEqual(request.responseCode, NOT_FOUND)
d.addCallback(cbRendered)
return d
def setupSite(self):
html.WebStatus.setupSite(self)
resource = self.site.resource
docdevPath = os.path.join(self.master.basedir, "doc-dev")
docdev = File(docdevPath)
File.contentTypes[".py,cover"] = "text/plain"
File.contentTypes[".svg"] = "image/svg+xml"
File.contentTypes[".json"] = "application/json"
# Historical name
resultsPath = os.path.join(self.master.basedir, "private_html")
results = File(resultsPath)
resource.putChild(b'results', results)
resource.putChild(b'metrics', PrometheusMetrics())
vhost = NameVirtualHost()
vhost.default = resource
vhost.addHost('doc-dev.clusterhq.com', docdev)
self.site.resource = vhost
def test_renderWithUnknownHostNoDefault(self):
"""
L{NameVirtualHost.render} returns a response with a status of I{NOT
FOUND} if the instance's C{default} is C{None} and there is no host
matching the value of the I{Host} header in the request.
"""
virtualHostResource = NameVirtualHost()
request = DummyRequest([''])
request.headers['host'] = 'example.com'
d = _render(virtualHostResource, request)
def cbRendered(ignored):
self.assertEqual(request.responseCode, NOT_FOUND)
d.addCallback(cbRendered)
return d
def setUp(self):
# prepare the authentication systems
self.userdb = cred.InMemoryUnicodeUsernamePasswordDatabase()
self.sitedb = cred.InMemoryUnicodeUsernamePasswordDatabase()
self.userrealm = TestUserRealm()
self.siterealm = TestSiteRealm()
self.userportal = portal.Portal(self.userrealm)
self.siteportal = portal.Portal(self.siterealm)
self.userportal.registerChecker(self.userdb)
self.siteportal.registerChecker(self.sitedb)
# register tokens
self.sitedb.addUser(
self.SITE_A_TOKEN,
self.SITE_A_SECRET,
)
self.siterealm.register_csauth_perm(
self.SITE_A_TOKEN,
TestWebAuthPermission(
self.SITE_A_NAME,
"http://{}/login".format(self.WEB_NAME),
full_username=True,
),
)
self.sitedb.addUser(
self.SITE_B_TOKEN,
self.SITE_B_SECRET,
)
self.siterealm.register_csauth_perm(
self.SITE_B_TOKEN,
TestWebAuthPermission(
self.SITE_B_NAME,
"http://{}/bpage".format(self.WEB_NAME),
full_username=False,
),
)
# register Users
self.userdb.addUser(
self.USER_A_NAME,
self.USER_A_PSWD,
)
self.userdb.addUser(
self.USER_B_NAME,
self.USER_B_PSWD,
)
# prepare the auth site
lr = BasicLoginResource()
authpage = AuthResource(
self.siteportal,
self.userportal,
lr,
url=u"http://{}/auth".format(self.AUTH_NAME),
)
arr = DebugResource("auth")
arr.putChild(b"auth", authpage)
arr.putChild(b"expire", SessionExpiringResource())
# prepare the web site
lrr = DebugResource("web")
# add the login page
loginpage = TestLoginResource(
u"http://{}/auth".format(self.AUTH_NAME),
self.SITE_A_TOKEN,
self.SITE_A_SECRET,
)
lrr.putChild(b"login", loginpage)
# add a login page with a different permission
bpage = TestLoginResource(
u"http://{}/auth".format(self.AUTH_NAME),
self.SITE_B_TOKEN,
self.SITE_B_SECRET,
)
lrr.putChild(b"bpage", bpage)
# add a resource with an invalid token/secret combination
invalidepage = TestLoginResource(
u"http://{}/auth".format(self.AUTH_NAME),
self.SITE_A_TOKEN,
self.SITE_B_SECRET, # <- site B secret
)
lrr.putChild(b"invalid", invalidepage)
# create and install treq stubs
supersite = NameVirtualHost()
supersite.addHost(self.AUTH_NAME.encode("ascii"), arr)
supersite.addHost(self.WEB_NAME.encode("ascii"), lrr)
supersite.default = DebugResource("default")
self.treq = StubTreq(supersite)
loginpage._set_request_dispatcher(self.treq)
bpage._set_request_dispatcher(self.treq)
invalidepage._set_request_dispatcher(self.treq)
class WebBoxVHost:
""" Class to manage and spawn Virtual Hosts, each with a different WebBox. """
def __init__(self, config):
self.config = config
self.host = config['management']['host'] # hostname of the management interface
self.port = config['management']['port'] # port to listen on
self.srcdir = config['management']['srcdir'] # source directory of templates
# TODO ssl port? or multiple ports?
self.vhost = NameVirtualHost()
# allow the config to be readable by .rpy files
registry = Registry()
registry.setComponent(WebBoxVHost, self)
root = FileNoDirectoryListings(self.srcdir, registry=registry)
# make .rpy python cgi
root.processors = {'.rpy': script.ResourceScript}
root.ignoreExt('.rpy')
# hook in the vhost controller urls to /start /stop etc.
root.putChild("start", WSGIResource(reactor, reactor.getThreadPool(), self.do_start))
root.putChild("stop", WSGIResource(reactor, reactor.getThreadPool(), self.do_stop))
class MgmtRealm(object):
implements(IRealm)
def requestAvatar(self, avatarId, mind, *interfaces):
if IResource in interfaces:
return (IResource, root, lambda: None)
logging.debug("Error in requestAvatar.")
realm = MgmtRealm()
portal = Portal(realm, [FilePasswordDB(config['htdigest'])]) #FIXME insecure passwords
credentialFactory = DigestCredentialFactory("md5", "webbox") # webbox is the "realm" of the htdigest
rootAuth = HTTPAuthSessionWrapper(portal, [credentialFactory])
self.vhost.addHost(self.host, rootAuth)
self.site = Site(self.vhost)
reactor.listenTCP(self.port, self.site)
# TODO ssl port?
self.url = "http://"+self.host+":"+str(self.port)
# load a web browser once the server has started
def on_start(arg):
logging.debug("Listening on: "+self.url)
try:
import webbrowser
webbrowser.open(server_url)
except Exception as e:
pass # no web browser? no problem.
def start_failed(arg):
logging.debug("Startup failed: "+str(arg))
# calls the web browser opening function above when the reactor has finished starting up
d = Deferred()
d.addCallbacks(on_start, start_failed)
reactor.callWhenRunning(d.callback, "Server startup")
logging.debug("Starting WebBox management interface on: "+self.url)
# add vhosts already configured
self.webboxes = {}
self.add_vhosts()
reactor.run()
def start_vhost(self, vhost):
""" Start the vhost with the definition 'vhost'. """
vhost['status'] = "running"
path = "webbox"
webbox = WebBox(vhost['config'])
resource = webbox.get_resource()
self.vhost.addHost(vhost['host'], resource)
self.webboxes[ vhost['host'] ] = webbox
def stop_vhost(self, vhost):
""" Stop the vhost with the defintion 'vhost'. """
vhost['status'] = "stopped"
self.vhost.removeHost(vhost['host'])
webbox = self.webboxes[ vhost['host'] ]
webbox.stop()
def add_vhosts(self):
""" Add the vhosts from the configuration. """
for vhost in self.config['vhosts']:
self.start_vhost(vhost)
def get_config(self):
for vhost in self.config['vhosts']:
vhost['url_scheme'] = self.config['url_scheme']
vhost['port'] = self.config['management']['port']
if vhost['status'] == "stopped":
vhost['modify'] = "Start"
vhost['modify_action'] = "start"
elif vhost['status'] == "running":
vhost['modify'] = "Stop"
vhost['modify_action'] = "stop"
return self.config
def do_start(self, environment, start_response):
host = environment['PATH_INFO'][1:] # remove leading slash
for vhost in self.config['vhosts']:
if host == vhost['host']:
self.start_vhost(vhost)
start_response("302 Found", [("Content-type", "text/html"), ("Location", "/")] )
return []
start_response("404 Not Found", [("Content-type", "text/html")] )
return ["That virtual host was not found."]
def do_stop(self, environment, start_response):
host = environment['PATH_INFO'][1:] # remove leading slash
for vhost in self.config['vhosts']:
if host == vhost['host']:
self.stop_vhost(vhost)
start_response("302 Found", [("Content-type", "text/html"), ("Location", "/")] )
return []
start_response("404 Not Found", [("Content-type", "text/html")] )
return ["That virtual host was not found."]
# First Fix the PYTHONPATH
import sys
from os.path import abspath, dirname
sys.path.append(dirname(abspath(__file__)))
# Now Perform the main imports
from twisted.application import internet, service
from twisted.web import server, resource
from twisted.web.static import File
from twisted.web.vhost import NameVirtualHost
from api.resources import APIRoot
from api.manager import ClientManager
from website.resources import SiteRoot
manager = ClientManager()
api = APIRoot(manager)
web = SiteRoot()
vhostManager = NameVirtualHost()
vhostManager.addHost('api.notiserv.org', api)
vhostManager.addHost('notiserv.org', web)
vhostManager.addHost('www.notiserv.org', web)
site = server.Site(vhostManager)
application = service.Application('notiserv')
siteServer = internet.TCPServer(9100, site)
siteServer.setServiceParent(application)
def __init__(self, config):
self.config = config
self.host = config['management']['host'] # hostname of the management interface
self.port = config['management']['port'] # port to listen on
self.srcdir = config['management']['srcdir'] # source directory of templates
# TODO ssl port? or multiple ports?
self.vhost = NameVirtualHost()
# allow the config to be readable by .rpy files
registry = Registry()
registry.setComponent(WebBoxVHost, self)
root = FileNoDirectoryListings(self.srcdir, registry=registry)
# make .rpy python cgi
root.processors = {'.rpy': script.ResourceScript}
root.ignoreExt('.rpy')
# hook in the vhost controller urls to /start /stop etc.
root.putChild("start", WSGIResource(reactor, reactor.getThreadPool(), self.do_start))
root.putChild("stop", WSGIResource(reactor, reactor.getThreadPool(), self.do_stop))
class MgmtRealm(object):
implements(IRealm)
def requestAvatar(self, avatarId, mind, *interfaces):
if IResource in interfaces:
return (IResource, root, lambda: None)
logging.debug("Error in requestAvatar.")
realm = MgmtRealm()
portal = Portal(realm, [FilePasswordDB(config['htdigest'])]) #FIXME insecure passwords
credentialFactory = DigestCredentialFactory("md5", "webbox") # webbox is the "realm" of the htdigest
rootAuth = HTTPAuthSessionWrapper(portal, [credentialFactory])
self.vhost.addHost(self.host, rootAuth)
self.site = Site(self.vhost)
reactor.listenTCP(self.port, self.site)
# TODO ssl port?
self.url = "http://"+self.host+":"+str(self.port)
# load a web browser once the server has started
def on_start(arg):
logging.debug("Listening on: "+self.url)
try:
import webbrowser
webbrowser.open(server_url)
except Exception as e:
pass # no web browser? no problem.
def start_failed(arg):
logging.debug("Startup failed: "+str(arg))
# calls the web browser opening function above when the reactor has finished starting up
d = Deferred()
d.addCallbacks(on_start, start_failed)
reactor.callWhenRunning(d.callback, "Server startup")
logging.debug("Starting WebBox management interface on: "+self.url)
# add vhosts already configured
self.webboxes = {}
self.add_vhosts()
reactor.run()
