cdk-ecr-deployment 2.1.3 → 2.3.0

package/node_modules/hpagent/README.md

@@ -0,0 +1,138 @@
+# hpagent
+
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)  ![build](https://github.com/delvedor/hpagent/workflows/build/badge.svg)
+
+A ready to use http and https agent for working with proxies that keeps connections alive!
+
+## Install
+
+```
+npm install hpagent
+```
+
+## Usage
+
+Based on your infrastructure, you should use the http agent or the https agent.
+The following table will help you picking the right one.
+
+| Type              | Proxy  | Server |
+|-------------------|--------|--------|
+| `HttpProxyAgent`  | HTTP   | HTTP   |
+| `HttpProxyAgent`  | HTTPS  | HTTP   |
+| `HttpsProxyAgent` | HTTP   | HTTPS  |
+| `HttpsProxyAgent` | HTTPS  | HTTPS  |
+
+```js
+const { HttpProxyAgent, HttpsProxyAgent } = require('hpagent')
+```
+
+Once you have understood the right agent for your use case, you can instance it. It takes the same parameter of the Node.js core's http(s) agent and an additional `proxy` option, which is the url of your proxy.
+
+```js
+const http = require('http')
+const { HttpProxyAgent } = require('hpagent')
+
+const agent = new HttpProxyAgent({
+  keepAlive: true,
+  keepAliveMsecs: 1000,
+  maxSockets: 256,
+  maxFreeSockets: 256,
+  proxy: 'http://localhost:8080'
+})
+
+http.get('http://localhost:9200', { agent })
+    .on('response', console.log)
+    .end()
+```
+
+If your proxy requires basic authentication, you can configure it in the proxy url:
+
+```js
+const http = require('http')
+const { HttpProxyAgent } = require('hpagent')
+
+const agent = new HttpProxyAgent({
+  keepAlive: true,
+  keepAliveMsecs: 1000,
+  maxSockets: 256,
+  maxFreeSockets: 256,
+  proxy: 'http://user:pwd@localhost:8080'
+})
+
+http.get('http://localhost:9200', { agent })
+    .on('response', console.log)
+    .end()
+```
+
+## Integrations
+
+Following you can find the list of userland http libraries that are tested with this agent.
+
+### [got](https://github.com/sindresorhus/got)
+
+```js
+got('http://localhost:9200', {
+  agent: {
+    http: new HttpProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: 'http://localhost:8080'
+    })
+  }
+})
+```
+
+### [needle](https://github.com/tomas/needle)
+
+```js
+needle('get', 'http://localhost:9200', {
+  agent: new HttpProxyAgent({
+    keepAlive: true,
+    keepAliveMsecs: 1000,
+    maxSockets: 256,
+    maxFreeSockets: 256,
+    scheduling: 'lifo',
+    proxy: 'http://localhost:8080'
+  })
+})
+```
+
+### [node-fetch](https://github.com/node-fetch/node-fetch)
+
+```js
+fetch('http://localhost:9200', {
+  agent: new HttpProxyAgent({
+    keepAlive: true,
+    keepAliveMsecs: 1000,
+    maxSockets: 256,
+    maxFreeSockets: 256,
+    scheduling: 'lifo',
+    proxy: 'http://localhost:8080'
+  })
+})
+```
+
+### [simple-get](https://github.com/feross/simple-get)
+
+```js
+sget.concat({
+  url: `http://${server.address().address}:${server.address().port}`,
+  agent: new HttpProxyAgent({
+    keepAlive: true,
+    keepAliveMsecs: 1000,
+    maxSockets: 256,
+    maxFreeSockets: 256,
+    scheduling: 'lifo',
+    proxy: `https://${proxy.address().address}:${proxy.address().port}`
+  })
+}, function (err, response, data) {
+  // handle the response
+})
+```
+
+## License
+
+This software is licensed under the [MIT](./LICENSE).

package/node_modules/hpagent/index.d.ts

@@ -0,0 +1,26 @@
+import * as http from 'http'
+import * as https from 'https'
+import { URL } from 'url'
+
+declare class HttpProxyAgent extends http.Agent {
+  constructor(options: HttpProxyAgentOptions)
+}
+
+interface HttpProxyAgentOptions extends http.AgentOptions {
+  proxy: string | URL
+}
+
+declare class HttpsProxyAgent extends https.Agent {
+  constructor(options: HttpsProxyAgentOptions)
+}
+
+interface HttpsProxyAgentOptions extends https.AgentOptions {
+  proxy: string | URL
+}
+
+export {
+  HttpProxyAgent,
+  HttpProxyAgentOptions,
+  HttpsProxyAgent,
+  HttpsProxyAgentOptions
+}

package/node_modules/hpagent/index.js

@@ -0,0 +1,101 @@
+'use strict'
+
+const https = require('https')
+const http = require('http')
+const { URL } = require('url')
+
+class HttpProxyAgent extends http.Agent {
+  constructor (options) {
+    const { proxy, ...opts } = options
+    super(opts)
+    this.proxy = typeof proxy === 'string'
+      ? new URL(proxy)
+      : proxy
+  }
+
+  createConnection (options, callback) {
+    const requestOptions = {
+      method: 'CONNECT',
+      host: this.proxy.hostname,
+      port: this.proxy.port,
+      path: `${options.host}:${options.port}`,
+      setHost: false,
+      headers: { connection: this.keepAlive ? 'keep-alive' : 'close', host: `${options.host}:${options.port}` },
+      agent: false
+    }
+
+    if (this.proxy.username || this.proxy.password) {
+      const base64 = Buffer.from(`${this.proxy.username || ''}:${this.proxy.password || ''}`).toString('base64')
+      requestOptions.headers['proxy-authorization'] = `Basic ${base64}`
+    }
+
+    const request = (this.proxy.protocol === 'http:' ? http : https).request(requestOptions)
+    request.once('connect', (response, socket, head) => {
+      request.removeAllListeners()
+      socket.removeAllListeners()
+      if (response.statusCode === 200) {
+        callback(null, socket)
+      } else {
+        callback(new Error(`Bad response: ${response.statusCode}`), null)
+      }
+    })
+
+    request.once('error', err => {
+      request.removeAllListeners()
+      callback(err, null)
+    })
+
+    request.end()
+  }
+}
+
+class HttpsProxyAgent extends https.Agent {
+  constructor (options) {
+    const { proxy, ...opts } = options
+    super(opts)
+    this.proxy = typeof proxy === 'string'
+      ? new URL(proxy)
+      : proxy
+  }
+
+  createConnection (options, callback) {
+    const requestOptions = {
+      method: 'CONNECT',
+      host: this.proxy.hostname,
+      port: this.proxy.port,
+      path: `${options.host}:${options.port}`,
+      setHost: false,
+      headers: { connection: this.keepAlive ? 'keep-alive' : 'close', host: `${options.host}:${options.port}` },
+      agent: false
+    }
+
+    if (this.proxy.username || this.proxy.password) {
+      const base64 = Buffer.from(`${this.proxy.username || ''}:${this.proxy.password || ''}`).toString('base64')
+      requestOptions.headers['proxy-authorization'] = `Basic ${base64}`
+    }
+
+    const request = (this.proxy.protocol === 'http:' ? http : https).request(requestOptions)
+    request.once('connect', (response, socket, head) => {
+      request.removeAllListeners()
+      socket.removeAllListeners()
+      if (response.statusCode === 200) {
+        const secureSocket = super.createConnection({ ...options, socket })
+        callback(null, secureSocket)
+      } else {
+        callback(new Error(`Bad response: ${response.statusCode}`), null)
+      }
+    })
+
+    request.once('error', err => {
+      request.removeAllListeners()
+      callback(err, null)
+    })
+
+    request.end()
+  }
+}
+
+module.exports = {
+  HttpProxyAgent,
+  HttpsProxyAgent
+}

package/node_modules/hpagent/index.mjs

@@ -0,0 +1,5 @@
+import mod from './index.js'
+
+export default mod
+export const HttpProxyAgent = mod.HttpProxyAgent
+export const HttpsProxyAgent = mod.HttpsProxyAgent

package/node_modules/hpagent/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "hpagent",
+  "version": "0.1.2",
+  "description": "A ready to use http and https agent for working with proxies that keeps connections alive!",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./": "./"
+  },
+  "scripts": {
+    "test": "standard && ava -v test/*.test.js && tsd"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/delvedor/hpagent.git"
+  },
+  "keywords": [
+    "agent",
+    "http",
+    "https",
+    "secure",
+    "proxy",
+    "alive",
+    "keep-alive"
+  ],
+  "author": "Tomas Della Vedova",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/delvedor/hpagent/issues"
+  },
+  "homepage": "https://github.com/delvedor/hpagent#readme",
+  "tsd": {
+    "directory": "test"
+  },
+  "devDependencies": {
+    "ava": "^3.10.1",
+    "got": "^11.5.1",
+    "needle": "^2.5.0",
+    "node-fetch": "^2.6.0",
+    "proxy": "^1.0.2",
+    "simple-get": "^4.0.0",
+    "standard": "^16.0.1",
+    "tsd": "^0.13.1"
+  }
+}

package/node_modules/hpagent/test/got.test.js

@@ -0,0 +1,111 @@
+'use strict'
+
+const got = require('got')
+const test = require('ava')
+const {
+  createServer,
+  createSecureServer,
+  createProxy,
+  createSecureProxy
+} = require('./utils')
+const { HttpProxyAgent, HttpsProxyAgent } = require('../')
+
+test('http to http', async t => {
+  const server = await createServer()
+  const proxy = await createProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await got(`http://${server.address().address}:${server.address().port}`, {
+    agent: {
+      http: new HttpProxyAgent({
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 256,
+        maxFreeSockets: 256,
+        scheduling: 'lifo',
+        proxy: `http://${proxy.address().address}:${proxy.address().port}`
+      })
+    }
+  })
+
+  t.is(response.body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('https to http', async t => {
+  const server = await createServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await got(`http://${server.address().address}:${server.address().port}`, {
+    agent: {
+      http: new HttpProxyAgent({
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 256,
+        maxFreeSockets: 256,
+        scheduling: 'lifo',
+        proxy: `https://${proxy.address().address}:${proxy.address().port}`
+      })
+    }
+  })
+
+  t.is(response.body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('http to https', async t => {
+  const server = await createSecureServer()
+  const proxy = await createProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await got(`https://${server.address().address}:${server.address().port}`, {
+    agent: {
+      http: new HttpsProxyAgent({
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 256,
+        maxFreeSockets: 256,
+        scheduling: 'lifo',
+        proxy: `http://${proxy.address().address}:${proxy.address().port}`
+      })
+    }
+  })
+
+  t.is(response.body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('https to https', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await got(`https://${server.address().address}:${server.address().port}`, {
+    agent: {
+      http: new HttpsProxyAgent({
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 256,
+        maxFreeSockets: 256,
+        scheduling: 'lifo',
+        proxy: `https://${proxy.address().address}:${proxy.address().port}`
+      })
+    }
+  })
+
+  t.is(response.body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})