def validate_ticket(self, ticket, request):
service_name = self.service_name
ticket_name = self.ticket_name
this_url = self.get_url(request)
p = urlparse.urlparse(this_url)
qs_map = urlparse.parse_qs(p.query)
if ticket_name in qs_map:
del qs_map[ticket_name]
param_str = urlencode(qs_map, doseq=True)
p = urlparse.ParseResult(*tuple(p[:4] + (param_str, ) + p[5:]))
service_url = urlparse.urlunparse(p)
params = {
service_name: service_url,
ticket_name: ticket,
}
param_str = urlencode(params, doseq=True)
p = urlparse.urlparse(self.cas_info['service_validate_url'])
p = urlparse.ParseResult(*tuple(p[:4] + (param_str, ) + p[5:]))
service_validate_url = urlparse.urlunparse(p)
self.log("Requesting service-validate URL => '{0}' ...".format(
service_validate_url))
http_client = HTTPClient(self.cas_agent)
d = http_client.get(service_validate_url)
d.addCallback(treq.content)
d.addCallback(self.parse_sv_results, service_url, ticket, request)
return d
def test_rate_syntax_error(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/rate'
params = {
'to': '06155423',
'username': self.u1.username,
'password': self.u1_password
}
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.get(url, params=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Asserts
self.assertEqual(lastErrorStatus, 400)
self.assertEqual(
lastResponse,
'"Failed running interception script, check log for details"')
self.assertEqual(_ic, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec + 1,
self.stats_http.get('interceptor_error_count'))
def __init__(self,
dockerAddr=None,
dockerPort=None,
dockerSocket=None,
path='',
reactor=reactor,
config=None):
"""
A docker proxy resource which knows how to connect to real Docker
daemon either via socket (dockerSocket specified) or address + port for
TCP connection (dockerAddr + dockerPort specified).
"""
if config is None:
# Try to get the configuration from the default place on the
# filesystem.
self.config = PluginConfiguration()
else:
self.config = config
self.config.read_and_parse()
self.parser = EndpointParser(self.config)
Resource.__init__(self)
self.host = dockerAddr
self.port = dockerPort
self.socket = dockerSocket
self.path = path
self.reactor = reactor
proxy.ReverseProxyResource.__init__(
self, dockerAddr, dockerPort, path,
reactor) # NB dockerAddr is not actually used
self.agent = Agent(reactor) # no connectionpool
self.client = HTTPClient(self.agent)
def handle_outbound_message(self, message):
# The transport does not make any attempt to
# interpret AfricasTalking responses
self.emit("consuming %s" % message)
message_id = message['message_id']
missing_fields = self.ensure_message_values(message,
['to_addr', 'content'])
if missing_fields:
returnValue(self.reject_message(message, missing_fields))
outbound_msg = {
'username': self.username,
'to': ','.join(message.payload['to_addr']),
'message': message.payload['content'].encode('utf-8'),
'bulkSMSMode': 1,
}
self.emit("outbound message {}".format(outbound_msg))
http_client = HTTPClient(self.agent_factory)
args = dict(url=self.outbound_url,
data=outbound_msg,
headers=self.headers,
allow_redirects=False)
response = yield http_client.post(**args)
validate = yield self.validate_outbound(response)
validate['message_id'] = message_id
yield self.outbound_status(**validate)
def test_failed_node_connection(self, folder_name, collective_dircap,
upload_dircap):
"""
If an HTTP request to the Tahoe-LAFS node fails, ``status`` returns a
``Deferred`` that fails with that failure.
"""
assume(collective_dircap != upload_dircap)
tempdir = FilePath(self.mktemp())
node_directory = tempdir.child(u"node")
node = self.useFixture(NodeDirectory(node_directory))
node.create_magic_folder(
folder_name,
collective_dircap,
upload_dircap,
tempdir.child(u"folder"),
60,
)
exception = Exception("Made up failure")
treq = HTTPClient(FailingAgent(Failure(exception)))
self.assertThat(
status(folder_name, node_directory, treq),
failed(AfterPreprocessing(
lambda f: f.value,
Equals(exception),
), ),
)
def main(reactor, *args):
agent = make_custom_agent(reactor)
http_client = HTTPClient(agent)
d = http_client.get('https://secure.example.net/area51',
auth=('admin', "you'll never guess!"))
d.addCallback(print_response)
return d
def run_balance_test(self,
user=None,
default_route=None,
side_effect=None):
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector(user, default_route,
side_effect)
# Set baseurl
params = {
'username': self.params['username'],
'password': self.params['password'],
}
baseurl = 'http://127.0.0.1:1401/balance'
# Send a balance check request
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.get(baseurl, params=params)
response_text = yield text_content(response)
response_code = response.code
# Wait 5 seconds before stopping SmppClientConnectors
yield waitFor(5)
yield self.stopSmppClientConnectors()
defer.returnValue((response_text, response_code))
def run_rate_test(self,
user=None,
content=None,
source_address=None,
destination_address=None,
default_route=None,
side_effect=None):
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector(user, default_route,
side_effect)
# Set content
if content is not None:
self.params['content'] = content
else:
del self.params['content']
if source_address is not None:
self.params['from'] = source_address
if destination_address is not None:
self.params['to'] = destination_address
baseurl = 'http://127.0.0.1:1401/rate'
# Send a MT
# We should receive a msg id
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.get(baseurl, params=self.params)
response_text = yield text_content(response)
response_code = response.code
# Wait 5 seconds before stopping SmppClientConnectors
yield waitFor(5)
yield self.stopSmppClientConnectors()
defer.returnValue((response_text, response_code))
def test_rate_interceptorpb_not_connected(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/rate'
params = {
'to': '06155423',
'username': self.u1.username,
'password': self.u1_password
}
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.get(url, params=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Asserts
self.assertEqual(lastErrorStatus, 503)
self.assertEqual(lastResponse, '"InterceptorPB not connected !"')
self.assertEqual(_ic, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec + 1,
self.stats_http.get('interceptor_error_count'))
def test_rate_success(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.update_message_sript)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/rate'
params = {
'to': '06155423',
'username': self.u1.username,
'password': self.u1_password
}
# We should receive an error since interceptorpb is not connected
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.get(url, params=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Asserts
self.assertEqual(lastErrorStatus, 200)
self.assertEqual(_ic + 1, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec, self.stats_http.get('interceptor_error_count'))
def status(options):
"""
``magic-folder status`` entry-point.
:param StatusOptions options: Values for configurable status parameters.
:return Deferred: A ``Deferred`` which fires with an exit status for the
process when the status operation has completed.
"""
nodedir = options.parent.node_directory
stdout, stderr = options.stdout, options.stderr
# Create a client without persistent connections to simplify testing.
# Connections will typically be to localhost anyway so there isn't
# much performance difference.
from twisted.internet import reactor
treq = HTTPClient(Agent(reactor))
name = options["name"].decode("utf-8")
try:
status_obj = yield _status(
name,
FilePath(nodedir),
treq,
)
except Exception as e:
print(e, file=stderr)
returnValue(1)
else:
print(_format_status(datetime.now(), status_obj), file=stdout)
returnValue(0)
def from_nurl(cls,
nurl: DecodedURL,
reactor,
persistent: bool = True) -> StorageClient:
"""
Create a ``StorageClient`` for the given NURL.
``persistent`` indicates whether to use persistent HTTP connections.
"""
assert nurl.fragment == "v=1"
assert nurl.scheme == "pb"
swissnum = nurl.path[0].encode("ascii")
certificate_hash = nurl.user.encode("ascii")
treq_client = HTTPClient(
Agent(
reactor,
_StorageClientHTTPSPolicy(expected_spki_hash=certificate_hash),
pool=HTTPConnectionPool(reactor, persistent=persistent),
))
https_url = DecodedURL().replace(scheme="https",
host=nurl.host,
port=nurl.port)
return cls(https_url, swissnum, treq_client)
def run_test(self, content, datacoding=None, port=1401):
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector()
# Set content
self.params['content'] = content
# Set datacoding
if datacoding is None and 'coding' in self.params:
del self.params['coding']
if datacoding is not None:
self.params['coding'] = datacoding
# Prepare baseurl
baseurl = 'http://127.0.0.1:%s/send' % port
# Send a MT
# We should receive a msg id
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.post(baseurl, data=self.params)
text = yield text_content(response)
msgStatus = text[:7]
# Wait 2 seconds before stopping SmppClientConnectors
exitDeferred = defer.Deferred()
reactor.callLater(2, exitDeferred.callback, None)
yield exitDeferred
yield self.stopSmppClientConnectors()
# Run tests
self.assertEqual(msgStatus, 'Success')
def __attrs_post_init__(self):
MultiService.__init__(self)
if self.tahoe_client is None:
self.tahoe_client = create_tahoe_client(
self.config.tahoe_client_url,
HTTPClient(Agent(self.reactor)),
)
self._listen_endpoint = serverFromString(
self.reactor,
self.config.api_endpoint,
)
web_service = magic_folder_web_service(
self._listen_endpoint,
self.config,
self,
self._get_auth_token,
self.tahoe_client,
self.status_service,
)
web_service.setServiceParent(self)
# We can create the services for all configured folders right now.
# They won't do anything until they are started which won't happen
# until this service is started.
self._create_magic_folder_services()
def createVerifyingHTTPClient(
reactor,
agent_kwds=None,
policy_factory=BrowserLikePolicyForHTTPS,
**kwds):
agent_kwds = normalizeDict_(agent_kwds)
agent_kwds['contextFactory'] = policy_factory()
return HTTPClient(Agent(reactor, **agent_kwds), **kwds)
def _client(*args, **kwargs):
agent = kwargs.get('agent')
if agent is None:
reactor = default_reactor(kwargs.get('reactor'))
pool = default_pool(reactor, kwargs.get('pool'),
kwargs.get('persistent'))
agent = Agent(reactor, pool=pool)
return HTTPClient(agent)
def http_put(self, url, data, callback=None):
connection_pool = self.config["pool"] if "pool" in self.config else None
HTTPClient(Agent(self.reactor, contextFactory=DoNotVerifySSLContextFactory())) \
.put(url, data, timeout=HTTP_TIMEOUT, pool=connection_pool).addCallbacks(
lambda response, url=url, callback=callback: self.http_response(response, url, callback),
errback=lambda error, url=url: anode.Log(logging.ERROR).log("Plugin", "error",
lambda: "[{}] error processing HTTP GET [{}] with [{}]".format(
self.name, url, error.getErrorMessage())))
def _default_client(jws_client, reactor, key, alg):
"""
Make a client if we didn't get one.
"""
if jws_client is None:
pool = HTTPConnectionPool(reactor)
agent = Agent(reactor, pool=pool)
jws_client = JWSClient(HTTPClient(agent=agent), key, alg)
return jws_client
def setUp(self):
"""
Construct a fake "Docker daemon" (one which does much less than the
actual Docker daemon) and a Proxy instance.
Pre- and post-hook API servers are provided by the individual tests.
"""
self.agent = Agent(reactor) # no connectionpool
self.client = HTTPClient(self.agent)
def _client(*args, **kwargs):
reactor = default_reactor(kwargs.get('reactor'))
pool = default_pool(reactor, kwargs.get('pool'), kwargs.get('persistent'))
if 'proxy' in kwargs.keys():
address, port = kwargs.get('proxy')
endpoint = TCP4ClientEndpoint(reactor, address, port)
agent = ProxyAgent(endpoint)
else:
agent = Agent(reactor, pool=pool)
return HTTPClient(agent)
def http_request_full(url,
data=None,
headers={},
method='POST',
timeout=None,
data_limit=None,
context_factory=None,
agent_class=None,
reactor=None):
"""
This is a drop in replacement for the original `http_request_full` method
but it has its internals completely replaced by treq. Treq supports SNI
and our implementation does not for some reason. Also, we do not want
to continue maintaining this because we're favouring treq everywhere
anyway.
"""
agent_class = agent_class or Agent
if reactor is None:
# The import replaces the local variable.
from twisted.internet import reactor
kwargs = {'pool': HTTPConnectionPool(reactor, persistent=False)}
if context_factory is not None:
kwargs['contextFactory'] = context_factory
agent = agent_class(reactor, **kwargs)
client = HTTPClient(agent)
def handle_response(response):
return SimplishReceiver(response, data_limit).deferred
d = client.request(method, url, headers=headers, data=data)
d.addCallback(handle_response)
if timeout is not None:
cancelling_on_timeout = [False]
def raise_timeout(reason):
if not cancelling_on_timeout[0] or reason.check(HttpTimeoutError):
return reason
return Failure(HttpTimeoutError("Timeout while connecting"))
def cancel_on_timeout():
cancelling_on_timeout[0] = True
d.cancel()
def cancel_timeout(r, delayed_call):
if delayed_call.active():
delayed_call.cancel()
return r
d.addErrback(raise_timeout)
delayed_call = reactor.callLater(timeout, cancel_on_timeout)
d.addCallback(cancel_timeout, delayed_call)
return d
def magic_folder_create(alias, nickname, name, node_directory, local_dir,
poll_interval, treq):
"""
Create a magic-folder with the specified ``name`` (or ``default``
if not specified) and optionally invite the client and join with
the specified ``nickname`` and the specified ``local_dir``.
:param unicode alias: The alias of the folder to which the invitation is
being generated.
:param unicode nickname: The nickname of the invitee.
:param unicode name: The name of the magic-folder.
:param unicode node_directory: The root of the Tahoe-LAFS node.
:param unicode local_dir: The directory on the filesystem that the user wants
to sync between different computers.
:param integer poll_interval: Periodic time interval after which the
client polls for updates.
:param HTTPClient treq: An ``HTTPClient`` or similar object to use to make
the queries.
:return Deferred[integer]: A status code of 0 for a successful execution. Otherwise
an appropriate exception is raised.
"""
# make sure we don't already have a magic-folder with this name before we create the alias
maybe_upgrade_magic_folders(node_directory)
folders = load_magic_folders(node_directory)
if name in folders:
raise Exception("Already have a magic-folder named '{}'".format(name))
rc = yield tahoe_create_alias(node_directory, alias, treq)
if rc != 0:
raise Exception("Failed to create alias")
if nickname is not None:
# inviting itself as a client
from twisted.internet import reactor
treq = HTTPClient(Agent(reactor))
try:
invite_code = yield _invite(node_directory, alias, nickname, treq)
except Exception as e:
raise Exception("Failed to invite after create: {}".format(str(e)))
rc = _join(invite_code, node_directory, local_dir, name, poll_interval)
if rc != 0:
raise Exception("Failed to join after create")
returnValue(0)
def _client(kwargs):
agent = kwargs.pop("agent", None)
pool = kwargs.pop("pool", None)
persistent = kwargs.pop("persistent", None)
if agent is None:
# "reactor" isn't removed from kwargs because it must also be passed
# down for use in the timeout logic.
reactor = default_reactor(kwargs.get("reactor"))
pool = default_pool(reactor, pool, persistent)
agent = Agent(reactor, pool=pool)
return HTTPClient(agent)
def setUp(self):
self.agent = mock.Mock(Agent)
self.client = HTTPClient(self.agent)
self.fbp_patcher = mock.patch('treq.client.FileBodyProducer')
self.FileBodyProducer = self.fbp_patcher.start()
self.addCleanup(self.fbp_patcher.stop)
self.mbp_patcher = mock.patch('treq.multipart.MultiPartProducer')
self.MultiPartProducer = self.mbp_patcher.start()
self.addCleanup(self.mbp_patcher.stop)
def invite(options):
from twisted.internet import reactor
treq = HTTPClient(Agent(reactor))
invite_code = yield magic_folder_invite(
options.parent.config,
options['name'],
options.nickname,
treq,
)
print(u"{}".format(invite_code), file=options.stdout)
def run_send_test(self,
user=None,
content='anycontent',
hex_content=None,
dlr_level=None,
dlr_method=None,
source_address=None,
priority=None,
schedule_delivery_time=None,
validity_period=None,
destination_address=None,
default_route=None,
side_effect=None):
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector(user, default_route,
side_effect)
# Set params
if content is None:
del (self.params['content'])
else:
self.params['content'] = content
if hex_content is not None:
self.params['hex-content'] = hex_content
if dlr_level is not None:
self.params['dlr-level'] = dlr_level
if dlr_method is not None:
self.params['dlr-method'] = dlr_method
if source_address is not None:
self.params['from'] = source_address
if priority is not None:
self.params['priority'] = priority
if schedule_delivery_time is not None:
self.params['sdt'] = schedule_delivery_time
if validity_period is not None:
self.params['validity-period'] = validity_period
if destination_address is not None:
self.params['to'] = destination_address
baseurl = 'http://127.0.0.1:1401/send'
# Send a MT
# We should receive a msg id
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.post(baseurl, data=self.params)
response_text = yield text_content(response)
response_code = response.code
# Wait 5 seconds before stopping SmppClientConnectors
yield waitFor(5)
yield self.stopSmppClientConnectors()
defer.returnValue((response_text, response_code))
def __init__(self,
agent,
key,
alg,
user_agent=u'txacme/{}'.format(__version__).encode('ascii')):
self._treq = HTTPClient(agent=agent)
self._agent = agent
self._current_request = None
self._key = key
self._alg = alg
self._user_agent = user_agent
self._nonces = set()
def create_txacme_client_creator(reactor, url, key, alg=jose.RS256):
"""
Create a creator for txacme clients to provide to the txacme service. See
``txacme.client.Client.from_url()``. We create the underlying JWSClient
with a non-persistent pool to avoid
https://github.com/mithrandi/txacme/issues/86.
:return: a callable that returns a deffered that returns the client
"""
# Creating an Agent without specifying a pool gives us the default pool
# which is non-persistent.
jws_client = JWSClient(HTTPClient(agent=Agent(reactor)), key, alg)
return partial(txacme_Client.from_url, reactor, url, key, alg, jws_client)
def proxy_treq(https_proxy=None):
# Setup of agent
if https_proxy:
host = https_proxy['host']
port = https_proxy['port']
proxy = HTTPProxyConnector(proxy_host=host,
proxy_port=int(port))
agent = Agent(reactor=proxy)
else:
agent = Agent(reactor)
return HTTPClient(agent)
def create_http_client(reactor, api_client_endpoint_str):
"""
:param reactor: Twisted reactor
:param unicode api_client_endpoint_str: a Twisted client endpoint-string
:returns: a Treq HTTPClient which will do all requests to the
indicated endpoint
"""
return HTTPClient(agent=Agent.usingEndpointFactory(
reactor,
_StaticEndpointFactory(
clientFromString(reactor, api_client_endpoint_str), ),
), )
