def test_posted(self):
root = Resource()
collector = Collector()
root.putChild(b"foo", collector)
from twisted.internet import reactor
while True:
try:
port = reactor.listenTCP(0, Site(root))
except:
pass
else:
self.addCleanup(port.stopListening)
port_number = port.getHost().port
break
fluentd_url = URL(
scheme="http",
host="127.0.0.1",
port=port_number,
path=["foo"],
)
agent = Agent(reactor)
destination = FluentdDestination(agent, fluentd_url)
destination({"hello": "world"})
def check():
self.assertEquals(collector.collected,
[b'json={"hello": "world"}'])
return deferLater(reactor, 0.1, check)
def get_data_uri(bucket, sibling=None, more_params=None):
"""
Compute uri to data source as sibling to the current path.
Add "from" and "to" query parameters from bucket.
"""
more_params = more_params or {}
forward_parameters = [
u'from', u'to', u'exclude', u'include', u'pad', u'backfill',
u'interpolate'
]
request = bucket.request
# Honor X-Forwarded-Proto request header if behind SSL-terminating HTTP proxy
twisted_honor_reverse_proxy(request)
url = URL()
for param in forward_parameters:
if param in bucket.tdata:
url = url.add(unicode(param), unicode(bucket.tdata[param]))
for param, value in more_params.iteritems():
# Special rule: Don't add any of "pad" or "backfill", if "interpolate" is true
do_interpolate = 'interpolate' in bucket.tdata and asbool(
bucket.tdata.interpolate)
if do_interpolate and param in ['pad', 'backfill']:
continue
url = url.add(unicode(param), unicode(value))
data_uri = str(request.URLPath().sibling(sibling).click(url.asText()))
return data_uri
def setUp(self):
super(EndpointTests, self).setUp()
clock = Clock()
clock.rightNow = (datetime.now() -
datetime(1970, 1, 1)).total_seconds()
client = FakeClient(RSA_KEY_512, clock)
self.endpoint = AutoTLSEndpoint(
reactor=clock,
directory=URL(u'https://example.com/'),
client_creator=lambda reactor, directory: succeed(client),
cert_store=MemoryStore(),
cert_mapping={},
sub_endpoint=DummyEndpoint())
def test_fluentd_http(self):
"""
A ``fluentd_http:`` description causes logs to be sent to a Fluentd server's
http input plugin at the given URL.
"""
reactor = object()
self.assertThat(
_parse_destination_description("fluentd_http:http://foo/bar")(
reactor),
MatchesStructure(
agent=IsInstance(Agent),
fluentd_url=Equals(
URL(scheme=u"http", host=u"foo", path=[u"bar"]), ),
))
def test_start_responding(self, token):
"""
Calling ``start_responding`` makes an appropriate resource available.
"""
challenge = challenges.HTTP01(token=token)
response = challenge.response(RSA_KEY_512)
responder = HTTP01Responder()
challenge_resource = Resource()
challenge_resource.putChild(b'acme-challenge', responder.resource)
root = Resource()
root.putChild(b'.well-known', challenge_resource)
client = StubTreq(root)
encoded_token = challenge.encode('token')
challenge_url = URL(
host=u'example.com',
path=[u'.well-known', u'acme-challenge', encoded_token]).asText()
self.assertThat(client.get(challenge_url),
succeeded(MatchesStructure(code=Equals(404))))
responder.start_responding(u'example.com', challenge, response)
self.assertThat(
client.get(challenge_url),
succeeded(
MatchesAll(
MatchesStructure(code=Equals(200),
headers=AfterPreprocessing(
methodcaller('getRawHeaders',
b'content-type'),
Equals([b'text/plain']))),
AfterPreprocessing(
methodcaller('content'),
succeeded(
Equals(response.key_authorization.encode(
'utf-8')))))))
# Starting twice before stopping doesn't break things
responder.start_responding(u'example.com', challenge, response)
self.assertThat(client.get(challenge_url),
succeeded(MatchesStructure(code=Equals(200))))
responder.stop_responding(u'example.com', challenge, response)
self.assertThat(client.get(challenge_url),
succeeded(MatchesStructure(code=Equals(404))))
def render(self, request):
# request.args can include URL encoded bodies, so extract the
# query from request.uri
_, _, query = request.uri.partition(b'?')
# Assume HTTPS is served over 443
httpsURL = URL(
scheme=u'https',
# I'm sure ASCII will be fine.
host=request.getRequestHostname().decode('ascii'),
path=tuple(
segment.decode('ascii')
for segment in request.prepath + request.postpath),
)
httpsLocation = httpsURL.asText().encode('ascii')
if query:
httpsLocation += (b'?' + query)
return movedTo(request, httpsLocation)
def test_start_responding(self):
"""
Calling ``start_responding`` makes an appropriate resource available.
"""
token = b'BWYcfxzmOha7-7LoxziqPZIUr99BCz3BfbN9kzSFnrU'
challenge = challenges.HTTP01(token=token)
response = challenge.response(RSA_KEY_512)
responder = HTTP01Responder()
challenge_resource = Resource()
challenge_resource.putChild(b'acme-challenge', responder.resource)
root = Resource()
root.putChild(b'.well-known', challenge_resource)
client = StubTreq(root)
encoded_token = challenge.encode('token')
challenge_url = URL(
host=u'example.com',
path=[u'.well-known', u'acme-challenge', encoded_token]).asText()
# We got page not found while the challenge is not yet active.
result = yield client.get(challenge_url)
self.assertEqual(404, result.code)
# Once we enable the response.
responder.start_responding(u'example.com', challenge, response)
result = yield client.get(challenge_url)
self.assertEqual(200, result.code)
self.assertEqual(['text/plain'],
result.headers.getRawHeaders('content-type'))
result = yield result.content()
self.assertEqual(response.key_authorization.encode('utf-8'), result)
# Starting twice before stopping doesn't break things
responder.start_responding(u'example.com', challenge, response)
result = yield client.get(challenge_url)
self.assertEqual(200, result.code)
yield responder.stop_responding(u'example.com', challenge, response)
result = yield client.get(challenge_url)
self.assertEqual(404, result.code)
