add proxy support for aws lambda (#807)

* add proxy support for aws lambda

* Update lib/proxiedFetch.js

Co-authored-by: Copilot <[email protected]>

* change to commonJS format

* fix the correct path for lib

* correct args to createProbot

* fix import

* add plugins

* Update deploy.md

* Update docs/deploy.md

Co-authored-by: Copilot <[email protected]>

---------

Co-authored-by: Copilot <[email protected]>

Author: decyjphr

docs/deploy.md

@@ -54,42 +54,48 @@ Optional values in the .env file can be found under the [Environment variables](
 
 Once you have the `.env` file configured, you are ready to start the building of the container.
 
-### Docker
-#### Build the Docker container
+## Docker
+### Build the Docker container
 Once you have configured the **GitHub App** and updated the source code, you should be ready to build the container.
 - Change directory to inside the code base
   - `cd safe-settings/`
 - Build the container
   - `docker build -t safe-settings .`
 - This process should complete successfully and you will then have a **Docker** container ready for deployment
 
-#### Run the Docker container
+### Run the Docker container
 Once the container has been successfully built, you can deploy it and start utilizing the **GitHub App**.
 
-#### Start the container with docker-compose
+### Start the container with docker-compose
 If you have docker-compose installed, you can simply start and stop the **Docker** container with:
 - `cd safe-settings/; docker-compose --env-file .env up -d`
 This will start the container in the background and detached.
 
-#### Start Docker container Detached in background
+### Start Docker container Detached in background
 - Start the container detached with port assigned (*Assuming port 3000 for the webhook*)
   - `docker run -d -p 3000:3000 safe-settings`
 - You should now have the container running in the background and can validate it running with the command:
   - `docker ps`
 - This should show the `safe-settings` alive and running
 
-#### Start Docker container attached in forground (Debug)
+### Start Docker container attached in foreground (Debug)
 - If you need to run the container in interactive mode to validate connectivity and functionality:
   - `docker run -it -p 3000:3000 safe-settings`
 - You will now have the log of the container showing to your terminal, and can validate connectivity and functionality.
 
-#### Connect to running Docker container (Debug)
+### Connect to running Docker container (Debug)
 - If you need to connect to the container thats already running, you can run the following command:
   - `docker exec -it safe-settings /bin/sh`
 - You will now be inside the running **Docker** container and can perform any troubleshooting needed
 
-### Deploy the app to AWS Lambda
+## Deploy the app to AWS Lambda
 [Serverless Framework Deployment of safe-settings on AWS](AWS-README.md)
+
+### Proxy Support
+The AWS Lambda handler, `handler.js` uses a custom  `Octokit` factory that creates Octokit with ___Proxied fetch___ instead of the regular ___fetch___ when the `http_proxy`/`https_proxy` env variables are set.
+
+In the future we can use the same pattern to support proxy in all deployments of the app.
+
 ## Deploy the app in Kubernetes
 
 ### __Deploying using kubectl__

handler.js

@@ -2,15 +2,16 @@ const {
   createLambdaFunction,
   createProbot
 } = require('@probot/adapter-aws-lambda-serverless')
+const { getProbotOctoKit } = require('./lib/proxyAwareProbotOctokit')
 
 const appFn = require('./')
 
 module.exports.webhooks = createLambdaFunction(appFn, {
-  probot: createProbot()
+  probot: createProbot({ overrides: { Octokit: getProbotOctoKit() } })
 })
 
 module.exports.scheduler = function () {
-  const probot = createProbot()
+  const probot = createProbot({ overrides: { Octokit: getProbotOctoKit() } })
   const app = appFn(probot, {})
   return app.syncInstallation()
 }

lib/proxiedFetch.js

@@ -0,0 +1,18 @@
+const { getProxyForUrl } = require('proxy-from-env')
+const { ProxyAgent, fetch: undiciFetch } = require('undici')
+
+function getProxiedFetch (url) {
+  const proxyUrl = getProxyForUrl(url)
+  if (proxyUrl) {
+    // LOG.debug('Setting up proxy agent for ', url)
+    return (url, options) => {
+      return undiciFetch(url, {
+        ...options,
+        dispatcher: new ProxyAgent(proxyUrl)
+      })
+    }
+  }
+  return null
+}
+
+module.exports = getProxiedFetch

lib/proxyAwareProbotOctokit.js

@@ -0,0 +1,63 @@
+// This custom plugin overrides the default ProbotOctokit plugin and support Http Proxy.
+const { Octokit } = require('@octokit/core')
+const { enterpriseCompatibility } = require('@octokit/plugin-enterprise-compatibility')
+// const { RequestOptions } = require('@octokit/types')
+const { paginateRest } = require('@octokit/plugin-paginate-rest')
+const { legacyRestEndpointMethods } = require('@octokit/plugin-rest-endpoint-methods')
+const { retry } = require('@octokit/plugin-retry')
+const { throttling } = require('@octokit/plugin-throttling')
+const { config } = require('@probot/octokit-plugin-config')
+const { createProbotAuth } = require('octokit-auth-probot')
+const getProxiedFetch = require('./proxiedFetch')
+
+const ProbotOctokit = Octokit.plugin(
+  throttling,
+  retry,
+  paginateRest,
+  legacyRestEndpointMethods,
+  enterpriseCompatibility,
+  config
+).defaults((instanceOptions) => {
+  const defaultOptions = {
+    authStrategy: createProbotAuth,
+    throttle: {
+      onSecondaryRateLimit: (
+        retryAfter,
+        options,
+        octokit
+      ) => {
+        octokit.log.warn(
+          `SecondaryRateLimit hit with "${options.method} ${options.url}", retrying in ${retryAfter} seconds.`
+        )
+        return true
+      },
+      onRateLimit: (
+        retryAfter,
+        options,
+        octokit
+      ) => {
+        octokit.log.warn(
+          `Rate limit hit with "${options.method} ${options.url}", retrying in ${retryAfter} seconds.`
+        )
+        return true
+      }
+    },
+    userAgent: 'probot',
+    request: {
+      fetch: getProxiedFetch(instanceOptions.baseUrl) || fetch
+    }
+  }
+  // merge options deeply
+  const options = Object.assign({}, defaultOptions, instanceOptions, {
+    request: Object.assign({}, defaultOptions.request, instanceOptions.request),
+    throttle: instanceOptions.throttle
+      ? Object.assign({}, defaultOptions.throttle, instanceOptions.throttle)
+      : defaultOptions.throttle
+  })
+  return options
+})
+
+function getProbotOctoKit () {
+  return ProbotOctokit
+}
+module.exports = { getProbotOctoKit }

package-lock.json

@@ -33,7 +33,9 @@
     "lodash": "^4.17.21",
     "node-cron": "^3.0.2",
     "octokit": "^4.1.2",
-    "probot": "^13.4.4"
+    "probot": "^13.4.4",
+    "proxy-from-env": "^1.1.0",
+    "undici": "^7.7.0"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.1.0",