Beispiel #1
0
    async def receive_request(self, request: Request) -> Transaction:
        """
        Handle duplicates and store received messages.

        :type request: Request
        :param request: the incoming request
        :rtype : Transaction
        :return: the edited transaction
        """
        logger.debug("receive_request - {0}".format(request))
        try:
            host, port = request.source
        except TypeError or AttributeError:  # pragma: no cover
            raise errors.CoAPException("Request Source cannot be computed")
        key_mid = utils.str_append_hash(host, port, request.mid)
        key_token = utils.str_append_hash(host, port, request.token)

        transaction = self._transactions.get(key_mid, None)
        if transaction is not None:
            from_token = self._transactions_token.get(key_token, None)
            if from_token is None:
                logger.warning("Duplicated message with different Token")
                raise errors.ProtocolError(msg="Tokens does not match",
                                           mid=transaction.request.mid)
            transaction.request.duplicated = True
        else:
            request.timestamp = time.time()
            transaction = Transaction(request=request, timestamp=request.timestamp)
            self._transactions[key_mid] = transaction
            self._transactions_token[key_token] = transaction
        return transaction
Beispiel #2
0
    async def send_request(self, request: Request):
        """
        Create the transaction and fill it with the outgoing request.

        :type request: Request
        :param request: the request to send
        :rtype : Transaction
        :return: the created transaction
        """

        try:
            host, port = request.destination
        except TypeError or AttributeError:  # pragma: no cover
            raise errors.CoAPException("Request destination cannot be computed")

        request.timestamp = time.time()
        transaction = Transaction(request=request, timestamp=request.timestamp)
        if transaction.request.type is None:  # pragma: no cover
            raise errors.CoAPException("Request type is not set")

        if transaction.request.mid is None:
            transaction.request.mid = self.fetch_mid()

        key_mid = utils.str_append_hash(host, port, request.mid)
        self._transactions[key_mid] = transaction

        key_token = utils.str_append_hash(host, port, request.token)
        self._transactions_token[key_token] = transaction
        logger.debug("send_request - {0}".format(request))
        return transaction