Integrasi langsung ke instance RPKI validator eksternal (seperti Routinator, OctoRPKI, atau StayRTR) pada automated testing pipeline sering kali memicu flaky test. Uji coba berbasis jaringan publik rentan terhadap latensi rsync/RRDP, keterlambatan propagasi Validated ROA Payloads (VRP), serta connection timeout. Masalah ini semakin jelas ketika tim menjalankan validator ringan dalam kontainer pengujian tanpa alokasi CPU atau memori yang memadai.
Solusi deterministik untuk mengatasi masalah ini adalah mengisolasi dependensi validator menggunakan pola mocking cache RTR lokal. Protokol RPKI-to-Router (RTR, RFC 6810 / RFC 8210) menggunakan struktur biner sederhana di atas transport TCP. Membangun mock server RTR lokal memungkinkan pipeline CI/CD memverifikasi logika validasi rute (Valid, Invalid, NotFound) serta skenario fallback secara cepat tanpa dependensi eksternal.
Anatomi Paket RTR dan Masalah Flaky Test
Flaky test pada sistem validasi rute terjadi akibat tiga faktor utama:
- Sinkronisasi VRP Asinkron: Repository RPKI global membutuhkan waktu sinkronisasi berkala. Pengujian yang bergantung pada rute publik baru dapat menghasilkan status NotFound sebelum sinkronisasi selesai.
- Beban Komputasi Validasi Kriptografi: Validator RPKI harus memvalidasi rantai sertifikat X.509 dan manifest CMS. Proses ini memicu CPU spike pada runner CI/CD yang berujung pada socket timeout.
- Kegagalan Transpor Eksternal: Dependensi ke port RTR remote (default port 323 atau 8282) memperbesar risiko kegagalan handshake akibat filter firewall atau degradasi rute internet.
Protokol RTR v0 (RFC 6810) dan v1 (RFC 8210) berkomunikasi via Protocol Data Unit (PDU) biner. Ketika router atau client service mengirim Reset Query (PDU Type 2), server RTR merespons dengan urutan: Cache Response (PDU Type 3), satu atau beberapa IPv4/IPv6 Prefix (PDU Type 4/6), dan diakhiri dengan End of Data (PDU Type 7).
Implementasi Mock Server RTR Lokal
Mock server berikut mengimplementasikan sebagian kecil spesifikasi RFC 6810 menggunakan Python standard library. Server ini menyajikan sekumpulan VRP statis untuk IPv4 Prefix PDU guna memastikan hasil pengujian deterministik.
import socket
import struct
import threading
class LocalRTRMock:
def __init__(self, host="127.0.0.1", port=8323):
self.host = host
self.port = port
self.sock = None
self.thread = None
self.is_running = False
def _pack_cache_response(self, session_id=1):
# Protocol Version: 0, PDU Type: 3 (Cache Response), Session ID: 1, Length: 8
return struct.pack("!BBHH", 0, 3, session_id, 8)
def _pack_ipv4_prefix(self, ip_bytes, prefix_len, max_len, asn, flags=1):
# PDU Type: 4 (IPv4 Prefix), Length: 20
# Flags: 1 (Announcement), 0 (Withdrawal)
return struct.pack("!BBBB4sII", 0, 4, 0, flags, ip_bytes, prefix_len, max_len, asn)
def _pack_end_of_data(self, session_id=1, serial=1):
# Protocol Version: 0, PDU Type: 7 (End of Data), Session ID: 1, Length: 12
return struct.pack("!BBHII", 0, 7, session_id, 12, serial)
def _handle_client(self, conn):
try:
while self.is_running:
header = conn.recv(8)
if not header or len(header) < 8:
break
version, pdu_type, session_id, length = struct.unpack("!BBHH", header)
# Reset Query (Type 2) or Serial Query (Type 1)
if pdu_type in (1, 2):
payload = bytearray()
payload.extend(self._pack_cache_response(session_id=100))
# ROA 1: 198.51.100.0/24 MaxLen 24 ASN 64496
ip_roa1 = socket.inet_aton("198.51.100.0")
payload.extend(self._pack_ipv4_prefix(ip_roa1, 24, 24, 64496))
# ROA 2: 203.0.113.0/24 MaxLen 28 ASN 64497
ip_roa2 = socket.inet_aton("203.0.113.0")
payload.extend(self._pack_ipv4_prefix(ip_roa2, 24, 28, 64497))
payload.extend(self._pack_end_of_data(session_id=100, serial=1))
conn.sendall(payload)
except (socket.error, struct.error):
pass
finally:
conn.close()
def start(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind((self.host, self.port))
self.sock.listen(5)
self.is_running = True
self.thread = threading.Thread(target=self._run)
self.thread.daemon = True
self.thread.start()
def _run(self):
while self.is_running:
try:
conn, _ = self.sock.accept()
threading.Thread(target=self._handle_client, args=(conn,), daemon=True).start()
except socket.error:
break
def stop(self):
self.is_running = False
if self.sock:
self.sock.close()
Pengujian Determinik Validitas Rute BGP
Dengan mock cache RTR lokal yang berjalan di port 8323, client service dapat mengonsumsi VRP statis untuk mengevaluasi status rute BGP RFC 6811 tanpa interaksi validator eksternal. Logika evaluasi menghasilkan tiga kondisi deterministik:
- Valid: Prefix BGP cocok dengan ROA dan ASN pengirim sesuai batas
max_length. - Invalid: Prefix BGP tercakup dalam ROA, namun ASN pengirim berbeda atau panjang subnet melebihi
max_length. - NotFound: Prefix BGP tidak terdaftar dalam tabel VRP cache RTR.
import unittest
from ipaddress import ip_network
# Menggunakan mock server dari implementasi sebelumnya
class TestRouteValidation(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.server = LocalRTRMock(port=8323)
cls.server.start()
# Inisialisasi client RTR hipotetis terhadap localhost:8323
cls.client = MockBGPRouteValidator(host="127.0.0.1", port=8323)
cls.client.sync()
@classmethod
def tearDownClass(cls):
cls.server.stop()
def test_route_valid(self):
# Cocok persis dengan ROA 1
status = self.client.validate(asn=64496, prefix="198.51.100.0/24")
self.assertEqual(status, "Valid")
def test_route_invalid_asn(self):
# Prefix sesuai ROA 1, tapi ASN salah
status = self.client.validate(asn=65000, prefix="198.51.100.0/24")
self.assertEqual(status, "Invalid")
def test_route_invalid_length(self):
# ASN sesuai ROA 1, tapi panjang prefix /25 melebihi MaxLen 24
status = self.client.validate(asn=64496, prefix="198.51.100.0/25")
self.assertEqual(status, "Invalid")
def test_route_not_found(self):
# Prefix tidak ada di database VRP
status = self.client.validate(asn=64496, prefix="192.0.2.0/24")
self.assertEqual(status, "NotFound")
Pola Pengujian Skema Fallback Offline
Layanan routing modern wajib menangani skenario saat RTR server mendadak tidak responsif. RFC mengamanatkan penggunaan fallback seperti expire timer atau beralih ke cache sekunder tanpa langsung membatalkan seluruh rute BGP aktif.
Mock server lokal memungkinkan pengujian skenario ini secara presisi melalui simulasi pemutusan soket:
def test_rtr_server_offline_fallback():
server = LocalRTRMock(port=8324)
server.start()
client = MockBGPRouteValidator(host="127.0.0.1", port=8324)
client.sync()
assert client.is_connected() is True
# Matikan server secara paksa
server.stop()
# Client mencoba re-sync, harus fallback ke stale cache tanpa panic
result = client.sync_with_retry(max_retries=1)
assert result == "USED_STALE_CACHE"
# Validasi rute tetap berfungsi menggunakan cache lokal lama
status = client.validate(asn=64496, prefix="198.51.100.0/24")
assert status == "Valid"
Trade-off dan Batasan
Meskipun mock cache RTR lokal menghilangkan ketergantungan eksternal dan mempercepat pipeline CI/CD hingga hitungan milidetik, pertimbangkan batasan berikut:
- Tidak Menguji Kriptografi Nyata: Mock server memotong layer validasi X.509, RPKI Manifest (.mft), dan CMS signature. Pengujian kriptografi sebaiknya ditempatkan di level integration/e2e test terjadwal terpisah (nightly build).
- Implementasi Protokol Terbatas: Contoh di atas hanya menangani PDU IPv4. Untuk pengujian dual-stack, tambahkan parsing IPv6 Prefix PDU (Type 6) dan pemrosesan
Serial Notify(Type 0). - Sinkronisasi Incremental: Pengujian kompleks yang membutuhkan update delta via Serial Query perlu menyimpan state serial secara berurutan di dalam instance mock.
Komentar
0 komentar
Masuk ke akun kamu untuk ikut berkomentar.
Belum ada komentar
Jadilah yang pertama ikut berdiskusi!