Go full dependency injection

lib/github-auth/github-provider.integration.js → lib/github-auth/github-api-provider.integration.js

@@ -2,25 +2,25 @@
 
 const { expect } = require('chai');
 const { PoolingTokenProvider } = require('./token-provider');
-const GithubProvider = require('./github-provider');
+const GithubApiProvider = require('./github-api-provider');
 const serverSecrets = require('../server-secrets');
 
 describe('Github provider with token pool', function() {
   const githubUri = process.env.GITHUB_URL || 'https://api.github.com';
   const reserveFraction = 0.333;
 
-  let tokenProvider, githubProvider;
+  let tokenProvider, githubApiProvider;
   before(function() {
     tokenProvider = new PoolingTokenProvider();
     tokenProvider.addToken(serverSecrets.gh_token);
 
-    githubProvider = new GithubProvider(githubUri, tokenProvider);
-    githubProvider.reserveFraction = reserveFraction;
+    githubApiProvider = new GithubApiProvider(githubUri, tokenProvider);
+    githubApiProvider.reserveFraction = reserveFraction;
   });
 
   const headers = [];
   async function performOneRequest() {
-    const { res } = await githubProvider.requestAsPromise(
+    const { res } = await githubApiProvider.requestAsPromise(
       require('request'),
       '/repos/rust-lang/rust',
       {}

lib/github-auth/github-provider.js → lib/github-auth/github-api-provider.js

@@ -1,8 +1,8 @@
 'use strict';
 
-class GithubProvider {
-  constructor(baseUri, tokenProvider) {
-    this.baseUri = baseUri;
+class GithubApiProvider {
+  constructor(baseUrl, tokenProvider) {
+    this.baseUrl = baseUrl;
     this.tokenProvider = tokenProvider;
 
     // How much of a token's quota do we reserve for the user?
@@ -31,6 +31,8 @@ class GithubProvider {
   // limit. Inject `request` so we can pass in `cachingRequest` from
   // `request-handler.js`.
   request(request, url, query, callback) {
+    const { baseUrl } = this;
+
     let token;
     try {
       token = this.tokenForUri(url);
@@ -41,7 +43,7 @@ class GithubProvider {
 
     const options = {
       url,
-      baseUrl: this.baseUri,
+      baseUrl,
       qs: query,
       headers: {
         'User-Agent': 'Shields.io',
@@ -75,4 +77,4 @@ class GithubProvider {
   }
 }
 
-module.exports = GithubProvider;
+module.exports = GithubApiProvider;

lib/github-auth/github-provider.spec.js → lib/github-auth/github-api-provider.spec.js

@@ -2,7 +2,7 @@
 
 const { expect } = require('chai');
 const sinon = require('sinon');
-const GithubProvider = require('./github-provider');
+const GithubApiProvider = require('./github-api-provider');
 
 describe('Github API provider', function() {
   const baseUri = 'https://github-api.example.com';
@@ -16,7 +16,7 @@ describe('Github API provider', function() {
       nextToken: sinon.stub().returns(mockToken),
       nextSearchToken: sinon.stub().returns(mockSearchToken),
     };
-    provider = new GithubProvider(baseUri, mockTokenProvider);
+    provider = new GithubApiProvider(baseUri, mockTokenProvider);
     provider.reserveFraction = reserveFraction;
   });
 

lib/github-auth/github-constellation.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const path = require('path');
+const serverSecrets = require('../server-secrets');
+const log = require('../log');
+const {
+  StaticTokenProvider,
+  PoolingTokenProvider,
+} = require('./token-provider');
+const TokenPersistence = require('./token-persistence');
+const GithubApiProvider = require('./github-api-provider');
+const { setRoutes: setAcceptorRoutes } = require('./acceptor');
+const { setRoutes: setAdminRoutes } = require('./admin');
+
+// Convenience class with all the stuff related to the Github API and its
+// authorization tokens, to simplify server initialization.
+class GithubConstellation {
+  constructor(config) {
+    this._debugEnabled = config.service.debug.enabled;
+    this._debugIntervalSeconds = config.service.debug.intervalSeconds;
+    this._userTokensPath = path.resolve(
+      config.persistence.dir,
+      'github-user-tokens.json'
+    );
+
+    const globalTokenString = (serverSecrets || {}).gh_token;
+
+    if (globalTokenString) {
+      // When a global gh_token is configured, use that in place of our token
+      // pool. This produces more predictable behavior, and more predictable
+      // failures when that token is exhausted.
+      this.usingPooling = false;
+      this.coreTokenProvider = this.searchTokenProvider = new StaticTokenProvider(
+        globalTokenString
+      );
+    } else {
+      this.usingPooling = true;
+      this.coreTokenProvider = new PoolingTokenProvider();
+      this.searchTokenProvider = new PoolingTokenProvider();
+    }
+
+    const githubUrl = process.env.GITHUB_URL || 'https://api.github.com';
+    this.apiProvider = new GithubApiProvider(githubUrl, this.coreTokenProvider);
+  }
+
+  scheduleDebugLogging() {
+    if (this._debugEnabled) {
+      this.debugInterval = setInterval(() => {
+        if (this.coreTokenProvider) {
+          log('coreTokenProvider', this.coreTokenProvider.getTokenDebugInfo());
+        }
+        if (this.searchTokenProvider) {
+          log(
+            'searchTokenProvider',
+            this.searchTokenProvider.getTokenDebugInfo()
+          );
+        }
+      }, 1000 * this._debugIntervalSeconds);
+    }
+  }
+
+  async initialize(server) {
+    this.scheduleDebugLogging();
+
+    if (this.usingPooling) {
+      this.persistence = new TokenPersistence(
+        this.coreTokenProvider,
+        this._userTokensPath
+      );
+      await this.persistence.initialize();
+      this.coreTokenProvider
+        .toNative()
+        .forEach(t => this.searchTokenProvider.addToken(t));
+    }
+    // TODO Catch errors and send them to Sentry.
+
+    setAdminRoutes(this.coreTokenProvider, server);
+
+    if (serverSecrets && serverSecrets.gh_client_id) {
+      setAcceptorRoutes(this.coreTokenProvider, server);
+    }
+  }
+
+  stop() {
+    if (this.persistence) {
+      this.persistence.stop();
+    }
+    if (this.debugInterval) {
+      clearInterval(this.debugInterval);
+      this.debugInterval = undefined;
+    }
+  }
+}
+
+module.exports = GithubConstellation;

lib/github-provider.js

@@ -15,7 +15,7 @@ const {
 } = require('./color-formatters');
 
 // GitHub commits since integration.
-function mapGithubCommitsSince({ camp, cache }, githubProvider) {
+function mapGithubCommitsSince({ camp, cache }, githubApiProvider) {
   camp.route(/^\/github\/commits-since\/([^/]+)\/([^/]+)\/([^/]+)\.(svg|png|gif|jpg|json)$/,
     cache(function (data, match, sendBadge, request) {
       const user = match[1];  // eg, SubtitleEdit
@@ -29,7 +29,7 @@ function mapGithubCommitsSince({ camp, cache }, githubProvider) {
         if (badgeData.template === 'social') {
           badgeData.logo = getLogo('github', data);
         }
-        githubProvider.request(request, apiUrl, {}, (err, res, buffer) => {
+        githubApiProvider.request(request, apiUrl, {}, (err, res, buffer) => {
           if (err != null) {
             badgeData.text[1] = 'inaccessible';
             sendBadge(format, badgeData);
@@ -52,7 +52,7 @@ function mapGithubCommitsSince({ camp, cache }, githubProvider) {
 
       if (version === 'latest') {
         const url = `/repos/${user}/${repo}/releases/latest`;
-        githubProvider.request(request, url, {}, (err, res, buffer) => {
+        githubApiProvider.request(request, url, {}, (err, res, buffer) => {
           if (err != null) {
             badgeData.text[1] = 'inaccessible';
             sendBadge(format, badgeData);
@@ -73,7 +73,7 @@ function mapGithubCommitsSince({ camp, cache }, githubProvider) {
 }
 
 //Github Release & Pre-Release Date Integration release-date-pre (?:\/(all))?
-function mapGithubReleaseDate({ camp, cache }, githubProvider) {
+function mapGithubReleaseDate({ camp, cache }, githubApiProvider) {
   camp.route(/^\/github\/(release-date|release-date-pre)\/([^/]+)\/([^/]+)\.(svg|png|gif|jpg|json)$/,
     cache(function (data, match, sendBadge, request) {
       const releaseType = match[1]; // eg, release-date-pre / release-date
@@ -88,7 +88,7 @@ function mapGithubReleaseDate({ camp, cache }, githubProvider) {
       if (badgeData.template === 'social') {
         badgeData.logo = getLogo('github', data);
       }
-      githubProvider.request(request, apiUrl, {}, (err, res, buffer) => {
+      githubApiProvider.request(request, apiUrl, {}, (err, res, buffer) => {
         if (err != null) {
           badgeData.text[1] = 'inaccessible';
           sendBadge(format, badgeData);

lib/suggest.js

@@ -2,15 +2,14 @@
 
 const nodeUrl = require('url');
 const request = require('request');
-const { defaultProvider: githubProvider } = require('./github-auth');
 
 // data: {url}, JSON-serializable object.
 // end: function(json), with json of the form:
 //  - badges: list of objects of the form:
 //    - link: target as a string URL.
 //    - badge: shields image URL.
 //    - name: string
-function suggest (allowedOrigin, data, end, ask) {
+function suggest (allowedOrigin, githubApiProvider, data, end, ask) {
   // The typical dev and production setups are cross-origin. However, in
   // Heroku deploys and some self-hosted deploys these requests may come from
   // the same host.
@@ -29,12 +28,12 @@ function suggest (allowedOrigin, data, end, ask) {
   try {
     url = nodeUrl.parse(data.url);
   } catch(e) { end({err: ''+e}); return; }
-  findSuggestions(url, end);
+  findSuggestions(githubApiProvider, url, end);
 }
 
 // url: string
 // cb: function({badges})
-function findSuggestions (url, cb) {
+function findSuggestions (githubApiProvider, url, cb) {
   let promises = [];
   if (url.hostname === 'github.com') {
     const userRepo = url.pathname.slice(1).split('/');
@@ -96,10 +95,10 @@ function githubStars (user, repo) {
   });
 }
 
-function githubLicense (user, repo) {
+function githubLicense (githubApiProvider, user, repo) {
   return new Promise((resolve) => {
     const apiUrl = `/repos/${user}/${repo}/license`;
-    githubProvider.request(request, apiUrl, {}, function(err, res, buffer) {
+    githubApiProvider.request(request, apiUrl, {}, function(err, res, buffer) {
       if (err !== null) {
         resolve(null);
         return;
@@ -127,10 +126,10 @@ function githubLicense (user, repo) {
   });
 }
 
-function setRoutes (allowedOrigin, camp) {
-  camp.ajax.on(
+function setRoutes (allowedOrigin, githubApiProvider, server) {
+  server.ajax.on(
     'suggest/v1',
-    (data, end, ask) => suggest(allowedOrigin, data, end, ask));
+    (data, end, ask) => suggest(allowedOrigin, githubApiProvider, data, end, ask));
 }
 
 module.exports = {