fixes the object has no attribute '_handshake_error' error (#4331)

* fixes the `object has no attribute '_handshake_error'` error
* fix the logging message

closes #4261

golem/task/server/resources.py

@@ -282,7 +282,18 @@ def _share_handshake_nonce(self, key_id):
                                                   self.NONCE_TASK,
                                                   client_options=options,
                                                   async_=True)
+
+        def handshake_error(exc):
+            session = self.sessions.get(key_id)
+            if not session:
+                logger.info(
+                    'Session not found. node=%s',
+                    common.short_node_id(key_id),
+                )
+                return
+            session._handshake_error(key_id, exc)  # noqa pylint:disable=protected-access
+
         deferred.addCallbacks(
             lambda res: self._nonce_shared(key_id, res, options),
-            lambda exc: self._handshake_error(key_id, exc)
+            handshake_error,
         )

tests/golem/task/server/test_resources.py

@@ -1,12 +1,17 @@
 # pylint: disable=protected-access
 from unittest import mock
 
+from twisted.internet.defer import Deferred
+
 from golem_messages import cryptography
 from golem_messages import utils as msg_utils
+from golem_messages.factories.datastructures import p2p as dt_p2p_factory
 from golem_messages.factories import helpers as msg_helpers
 
+from golem.network.p2p.local_node import LocalNode
 from golem.task.taskkeeper import TaskHeaderKeeper
 from golem.task.server.resources import TaskResourcesMixin
+from golem.task.tasksession import TaskSession
 from golem.testutils import TestWithClient
 
 
@@ -29,15 +34,14 @@ def test_request_resource(self):
 @mock.patch(
     "golem.task.server.resources.TaskResourcesMixin._start_handshake_timer",
 )
-@mock.patch(
-    "golem.task.server.resources.TaskResourcesMixin._share_handshake_nonce",
-)
 class TestResourceHandhsake(TestWithClient):
     def setUp(self):
         super().setUp()
         self.server = TaskResourcesMixin()
+        self.server.sessions = {}
         self.server.resource_handshakes = {}
         self.server.client = self.client
+        self.server.node = LocalNode(**dt_p2p_factory.Node().to_dict())
         self.server.resource_manager.storage.get_dir.return_value = self.tempdir
         self.ecc = cryptography.ECCx(None)
         self.task_id = msg_helpers.fake_golem_uuid(self.public_key)
@@ -50,6 +54,10 @@ def public_key(self):
     def key_id(self):
         return self.public_key[2:]
 
+    @mock.patch(
+        "golem.task.server.resources."
+        "TaskResourcesMixin._share_handshake_nonce",
+    )
     def test_start_handshake(self, mock_share, mock_timer, *_):
         self.server.start_handshake(
             key_id=self.key_id,
@@ -62,6 +70,57 @@ def test_start_handshake(self, mock_share, mock_timer, *_):
         mock_timer.assert_called_once_with(self.key_id)
         mock_share.assert_called_once_with(self.key_id)
 
+    @mock.patch('golem.task.server.resources.msg_queue.put')
+    def test_start_handshake_nonce_callback(self, mock_queue, *_):
+        deferred = Deferred()
+        self.server.resource_manager.add_file.return_value = deferred
+        self.server.start_handshake(
+            key_id=self.key_id,
+            task_id=self.task_id,
+        )
+
+        exception = False
+
+        def exception_on_error(error):
+            nonlocal exception
+            exception = error
+
+        deferred.addErrback(exception_on_error)
+        deferred.callback(('result', None))
+
+        if exception:
+            raise Exception(exception)
+
+        mock_queue.assert_called_once_with(node_id=self.key_id, msg=mock.ANY)
+
+    def test_start_handshake_nonce_errback(self, *_):
+        deferred = Deferred()
+        self.server.resource_manager.add_file.return_value = deferred
+        ts = mock.Mock(TaskSession)
+        self.server.sessions[self.key_id] = ts
+        self.server.start_handshake(
+            key_id=self.key_id,
+            task_id=self.task_id,
+        )
+
+        exception = False
+
+        def exception_on_error(error):
+            nonlocal exception
+            exception = error
+
+        deferred.addErrback(exception_on_error)
+        deferred.errback(('result', None))
+
+        if exception:
+            raise Exception(exception)
+
+        ts._handshake_error.assert_called_once_with(self.key_id, mock.ANY)
+
+    @mock.patch(
+        "golem.task.server.resources."
+        "TaskResourcesMixin._share_handshake_nonce",
+    )
     @mock.patch(
         "golem.resource.resourcehandshake.ResourceHandshake.start",
         side_effect=RuntimeError("Intentional error"),