Grdowns/update channel4 (#2576)

* Remove redundant error telemetry
* Check rate limit before attempting to download release JSON

Author: grdowns

Extension/src/LanguageServer/extension.ts

@@ -339,7 +339,6 @@ async function checkAndApplyUpdate(updateChannel: string): Promise<void> {
             });
         }, (error: Error) => {
             // Handle getTargetBuildInfo rejection
-            logFailure(error);
             reject(error);
         });
     });

Extension/src/common.ts

@@ -620,4 +620,37 @@ export function downloadFileToDestination(urlStr: string, destinationPath: strin
         request.on('error', (error) => { reject(); });
         request.end();
     });
+}
+
+export function downloadFileToStr(urlStr: string, headers?: OutgoingHttpHeaders): Promise<any> {
+    return new Promise<string>((resolve, reject) => {
+        let parsedUrl: url.Url = url.parse(urlStr);
+        let request: ClientRequest = https.request({
+            host: parsedUrl.host,
+            path: parsedUrl.path,
+            agent: getHttpsProxyAgent(),
+            rejectUnauthorized: vscode.workspace.getConfiguration().get('http.proxyStrictSSL', true),
+            headers: headers
+        }, (response) => {
+            if (response.statusCode === 301 || response.statusCode === 302) { // If redirected
+                // Download from new location
+                let redirectUrl: string;
+                if (typeof response.headers.location === 'string') {
+                    redirectUrl = response.headers.location;
+                } else {
+                    redirectUrl = response.headers.location[0];
+                }
+                return resolve(downloadFileToStr(redirectUrl, headers));
+            }
+            if (response.statusCode !== 200) { // If request is not successful
+                return reject();
+            }
+            let downloadedData: string = '';
+            response.on('data', (data) => { downloadedData += data; });
+            response.on('error', (error) => { reject(); });
+            response.on('end', () => { resolve(downloadedData); });
+        });
+        request.on('error', (error) => { reject(); });
+        request.end();
+    });
 }

Extension/src/githubAPI.ts

@@ -6,7 +6,6 @@
 
 import { PackageVersion } from './packageVersion';
 import * as util from './common';
-import * as tmp from 'tmp';
 import { PlatformInformation } from './platform';
 import { OutgoingHttpHeaders } from 'http';
 
@@ -177,47 +176,74 @@ function getTargetBuild(builds: Build[], updateChannel: string): Build {
     return needsUpdate(userVersion, targetVersion) ? targetBuild : undefined;
 }
 
+interface Rate {
+    remaining: number;
+}
+
+interface RateLimit {
+    rate: Rate;
+}
+
+function isRate(input: any): input is Rate {
+    return input && input.remaining && util.isNumber(input.remaining);
+}
+
+function isRateLimit(input: any): input is RateLimit {
+    return input && isRate(input.rate);
+}
+
+async function getRateLimit(): Promise<RateLimit> {
+    const header: OutgoingHttpHeaders = { 'User-Agent': 'vscode-cpptools' };
+    const data: string = await util.downloadFileToStr('https://api.github.com/rate_limit', header)
+        .catch(() => { throw new Error('Failed to download rate limit JSON'); });
+
+    let rateLimit: any;
+    try {
+        rateLimit = JSON.parse(data);
+    } catch (error) {
+        throw new Error('Failed to parse rate limit JSON');
+    }
+
+    if (isRateLimit(rateLimit)) {
+        return Promise.resolve(rateLimit);
+    } else {
+        throw new Error('Rate limit JSON is not of type RateLimit');
+    }
+}
+
+async function rateLimitExceeded(): Promise<boolean> {
+    const rateLimit: RateLimit = await getRateLimit();
+    return rateLimit.rate.remaining <= 0;
+}
+
 /**
  * Download and parse the release list JSON from the GitHub API into a Build[].
  * @return Information about the released builds of the C/C++ extension.
  */
 async function getReleaseJson(): Promise<Build[]> {
-    return new Promise<Build[]>((resolve, reject) => {
-        // Create temp file to hold JSON
-        tmp.file(async (err, releaseJsonPath, fd, cleanupCallback) => {
-            if (err) {
-                reject(new Error('Failed to create release json file'));
-                return;
-            }
+    if (await rateLimitExceeded()) {
+        throw new Error('Failed to stay within GitHub API rate limit');
+    }
 
-            try {
-                // Download release JSON
-                const releaseUrl: string = 'https://api.github.com/repos/Microsoft/vscode-cpptools/releases';
-                const header: OutgoingHttpHeaders = { 'User-Agent': 'vscode-cpptools' };
-                await util.downloadFileToDestination(releaseUrl, releaseJsonPath, header)
-                    .catch(() => { throw new Error('Failed to download release JSON'); });
-
-                // Read the release JSON file
-                const fileContent: string = await util.readFileText(releaseJsonPath)
-                    .catch(() => { throw new Error('Failed to read release JSON file'); } );
-
-                // Parse the file
-                let releaseJson: any;
-                try {
-                    releaseJson = JSON.parse(fileContent);
-                } catch (error) {
-                    throw new Error('Failed to parse release JSON');
-                }
+    // Download release JSON
+    const releaseUrl: string = 'https://api.github.com/repos/Microsoft/vscode-cpptools/releases';
+    const header: OutgoingHttpHeaders = { 'User-Agent': 'vscode-cpptools' };
 
-                // Type check
-                if (isArrayOfBuilds(releaseJson)) {
-                    resolve(releaseJson);
-                } else {
-                    reject(releaseJson);
-                }
-            } catch (error) {
-                reject(error);
-            }
-        });
-    });
+    const data: string = await util.downloadFileToStr(releaseUrl, header)
+        .catch(() => { throw new Error('Failed to download release JSON'); });
+
+    // Parse the file
+    let releaseJson: any;
+    try {
+        releaseJson = JSON.parse(data);
+    } catch (error) {
+        throw new Error('Failed to parse release JSON');
+    }
+
+    // Type check
+    if (isArrayOfBuilds(releaseJson)) {
+        return releaseJson;
+    } else {
+        throw new Error('Release JSON is not of type Build[]');
+    }
 }