Lines Matching refs:client
115 channels.sendHeaders = diagnosticsChannel.channel('undici:client:sendHeaders')
116 channels.beforeConnect = diagnosticsChannel.channel('undici:client:beforeConnect')
117 channels.connectError = diagnosticsChannel.channel('undici:client:connectError')
118 channels.connected = diagnosticsChannel.channel('undici:client:connected')
127 * @type {import('../types/client').default}
133 * @param {import('../types/client').Client.Options} options
452 const client = this[kClient]
454 client[kSocket] = null
455 client[kHTTP2Session] = null
457 if (client.destroyed) {
461 const requests = client[kQueue].splice(client[kRunningIdx])
466 } else if (client[kRunning] > 0) {
468 const request = client[kQueue][client[kRunningIdx]]
469 client[kQueue][client[kRunningIdx]++] = null
471 errorRequest(client, request, err)
474 client[kPendingIdx] = client[kRunningIdx]
476 assert(client[kRunning] === 0)
478 client.emit('disconnect',
479 client[kUrl],
480 [client],
484 resume(client)
567 constructor (client, socket, { exports }) {
568 assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0)
572 this.client = client
582 this.headersMaxSize = client[kMaxHeadersSize]
592 this.maxResponseSize = client[kMaxResponseSize]
732 const { socket, client } = this
739 const request = client[kQueue][client[kRunningIdx]]
787 const { upgrade, client, socket, headers, statusCode } = this
791 const request = client[kQueue][client[kRunningIdx]]
795 assert(socket === client[kSocket])
820 client[kSocket] = null
821 client[kQueue][client[kRunningIdx]++] = null
822 client.emit('disconnect', client[kUrl], [client], new InformationalError('upgrade'))
830 resume(client)
834 const { client, socket, headers, statusText } = this
841 const request = client[kQueue][client[kRunningIdx]]
874 : client[kBodyTimeout]
884 assert(client[kRunning] === 1)
890 assert(client[kRunning] === 1)
899 if (this.shouldKeepAlive && client[kPipelining]) {
904 keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
905 client[kKeepAliveMaxTimeout]
910 client[kKeepAliveTimeoutValue] = timeout
913 client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]
936 resume(client)
943 const { client, socket, statusCode, maxResponseSize } = this
949 const request = client[kQueue][client[kRunningIdx]]
975 const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this
985 const request = client[kQueue][client[kRunningIdx]]
1013 client[kQueue][client[kRunningIdx]++] = null
1016 assert.strictEqual(client[kRunning], 0)
1023 } else if (socket[kReset] && client[kRunning] === 0) {
1030 } else if (client[kPipelining] === 1) {
1034 setImmediate(resume, client)
1036 resume(client)
1042 const { socket, timeoutType, client } = parser
1046 if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
1055 assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue])
1068 const { [kClient]: client, [kParser]: parser } = this
1072 if (client[kHTTPConnVersion] !== 'h2') {
1087 function onError (client, err) {
1089 client[kRunning] === 0 &&
1096 assert(client[kPendingIdx] === client[kRunningIdx])
1098 const requests = client[kQueue].splice(client[kRunningIdx])
1101 errorRequest(client, request, err)
1103 assert(client[kSize] === 0)
1108 const { [kParser]: parser, [kClient]: client } = this
1110 if (client[kHTTPConnVersion] !== 'h2') {
1122 const { [kClient]: client, [kParser]: parser } = this
1124 if (client[kHTTPConnVersion] === 'h1' && parser) {
1136 client[kSocket] = null
1138 if (client.destroyed) {
1139 assert(client[kPending] === 0)
1142 const requests = client[kQueue].splice(client[kRunningIdx])
1145 errorRequest(client, request, err)
1147 } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
1149 const request = client[kQueue][client[kRunningIdx]]
1150 client[kQueue][client[kRunningIdx]++] = null
1152 errorRequest(client, request, err)
1155 client[kPendingIdx] = client[kRunningIdx]
1157 assert(client[kRunning] === 0)
1159 client.emit('disconnect', client[kUrl], [client], err)
1161 resume(client)
1164 async function connect (client) {
1165 assert(!client[kConnecting])
1166 assert(!client[kSocket])
1168 let { host, hostname, protocol, port } = client[kUrl]
1181 client[kConnecting] = true
1190 servername: client[kServerName],
1191 localAddress: client[kLocalAddress]
1193 connector: client[kConnector]
1199 client[kConnector]({
1204 servername: client[kServerName],
1205 localAddress: client[kLocalAddress]
1215 if (client.destroyed) {
1220 client[kConnecting] = false
1233 const session = http2.connect(client[kUrl], {
1235 peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams
1238 client[kHTTPConnVersion] = 'h2'
1239 session[kClient] = client
1248 client[kHTTP2Session] = session
1260 socket[kParser] = new Parser(client, socket, llhttpInstance)
1264 socket[kMaxRequests] = client[kMaxRequests]
1265 socket[kClient] = client
1274 client[kSocket] = socket
1283 servername: client[kServerName],
1284 localAddress: client[kLocalAddress]
1286 connector: client[kConnector],
1290 client.emit('connect', client[kUrl], [client])
1292 if (client.destroyed) {
1296 client[kConnecting] = false
1305 servername: client[kServerName],
1306 localAddress: client[kLocalAddress]
1308 connector: client[kConnector],
1314 assert(client[kRunning] === 0)
1315 while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
1316 const request = client[kQueue][client[kPendingIdx]++]
1317 errorRequest(client, request, err)
1320 onError(client, err)
1323 client.emit('connectionError', client[kUrl], [client], err)
1326 resume(client)
1329 function emitDrain (client) {
1330 client[kNeedDrain] = 0
1331 client.emit('drain', client[kUrl], [client])
1334 function resume (client, sync) {
1335 if (client[kResuming] === 2) {
1339 client[kResuming] = 2
1341 _resume(client, sync)
1342 client[kResuming] = 0
1344 if (client[kRunningIdx] > 256) {
1345 client[kQueue].splice(0, client[kRunningIdx])
1346 client[kPendingIdx] -= client[kRunningIdx]
1347 client[kRunningIdx] = 0
1351 function _resume (client, sync) {
1353 if (client.destroyed) {
1354 assert(client[kPending] === 0)
1358 if (client[kClosedResolve] && !client[kSize]) {
1359 client[kClosedResolve]()
1360 client[kClosedResolve] = null
1364 const socket = client[kSocket]
1367 if (client[kSize] === 0) {
1377 if (client[kSize] === 0) {
1379 socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE)
1381 } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
1383 const request = client[kQueue][client[kRunningIdx]]
1386 : client[kHeadersTimeout]
1392 if (client[kBusy]) {
1393 client[kNeedDrain] = 2
1394 } else if (client[kNeedDrain] === 2) {
1396 client[kNeedDrain] = 1
1397 process.nextTick(emitDrain, client)
1399 emitDrain(client)
1404 if (client[kPending] === 0) {
1408 if (client[kRunning] >= (client[kPipelining] || 1)) {
1412 const request = client[kQueue][client[kPendingIdx]]
1414 if (client[kUrl].protocol === 'https:' && client[kServerName] !== request.servername) {
1415 if (client[kRunning] > 0) {
1419 client[kServerName] = request.servername
1427 if (client[kConnecting]) {
1431 if (!socket && !client[kHTTP2Session]) {
1432 connect(client)
1440 if (client[kRunning] > 0 && !request.idempotent) {
1447 if (client[kRunning] > 0 && (request.upgrade || request.method === 'CONNECT')) {
1454 if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 &&
1467 if (!request.aborted && write(client, request)) {
1468 client[kPendingIdx]++
1470 client[kQueue].splice(client[kPendingIdx], 1)
1480 function write (client, request) {
1481 if (client[kHTTPConnVersion] === 'h2') {
1482 writeH2(client, client[kHTTP2Session], request)
1528 if (client[kStrictContentLength]) {
1529 errorRequest(client, request, new RequestContentLengthMismatchError())
1536 const socket = client[kSocket]
1544 errorRequest(client, request, err || new RequestAbortedError())
1549 errorRequest(client, request, err)
1575 if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
1588 header += client[kHostHeader]
1593 } else if (client[kPipelining] && !socket[kReset]) {
1630 writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload })
1632 writeBlob({ body, client, request, socket, contentLength, header, expectsPayload })
1635 writeStream({ body, client, request, socket, contentLength, header, expectsPayload })
1637 writeIterable({ body, client, request, socket, contentLength, header, expectsPayload })
1645 function writeH2 (client, session, request) {
1653 errorRequest(client, request, new Error('Upgrade not supported for H2'))
1664 errorRequest(client, request, err || new RequestAbortedError())
1667 errorRequest(client, request, err)
1676 const h2State = client[kHTTP2SessionState]
1678 headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost]
1752 if (client[kStrictContentLength]) {
1753 errorRequest(client, request, new RequestContentLengthMismatchError())
1811 if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
1819 errorRequest(client, request, err)
1821 if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
1860 client,
1866 socket: client[kSocket],
1872 client,
1878 socket: client[kSocket]
1884 client,
1888 socket: client[kSocket],
1895 client,
1901 socket: client[kSocket]
1909 function writeStream ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
1910 assert(contentLength !== 0 || client[kRunning] === 0, 'stream body cannot be pipelined')
1912 if (client[kHTTPConnVersion] === 'h2') {
1942 const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header })
1980 assert(socket.destroyed || (socket[kWriting] && client[kRunning] <= 1))
2024 async function writeBlob ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
2027 const isH2 = client[kHTTPConnVersion] === 'h2'
2053 resume(client)
2059 async function writeIterable ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
2060 assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined')
2081 if (client[kHTTPConnVersion] === 'h2') {
2116 const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header })
2140 constructor ({ socket, request, contentLength, client, expectsPayload, header }) {
2144 this.client = client
2153 const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this
2170 if (client[kStrictContentLength]) {
2216 const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this
2245 if (client[kStrictContentLength]) {
2259 resume(client)
2263 const { socket, client } = this
2268 assert(client[kRunning] <= 1, 'pipeline should only contain this request')
2274 function errorRequest (client, request, err) {
2279 client.emit('error', err)