Exemplo n.º 1
0
    def test_encode_produce_request(self):
        requests = [
            ProduceRequest("topic1", 0, [
                create_message((-1, b"a")),
                create_message((-1, b"b")),
            ]),
            ProduceRequest(u"topic2", 1, [
                create_message((-1, b"c")),
            ]),
        ]

        msg_a_binary = KafkaCodec._encode_message(create_message((-1, b"a")))
        msg_b_binary = KafkaCodec._encode_message(create_message((-1, b"b")))
        msg_c_binary = KafkaCodec._encode_message(create_message((-1, b"c")))

        header = b"".join([
            struct.pack('>h', 0),  # Msg Header, Message type = Produce
            struct.pack('>h', 1),  # Msg Header, API version
            struct.pack('>i', 2),  # Msg Header, Correlation ID
            struct.pack('>h7s', 7, b"client1"),  # Msg Header, The client ID
            struct.pack('>h', 2),  # Num acks required
            struct.pack('>i', 100),  # Request Timeout
            struct.pack('>i', 2),  # The number of requests
        ])

        total_len = len(msg_a_binary) + len(msg_b_binary)
        topic1 = b"".join([
            struct.pack('>h6s', 6, b'topic1'),  # The topic1
            struct.pack('>i', 1),  # One message set
            struct.pack('>i', 0),  # Partition 0
            struct.pack('>i', total_len + 24),  # Size of message set
            struct.pack('>q', 0),  # No offset specified
            struct.pack('>i', len(msg_a_binary)),  # Length of message
            msg_a_binary,  # Actual message
            struct.pack('>q', 0),  # No offset specified
            struct.pack('>i', len(msg_b_binary)),  # Length of message
            msg_b_binary,  # Actual message
        ])

        topic2 = b"".join([
            struct.pack('>h6s', 6, b'topic2'),  # The topic1
            struct.pack('>i', 1),  # One message set
            struct.pack('>i', 1),  # Partition 1
            struct.pack('>i',
                        len(msg_c_binary) + 12),  # Size of message set
            struct.pack('>q', 0),  # No offset specified
            struct.pack('>i', len(msg_c_binary)),  # Length of message
            msg_c_binary,  # Actual message
        ])

        expected1 = b"".join([header, topic1, topic2])
        expected2 = b"".join([header, topic2, topic1])

        encoded = KafkaCodec.encode_produce_request(b"client1", 2, requests, 2,
                                                    100)

        self.assertIn(encoded, [expected1, expected2])
Exemplo n.º 2
0
    def test_encode_produce_request(self):
        requests = [
            ProduceRequest("topic1", 0, [
                create_message(b"a"),
                create_message(b"b"),
            ]),
            ProduceRequest(u"topic2", 1, [
                create_message(b"c"),
            ]),
        ]

        msg_a_binary = KafkaCodec._encode_message(create_message(b"a"))
        msg_b_binary = KafkaCodec._encode_message(create_message(b"b"))
        msg_c_binary = KafkaCodec._encode_message(create_message(b"c"))

        header = b"".join([
            struct.pack('>h', 0),        # Msg Header, Message type = Produce
            struct.pack('>h', 0),        # Msg Header, API version
            struct.pack('>i', 2),        # Msg Header, Correlation ID
            struct.pack('>h7s', 7, b"client1"),  # Msg Header, The client ID
            struct.pack('>h', 2),        # Num acks required
            struct.pack('>i', 100),      # Request Timeout
            struct.pack('>i', 2),        # The number of requests
        ])

        total_len = len(msg_a_binary) + len(msg_b_binary)
        topic1 = b"".join([
            struct.pack('>h6s', 6, b'topic1'),         # The topic1
            struct.pack('>i', 1),                      # One message set
            struct.pack('>i', 0),                      # Partition 0
            struct.pack('>i', total_len + 24),         # Size of message set
            struct.pack('>q', 0),                      # No offset specified
            struct.pack('>i', len(msg_a_binary)),      # Length of message
            msg_a_binary,                              # Actual message
            struct.pack('>q', 0),                      # No offset specified
            struct.pack('>i', len(msg_b_binary)),      # Length of message
            msg_b_binary,                              # Actual message
        ])

        topic2 = b"".join([
            struct.pack('>h6s', 6, b'topic2'),          # The topic1
            struct.pack('>i', 1),                       # One message set
            struct.pack('>i', 1),                       # Partition 1
            struct.pack('>i', len(msg_c_binary) + 12),  # Size of message set
            struct.pack('>q', 0),                       # No offset specified
            struct.pack('>i', len(msg_c_binary)),       # Length of message
            msg_c_binary,                               # Actual message
        ])

        expected1 = b"".join([header, topic1, topic2])
        expected2 = b"".join([header, topic2, topic1])

        encoded = KafkaCodec.encode_produce_request(
            b"client1", 2, requests, 2, 100)
        self.assertIn(encoded, [expected1, expected2])
Exemplo n.º 3
0
    def test_encode_message(self):
        message = create_message(b"test", b"key")
        encoded = KafkaCodec._encode_message(message)
        expect = b"".join([
            struct.pack(">i", -1427009701),  # CRC
            struct.pack(">bb", 0, 0),        # Magic, flags
            struct.pack(">i", 3),            # Length of key
            b"key",                          # key
            struct.pack(">i", 4),            # Length of value
            b"test",                         # value
        ])

        self.assertEqual(encoded, expect)
Exemplo n.º 4
0
    def test_encode_message(self):
        message = create_message(b"test", b"key")
        encoded = KafkaCodec._encode_message(message)
        expect = b"".join([
            struct.pack(">i", -1427009701),  # CRC
            struct.pack(">bb", 0, 0),  # Magic, flags
            struct.pack(">i", 3),  # Length of key
            b"key",  # key
            struct.pack(">i", 4),  # Length of value
            b"test",  # value
        ])

        self.assertEqual(encoded, expect)
Exemplo n.º 5
0
    def test_encode_message(self):
        message = create_message((47, b"test"), b"key", magic=1)
        encoded = KafkaCodec._encode_message(message)
        expect = b"".join([
            struct.pack(">i", -1232077792),  # CRC
            struct.pack(">bbq", 1, 0, 47),  # Magic, flags, timestamp
            struct.pack(">i", 3),  # Length of key
            b"key",  # key
            struct.pack(">i", 4),  # Length of value
            b"test",  # value
        ])

        self.assertEqual(encoded, expect)