134 lines
4.2 KiB
Python
134 lines
4.2 KiB
Python
import json
|
|
|
|
from twisted.internet.defer import inlineCallbacks, returnValue
|
|
|
|
from . import wormhole
|
|
from .tor_manager import get_tor
|
|
|
|
|
|
@inlineCallbacks
|
|
def receive(reactor,
|
|
appid,
|
|
relay_url,
|
|
code,
|
|
use_tor=False,
|
|
launch_tor=False,
|
|
tor_control_port=None,
|
|
on_code=None):
|
|
"""
|
|
This is a convenience API which returns a Deferred that callbacks
|
|
with a single chunk of data from another wormhole (and then closes
|
|
the wormhole). Under the hood, it's just using an instance
|
|
returned from :func:`wormhole.wormhole`. This is similar to the
|
|
`wormhole receive` command.
|
|
|
|
:param unicode appid: our application ID
|
|
|
|
:param unicode relay_url: the relay URL to use
|
|
|
|
:param unicode code: a pre-existing code to use, or None
|
|
|
|
:param bool use_tor: True if we should use Tor, False to not use it (None
|
|
for default)
|
|
|
|
:param on_code: if not None, this is called when we have a code (even if
|
|
you passed in one explicitly)
|
|
:type on_code: single-argument callable
|
|
"""
|
|
tor = None
|
|
if use_tor:
|
|
tor = yield get_tor(reactor, launch_tor, tor_control_port)
|
|
# For now, block everything until Tor has started. Soon: launch
|
|
# tor in parallel with everything else, make sure the Tor object
|
|
# can lazy-provide an endpoint, and overlap the startup process
|
|
# with the user handing off the wormhole code
|
|
|
|
wh = wormhole.create(appid, relay_url, reactor, tor=tor)
|
|
if code is None:
|
|
wh.allocate_code()
|
|
code = yield wh.get_code()
|
|
else:
|
|
wh.set_code(code)
|
|
# we'll call this no matter what, even if you passed in a code --
|
|
# maybe it should be only in the 'if' block above?
|
|
if on_code:
|
|
on_code(code)
|
|
data = yield wh.get_message()
|
|
data = json.loads(data.decode("utf-8"))
|
|
offer = data.get('offer', None)
|
|
if not offer:
|
|
raise Exception("Do not understand response: {}".format(data))
|
|
msg = None
|
|
if 'message' in offer:
|
|
msg = offer['message']
|
|
wh.send_message(
|
|
json.dumps({
|
|
"answer": {
|
|
"message_ack": "ok"
|
|
}
|
|
}).encode("utf-8"))
|
|
|
|
else:
|
|
raise Exception("Unknown offer type: {}".format(offer.keys()))
|
|
|
|
yield wh.close()
|
|
returnValue(msg)
|
|
|
|
|
|
@inlineCallbacks
|
|
def send(reactor,
|
|
appid,
|
|
relay_url,
|
|
data,
|
|
code,
|
|
use_tor=False,
|
|
launch_tor=False,
|
|
tor_control_port=None,
|
|
on_code=None):
|
|
"""
|
|
This is a convenience API which returns a Deferred that callbacks
|
|
after a single chunk of data has been sent to another
|
|
wormhole. Under the hood, it's just using an instance returned
|
|
from :func:`wormhole.wormhole`. This is similar to the `wormhole
|
|
send` command.
|
|
|
|
:param unicode appid: the application ID
|
|
|
|
:param unicode relay_url: the relay URL to use
|
|
|
|
:param unicode code: a pre-existing code to use, or None
|
|
|
|
:param bool use_tor: True if we should use Tor, False to not use it (None
|
|
for default)
|
|
|
|
:param on_code: if not None, this is called when we have a code (even if
|
|
you passed in one explicitly)
|
|
|
|
:type on_code: single-argument callable
|
|
"""
|
|
tor = None
|
|
if use_tor:
|
|
tor = yield get_tor(reactor, launch_tor, tor_control_port)
|
|
# For now, block everything until Tor has started. Soon: launch
|
|
# tor in parallel with everything else, make sure the Tor object
|
|
# can lazy-provide an endpoint, and overlap the startup process
|
|
# with the user handing off the wormhole code
|
|
wh = wormhole.create(appid, relay_url, reactor, tor=tor)
|
|
if code is None:
|
|
wh.allocate_code()
|
|
code = yield wh.get_code()
|
|
else:
|
|
wh.set_code(code)
|
|
if on_code:
|
|
on_code(code)
|
|
|
|
wh.send_message(json.dumps({"offer": {"message": data}}).encode("utf-8"))
|
|
data = yield wh.get_message()
|
|
data = json.loads(data.decode("utf-8"))
|
|
answer = data.get('answer', None)
|
|
yield wh.close()
|
|
if answer:
|
|
returnValue(None)
|
|
else:
|
|
raise Exception("Unknown answer: {}".format(data))
|