FilesExpand file tree

main

/

Options.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

161 lines (145 loc) · 6.15 KB

main

/

Options.java

Copy path

Top

File metadata and controls

• Code
• Blame

161 lines (145 loc) · 6.15 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

package com.hook0.client;

import java.time.Duration;

/**

* Every bound a client applies to one send.

*

* <p>The first three bound what this client does; the last four bound what the other end may cost it. A server that is

* broken or hostile can otherwise stream a body, a head or a single header of any length into a caller's memory, and a

* client with no ceiling has no answer to that.

*

* <p>The four are not interchangeable. {@code maxHeadBytes} is the one that bounds what a head can cost, because it

* bounds the total; a line count and a size per line multiply, and 64 lines of 64 KiB is 4 MiB of head admitted by

* both. Those two earn their place by refusing sooner — on the first line past the count, or the first line too long —

* rather than after the whole head has been read.

*

* @param retryPolicy how the attempts of one send are spaced out

* @param requestTimeout how long one attempt is given

* @param maxPayloadBytes the largest payload sent, refused before a socket is opened

* @param maxResponseBytes the largest answer read off a socket

* @param maxHeadBytes the largest head of an answer, every line of it taken together

* @param maxResponseHeaders how many header lines an answer may carry

* @param maxHeaderBytes the longest one header line may be

*/

public record Options(

RetryPolicy retryPolicy,

Duration requestTimeout,

int maxPayloadBytes,

long maxResponseBytes,

int maxHeadBytes,

int maxResponseHeaders,

int maxHeaderBytes) {

/**

* Largest event payload the client agrees to send, in bytes.

*

* <p>Hook0's API refuses request bodies above 2 MiB, so a payload above 1 MiB is already at risk of being refused

* once the JSON envelope around it — metadata, labels, identifiers — is counted. The client rules such an event out

* rather than spending a round trip, and every retry after it, on a request that cannot be accepted.

*/

public static final int DEFAULT_MAX_PAYLOAD_BYTES = 1024 * 1024;

/** Largest response body read off a socket, in bytes. */

public static final long DEFAULT_MAX_RESPONSE_BYTES = 8L * 1024 * 1024;

/**

* Largest head of an answer read off a socket, every line of it taken together, in bytes.

*

* <p>The number is the ceiling of the strictest runtime any Hook0 SDK runs on rather than a round figure, so that

* every target can apply the same one in library code instead of inheriting whatever its runtime happens to do. This

* one bounds what a head can cost; the two below it refuse sooner.

*/

public static final int DEFAULT_MAX_HEAD_BYTES = 16 * 1024;

/** How many header lines an answer may carry before it is refused. */

public static final int DEFAULT_MAX_RESPONSE_HEADERS = 64;

/** Longest one header line may be, name and value together, in bytes. */

public static final int DEFAULT_MAX_HEADER_BYTES = 64 * 1024;

/**

* Longest one attempt at reaching the API is given before it is abandoned.

*

* <p>Ten seconds is far above what ingesting an event takes when the API is healthy, and short enough that a stuck

* connection does not hold a caller for a noticeable time.

*/

public static final Duration DEFAULT_REQUEST_TIMEOUT = Duration.ofSeconds(10);

/**

* The bounds a client applies when the caller names none.

*

* @return the defaults, which are the numbers the shared conformance corpus writes down

*/

public static Options defaults() {

return new Options(

RetryPolicy.defaults(),

DEFAULT_REQUEST_TIMEOUT,

DEFAULT_MAX_PAYLOAD_BYTES,

DEFAULT_MAX_RESPONSE_BYTES,

DEFAULT_MAX_HEAD_BYTES,

DEFAULT_MAX_RESPONSE_HEADERS,

DEFAULT_MAX_HEADER_BYTES);

}

/**

* The same bounds, under another schedule.

*

* @param chosen the schedule to apply

* @return the bounds with that schedule

*/

public Options withRetryPolicy(RetryPolicy chosen) {

return new Options(

chosen, requestTimeout, maxPayloadBytes, maxResponseBytes, maxHeadBytes, maxResponseHeaders, maxHeaderBytes);

}

/**

* The same bounds, giving one attempt that long.

*

* @param chosen how long one attempt is given

* @return the bounds with that timeout

*/

public Options withRequestTimeout(Duration chosen) {

return new Options(

retryPolicy, chosen, maxPayloadBytes, maxResponseBytes, maxHeadBytes, maxResponseHeaders, maxHeaderBytes);

}

/**

* The same bounds, sending at most that many bytes of payload.

*

* @param chosen the largest payload sent

* @return the bounds with that ceiling

*/

public Options withMaxPayloadBytes(int chosen) {

return new Options(

retryPolicy, requestTimeout, chosen, maxResponseBytes, maxHeadBytes, maxResponseHeaders, maxHeaderBytes);

}

/**

* The same bounds, reading at most that many bytes of answer.

*

* @param chosen the largest answer read

* @return the bounds with that ceiling

*/

public Options withMaxResponseBytes(long chosen) {

return new Options(

retryPolicy, requestTimeout, maxPayloadBytes, chosen, maxHeadBytes, maxResponseHeaders, maxHeaderBytes);

}

/**

* The same bounds, reading at most that large a head.

*

* @param chosen the largest head read, every line of it taken together

* @return the bounds with that ceiling

*/

public Options withMaxHeadBytes(int chosen) {

return new Options(

retryPolicy, requestTimeout, maxPayloadBytes, maxResponseBytes, chosen, maxResponseHeaders, maxHeaderBytes);

}

/**

* The same bounds, reading at most that many header lines.

*

* @param chosen how many header lines an answer may carry

* @return the bounds with that ceiling

*/

public Options withMaxResponseHeaders(int chosen) {

return new Options(

retryPolicy, requestTimeout, maxPayloadBytes, maxResponseBytes, maxHeadBytes, chosen, maxHeaderBytes);

}

/**

* The same bounds, reading at most that long a header line.

*

* @param chosen the longest one header line may be

* @return the bounds with that ceiling

*/

public Options withMaxHeaderBytes(int chosen) {

return new Options(

retryPolicy, requestTimeout, maxPayloadBytes, maxResponseBytes, maxHeadBytes, maxResponseHeaders, chosen);

}

}