From 501af4b4ec8c7e8f4164ba4390885f6b58172211 Mon Sep 17 00:00:00 2001 From: Brian Warner Date: Thu, 12 May 2016 15:52:22 -0700 Subject: [PATCH] rename send_data/get_data to just send/get --- src/wormhole/cli/cmd_receive.py | 8 +-- src/wormhole/cli/cmd_send.py | 6 +-- src/wormhole/test/test_twisted.py | 84 ++++++++++++++---------------- src/wormhole/twisted/transcribe.py | 14 ++--- 4 files changed, 52 insertions(+), 60 deletions(-) diff --git a/src/wormhole/cli/cmd_receive.py b/src/wormhole/cli/cmd_receive.py index 0de21cd..b39e3c6 100644 --- a/src/wormhole/cli/cmd_receive.py +++ b/src/wormhole/cli/cmd_receive.py @@ -90,7 +90,7 @@ class TwistedReceiver: raise RespondError("unknown offer type") except RespondError as r: data = json.dumps({"error": r.response}).encode("utf-8") - yield w.send_data(data) + yield w.send(data) raise TransferError(r.response) returnValue(None) @@ -113,7 +113,7 @@ class TwistedReceiver: @inlineCallbacks def get_data(self, w): # this may raise WrongPasswordError - them_bytes = yield w.get_data() + them_bytes = yield w.get() them_d = json.loads(them_bytes.decode("utf-8")) if "error" in them_d: raise TransferError(them_d["error"]) @@ -124,7 +124,7 @@ class TwistedReceiver: # we're receiving a text message self.msg(them_d["message"]) data = json.dumps({"message_ack": "ok"}).encode("utf-8") - yield w.send_data(data, wait=True) + yield w.send(data, wait=True) def handle_file(self, them_d): file_data = them_d["file"] @@ -199,7 +199,7 @@ class TwistedReceiver: "relay_connection_hints": relay_hints, }, }).encode("utf-8") - yield w.send_data(data) + yield w.send(data) # now receive the rest of the owl tdata = them_d["transit"] diff --git a/src/wormhole/cli/cmd_send.py b/src/wormhole/cli/cmd_send.py index 9904c58..cdc5cec 100644 --- a/src/wormhole/cli/cmd_send.py +++ b/src/wormhole/cli/cmd_send.py @@ -94,17 +94,17 @@ def _send(reactor, w, args, phase1, fd_to_send, tor_manager): if ok.lower() == "no": err = "sender rejected verification check, abandoned transfer" reject_data = json.dumps({"error": err}).encode("utf-8") - yield w.send_data(reject_data) + yield w.send(reject_data) raise TransferError(err) if fd_to_send is not None: transit_key = w.derive_key(APPID+"/transit-key") transit_sender.set_transit_key(transit_key) my_phase1_bytes = json.dumps(phase1).encode("utf-8") - yield w.send_data(my_phase1_bytes) + yield w.send(my_phase1_bytes) # this may raise WrongPasswordError - them_phase1_bytes = yield w.get_data() + them_phase1_bytes = yield w.get() them_phase1 = json.loads(them_phase1_bytes.decode("utf-8")) diff --git a/src/wormhole/test/test_twisted.py b/src/wormhole/test/test_twisted.py index 1c186da..2d4941a 100644 --- a/src/wormhole/test/test_twisted.py +++ b/src/wormhole/test/test_twisted.py @@ -18,8 +18,8 @@ class Basic(ServerBase, unittest.TestCase): w2 = Wormhole(APPID, self.relayurl) code = yield w1.get_code() w2.set_code(code) - yield self.doBoth(w1.send_data(b"data1"), w2.send_data(b"data2")) - dl = yield self.doBoth(w1.get_data(), w2.get_data()) + yield self.doBoth(w1.send(b"data1"), w2.send(b"data2")) + dl = yield self.doBoth(w1.get(), w2.get()) (dataX, dataY) = dl self.assertEqual(dataX, b"data2") self.assertEqual(dataY, b"data1") @@ -34,8 +34,8 @@ class Basic(ServerBase, unittest.TestCase): w2 = Wormhole(APPID, self.relayurl) code = yield w1.get_code() w2.set_code(code) - yield self.doBoth(w1.send_data(b"data"), w2.send_data(b"data")) - dl = yield self.doBoth(w1.get_data(), w2.get_data()) + yield self.doBoth(w1.send(b"data"), w2.send(b"data")) + dl = yield self.doBoth(w1.get(), w2.get()) (dataX, dataY) = dl self.assertEqual(dataX, b"data") self.assertEqual(dataY, b"data") @@ -47,10 +47,10 @@ class Basic(ServerBase, unittest.TestCase): w2 = Wormhole(APPID, self.relayurl) code = yield w1.get_code() w2.set_code(code) - res = yield self.doBoth(w1.send_data(b"data1"), w2.get_data()) + res = yield self.doBoth(w1.send(b"data1"), w2.get()) (_, dataY) = res self.assertEqual(dataY, b"data1") - dl = yield self.doBoth(w1.get_data(), w2.send_data(b"data2")) + dl = yield self.doBoth(w1.get(), w2.send(b"data2")) (dataX, _) = dl self.assertEqual(dataX, b"data2") yield self.doBoth(w1.close(), w2.close()) @@ -61,8 +61,8 @@ class Basic(ServerBase, unittest.TestCase): w2 = Wormhole(APPID, self.relayurl) w1.set_code(u"123-purple-elephant") w2.set_code(u"123-purple-elephant") - yield self.doBoth(w1.send_data(b"data1"), w2.send_data(b"data2")) - dl = yield self.doBoth(w1.get_data(), w2.get_data()) + yield self.doBoth(w1.send(b"data1"), w2.send(b"data2")) + dl = yield self.doBoth(w1.get(), w2.get()) (dataX, dataY) = dl self.assertEqual(dataX, b"data2") self.assertEqual(dataY, b"data1") @@ -75,17 +75,13 @@ class Basic(ServerBase, unittest.TestCase): w2 = Wormhole(APPID, self.relayurl) w1.set_code(u"123-purple-elephant") w2.set_code(u"123-purple-elephant") - yield self.doBoth(w1.send_data(b"data1", u"p1"), - w2.send_data(b"data2", u"p1")) - yield self.doBoth(w1.send_data(b"data3", u"p2"), - w2.send_data(b"data4", u"p2")) - dl = yield self.doBoth(w1.get_data(u"p2"), - w2.get_data(u"p1")) + yield self.doBoth(w1.send(b"data1", u"p1"), w2.send(b"data2", u"p1")) + yield self.doBoth(w1.send(b"data3", u"p2"), w2.send(b"data4", u"p2")) + dl = yield self.doBoth(w1.get(u"p2"), w2.get(u"p1")) (dataX, dataY) = dl self.assertEqual(dataX, b"data4") self.assertEqual(dataY, b"data1") - dl = yield self.doBoth(w1.get_data(u"p1"), - w2.get_data(u"p2")) + dl = yield self.doBoth(w1.get(u"p1"), w2.get(u"p2")) (dataX, dataY) = dl self.assertEqual(dataX, b"data2") self.assertEqual(dataY, b"data3") @@ -100,21 +96,21 @@ class Basic(ServerBase, unittest.TestCase): # w2 can't throw WrongPasswordError until it sees a CONFIRM message, # and w1 won't send CONFIRM until it sees a PAKE message, which w2 - # won't send until we call get_data. So we need both sides to be + # won't send until we call get. So we need both sides to be # running at the same time for this test. - d1 = w1.send_data(b"data1") + d1 = w1.send(b"data1") # at this point, w1 should be waiting for w2.PAKE - yield self.assertFailure(w2.get_data(), WrongPasswordError) + yield self.assertFailure(w2.get(), WrongPasswordError) # * w2 will send w2.PAKE, wait for (and get) w1.PAKE, compute a key, # send w2.CONFIRM, then wait for w1.DATA. # * w1 will get w2.PAKE, compute a key, send w1.CONFIRM. # * w1 might also get w2.CONFIRM, and may notice the error before it # sends w1.CONFIRM, in which case the wait=True will signal an - # error inside _get_master_key() (inside send_data), and d1 will + # error inside _get_master_key() (inside send), and d1 will # errback. # * but w1 might not see w2.CONFIRM yet, in which case it won't - # errback until we do w1.get_data() + # errback until we do w1.get() # * w2 gets w1.CONFIRM, notices the error, records it. # * w2 (waiting for w1.DATA) wakes up, sees the error, throws # * meanwhile w1 finishes sending its data. w2.CONFIRM may or may not @@ -124,20 +120,20 @@ class Basic(ServerBase, unittest.TestCase): except WrongPasswordError: pass - # When we ask w1 to get_data(), one of two things might happen: + # When we ask w1 to get(), one of two things might happen: # * if w2.CONFIRM arrived already, it will have recorded the error. - # When w1.get_data() sleeps (waiting for w2.DATA), we'll notice the + # When w1.get() sleeps (waiting for w2.DATA), we'll notice the # error before sleeping, and throw WrongPasswordError # * if w2.CONFIRM hasn't arrived yet, we'll sleep. When w2.CONFIRM # arrives, we notice and record the error, and wake up, and throw - # Note that we didn't do w2.send_data(), so we're hoping that w1 will + # Note that we didn't do w2.send(), so we're hoping that w1 will # have enough information to detect the error before it sleeps # (waiting for w2.DATA). Checking for the error both before sleeping # and after waking up makes this happen. # so now w1 should have enough information to throw too - yield self.assertFailure(w1.get_data(), WrongPasswordError) + yield self.assertFailure(w1.get(), WrongPasswordError) # both sides are closed automatically upon error, but it's still # legal to call .close(), and should be idempotent @@ -153,9 +149,9 @@ class Basic(ServerBase, unittest.TestCase): code = yield w1.get_code() w2.set_code(code) - dl = yield self.doBoth(w1.send_data(b"data1"), w2.get_data()) + dl = yield self.doBoth(w1.send(b"data1"), w2.get()) self.assertEqual(dl[1], b"data1") - dl = yield self.doBoth(w1.get_data(), w2.send_data(b"data2")) + dl = yield self.doBoth(w1.get(), w2.send(b"data2")) self.assertEqual(dl[0], b"data2") yield self.doBoth(w1.close(), w2.close()) @@ -169,8 +165,8 @@ class Basic(ServerBase, unittest.TestCase): v1, v2 = res self.failUnlessEqual(type(v1), type(b"")) self.failUnlessEqual(v1, v2) - yield self.doBoth(w1.send_data(b"data1"), w2.send_data(b"data2")) - dl = yield self.doBoth(w1.get_data(), w2.get_data()) + yield self.doBoth(w1.send(b"data1"), w2.send(b"data2")) + dl = yield self.doBoth(w1.get(), w2.get()) (dataX, dataY) = dl self.assertEqual(dataX, b"data2") self.assertEqual(dataY, b"data1") @@ -180,8 +176,8 @@ class Basic(ServerBase, unittest.TestCase): def test_errors(self): w1 = Wormhole(APPID, self.relayurl) yield self.assertFailure(w1.get_verifier(), UsageError) - yield self.assertFailure(w1.send_data(b"data"), UsageError) - yield self.assertFailure(w1.get_data(), UsageError) + yield self.assertFailure(w1.send(b"data"), UsageError) + yield self.assertFailure(w1.get(), UsageError) w1.set_code(u"123-purple-elephant") yield self.assertRaises(UsageError, w1.set_code, u"123-nope") yield self.assertFailure(w1.get_code(), UsageError) @@ -198,22 +194,20 @@ class Basic(ServerBase, unittest.TestCase): w2.set_code(u"123-purple-elephant") # we must let them establish a key before we can send data yield self.doBoth(w1.get_verifier(), w2.get_verifier()) - yield w1.send_data(b"data1", phase=u"1") + yield w1.send(b"data1", phase=u"1") # underscore-prefixed phases are reserved - yield self.assertFailure(w1.send_data(b"data1", phase=u"_1"), - UsageError) - yield self.assertFailure(w1.get_data(phase=u"_1"), UsageError) + yield self.assertFailure(w1.send(b"data1", phase=u"_1"), UsageError) + yield self.assertFailure(w1.get(phase=u"_1"), UsageError) # you can't send twice to the same phase - yield self.assertFailure(w1.send_data(b"data1", phase=u"1"), - UsageError) + yield self.assertFailure(w1.send(b"data1", phase=u"1"), UsageError) # but you can send to a different one - yield w1.send_data(b"data2", phase=u"2") - res = yield w2.get_data(phase=u"1") + yield w1.send(b"data2", phase=u"2") + res = yield w2.get(phase=u"1") self.failUnlessEqual(res, b"data1") # and you can't read twice from the same phase - yield self.assertFailure(w2.get_data(phase=u"1"), UsageError) + yield self.assertFailure(w2.get(phase=u"1"), UsageError) # but you can read from a different one - res = yield w2.get_data(phase=u"2") + res = yield w2.get(phase=u"2") self.failUnlessEqual(res, b"data2") yield self.doBoth(w1.close(), w2.close()) @@ -232,12 +226,10 @@ class Basic(ServerBase, unittest.TestCase): self.assertEqual(type(unpacked), dict) self.new_w1 = Wormhole.from_serialized(s) - yield self.doBoth(self.new_w1.send_data(b"data1"), - w2.send_data(b"data2")) - dl = yield self.doBoth(self.new_w1.get_data(), w2.get_data()) + yield self.doBoth(self.new_w1.send(b"data1"), w2.send(b"data2")) + dl = yield self.doBoth(self.new_w1.get(), w2.get()) (dataX, dataY) = dl self.assertEqual((dataX, dataY), (b"data2", b"data1")) self.assertRaises(UsageError, w2.serialize) # too late - yield gatherResults([w1.close(), w2.close(), self.new_w1.close()], - True) + yield gatherResults([w1.close(), w2.close(), self.new_w1.close()], True) diff --git a/src/wormhole/twisted/transcribe.py b/src/wormhole/twisted/transcribe.py index 199fa50..63f3e6b 100644 --- a/src/wormhole/twisted/transcribe.py +++ b/src/wormhole/twisted/transcribe.py @@ -332,7 +332,7 @@ class Wormhole: def serialize(self): # I can only be serialized after get_code/set_code and before - # get_verifier/get_data + # get_verifier/get if self._code is None: raise UsageError if self._key is not None: raise UsageError if self._sent_phases: raise UsageError @@ -448,7 +448,7 @@ class Wormhole: def derive_key(self, purpose, length=SecretBox.KEY_SIZE): if not isinstance(purpose, type(u"")): raise TypeError(type(purpose)) if self._key is None: - # call after get_verifier() or get_data() + # call after get_verifier() or get() raise UsageError return HKDF(self._key, length, CTXinfo=to_bytes(purpose)) @@ -469,17 +469,17 @@ class Wormhole: return data @inlineCallbacks - def send_data(self, outbound_data, phase=u"data", wait=False): + def send(self, outbound_data, phase=u"data", wait=False): if not isinstance(outbound_data, type(b"")): raise TypeError(type(outbound_data)) if not isinstance(phase, type(u"")): raise TypeError(type(phase)) if self._closed: raise UsageError if self._code is None: - raise UsageError("You must set_code() before send_data()") + raise UsageError("You must set_code() before send()") if phase.startswith(u"_"): raise UsageError # reserved for internals if phase in self._sent_phases: raise UsageError # only call this once self._sent_phases.add(phase) - with self._timing.add("API send_data", phase=phase, wait=wait): + with self._timing.add("API send", phase=phase, wait=wait): # Without predefined roles, we can't derive predictably unique # keys for each side, so we use the same key for both. We use # random nonces to keep the messages distinct, and we @@ -490,14 +490,14 @@ class Wormhole: yield self._msg_send(phase, outbound_encrypted, wait) @inlineCallbacks - def get_data(self, phase=u"data"): + def get(self, phase=u"data"): if not isinstance(phase, type(u"")): raise TypeError(type(phase)) if self._closed: raise UsageError if self._code is None: raise UsageError if phase.startswith(u"_"): raise UsageError # reserved for internals if phase in self._got_phases: raise UsageError # only call this once self._got_phases.add(phase) - with self._timing.add("API get_data", phase=phase): + with self._timing.add("API get", phase=phase): yield self._get_master_key() body = yield self._msg_get(phase) # we can wait a long time here try: