Remove network functions

1 files changed, 0 insertions, 228 deletions

diff --git a/editors/code/src/net.ts b/editors/code/src/net.ts
deleted file mode 100644
index bd1bb5f8a8a..00000000000
--- a/editors/code/src/net.ts
+++ /dev/null
@@ -1,228 +0,0 @@
-import fetch from "node-fetch";
-var HttpsProxyAgent = require('https-proxy-agent');
-
-import * as vscode from "vscode";
-import * as stream from "stream";
-import * as crypto from "crypto";
-import * as fs from "fs";
-import * as zlib from "zlib";
-import * as util from "util";
-import * as path from "path";
-import { log, assert } from "./util";
-import * as https from "https";
-import { ProxySettings } from "./config";
-
-const pipeline = util.promisify(stream.pipeline);
-
-const GITHUB_API_ENDPOINT_URL = "https://api.github.com";
-const OWNER = "rust-analyzer";
-const REPO = "rust-analyzer";
-
-function makeHttpAgent(proxy: string | null | undefined, options?: https.AgentOptions) {
-    if (proxy) {
-        return new HttpsProxyAgent({ ...options, ...new URL(proxy) });
-    } else {
-        return new https.Agent(options);
-    }
-}
-
-export async function fetchRelease(
-    releaseTag: string,
-    githubToken: string | null | undefined,
-    proxySettings: ProxySettings,
-): Promise<GithubRelease> {
-
-    const apiEndpointPath = `/repos/${OWNER}/${REPO}/releases/tags/${releaseTag}`;
-
-    const requestUrl = GITHUB_API_ENDPOINT_URL + apiEndpointPath;
-
-    log.debug("Issuing request for released artifacts metadata to", requestUrl);
-
-    const headers: Record<string, string> = { Accept: "application/vnd.github.v3+json" };
-    if (githubToken != null) {
-        headers.Authorization = "token " + githubToken;
-    }
-
-    const response = await (() => {
-        if (proxySettings.proxy) {
-            log.debug(`Fetching release metadata via proxy: ${proxySettings.proxy}`);
-        }
-        const options: any = {};
-        if (proxySettings.strictSSL) {
-            options["rejectUnauthorized"] = false;
-        }
-        const agent = makeHttpAgent(proxySettings.proxy, options);
-        return fetch(requestUrl, { headers: headers, agent: agent });
-    })();
-
-    if (!response.ok) {
-        log.error("Error fetching artifact release info", {
-            requestUrl,
-            releaseTag,
-            response: {
-                headers: response.headers,
-                status: response.status,
-                body: await response.text(),
-            }
-        });
-
-        throw new Error(
-            `Got response ${response.status} when trying to fetch ` +
-            `release info for ${releaseTag} release`
-        );
-    }
-
-    // We skip runtime type checks for simplicity (here we cast from `unknown` to `GithubRelease`)
-    const release = await response.json() as GithubRelease;
-    return release;
-}
-
-// We omit declaration of tremendous amount of fields that we are not using here
-export interface GithubRelease {
-    name: string;
-    id: number;
-    // eslint-disable-next-line camelcase
-    published_at: string;
-    assets: Array<{
-        name: string;
-        // eslint-disable-next-line camelcase
-        browser_download_url: vscode.Uri;
-    }>;
-}
-
-interface DownloadOpts {
-    progressTitle: string;
-    url: vscode.Uri;
-    dest: vscode.Uri;
-    mode?: number;
-    gunzip?: boolean;
-    proxySettings: ProxySettings;
-}
-
-export async function download(opts: DownloadOpts) {
-    // Put artifact into a temporary file (in the same dir for simplicity)
-    // to prevent partially downloaded files when user kills vscode
-    // This also avoids overwriting running executables
-    const randomHex = crypto.randomBytes(5).toString("hex");
-    const rawDest = path.parse(opts.dest.fsPath);
-    const oldServerPath = vscode.Uri.joinPath(vscode.Uri.file(rawDest.dir), `${rawDest.name}-stale-${randomHex}${rawDest.ext}`);
-    const tempFilePath = vscode.Uri.joinPath(vscode.Uri.file(rawDest.dir), `${rawDest.name}${randomHex}`);
-
-    await vscode.window.withProgress(
-        {
-            location: vscode.ProgressLocation.Notification,
-            cancellable: false,
-            title: opts.progressTitle
-        },
-        async (progress, _cancellationToken) => {
-            let lastPercentage = 0;
-            await downloadFile(opts.url, tempFilePath, opts.mode, !!opts.gunzip, opts.proxySettings, (readBytes, totalBytes) => {
-                const newPercentage = Math.round((readBytes / totalBytes) * 100);
-                if (newPercentage !== lastPercentage) {
-                    progress.report({
-                        message: `${newPercentage.toFixed(0)}%`,
-                        increment: newPercentage - lastPercentage
-                    });
-
-                    lastPercentage = newPercentage;
-                }
-            });
-        }
-    );
-
-    // Try to rename a running server to avoid EPERM on Windows
-    // NB: this can lead to issues if a running Code instance tries to restart the server.
-    try {
-        await vscode.workspace.fs.rename(opts.dest, oldServerPath, { overwrite: true });
-        log.info(`Renamed old server binary ${opts.dest.fsPath} to ${oldServerPath.fsPath}`);
-    } catch (err) {
-        const fsErr = err as vscode.FileSystemError;
-
-        // This is supposed to return `FileNotFound` (spelled as `EntryNotFound`)
-        // but instead `code` is `Unknown` and `name` is `EntryNotFound (FileSystemError) (FileSystemError)`.
-        // https://github.com/rust-analyzer/rust-analyzer/pull/10222
-        if (!fsErr.code || fsErr.code !== "EntryNotFound" && fsErr.name.indexOf("EntryNotFound") === -1) {
-            log.error(`Cannot rename existing server instance: ${err}"`);
-        }
-    }
-    try {
-        await vscode.workspace.fs.rename(tempFilePath, opts.dest, { overwrite: true });
-    } catch (err) {
-        log.error(`Cannot update server binary: ${err}`);
-    }
-
-    // Now try to remove any stale server binaries
-    const serverDir = vscode.Uri.file(rawDest.dir);
-    try {
-        const entries = await vscode.workspace.fs.readDirectory(serverDir);
-        for (const [entry, _] of entries) {
-            try {
-                if (entry.includes(`${rawDest.name}-stale-`)) {
-                    const uri = vscode.Uri.joinPath(serverDir, entry);
-                    try {
-                        await vscode.workspace.fs.delete(uri);
-                        log.info(`Removed old server binary ${uri.fsPath}`);
-                    } catch (err) {
-                        log.error(`Unable to remove old server binary ${uri.fsPath}`);
-                    }
-                }
-            } catch (err) {
-                log.error(`Unable to parse ${entry}`);
-            }
-        }
-    } catch (err) {
-        log.error(`Unable to enumerate contents of ${serverDir.fsPath}`);
-    }
-}
-
-async function downloadFile(
-    url: vscode.Uri,
-    destFilePath: vscode.Uri,
-    mode: number | undefined,
-    gunzip: boolean,
-    proxySettings: ProxySettings,
-    onProgress: (readBytes: number, totalBytes: number) => void
-): Promise<void> {
-    const urlString = url.toString();
-
-    const res = await (() => {
-        if (proxySettings.proxy) {
-            log.debug(`Downloading ${urlString} via proxy: ${proxySettings.proxy}`);
-        }
-        const options: any = {};
-        if (proxySettings.strictSSL) {
-            options["rejectUnauthorized"] = false;
-        }
-        const agent = makeHttpAgent(proxySettings.proxy, options);
-        return fetch(urlString, { agent: agent });
-    })();
-
-    if (!res.ok) {
-        log.error("Error", res.status, "while downloading file from", urlString);
-        log.error({ body: await res.text(), headers: res.headers });
-
-        throw new Error(`Got response ${res.status} when trying to download a file.`);
-    }
-
-    if (!res.body) {
-        log.error("Empty body while downloading file from", urlString);
-        log.error({ headers: res.headers });
-        throw new Error(`Got empty body when trying to download a file.`);
-    }
-
-    const totalBytes = Number(res.headers.get('content-length'));
-    assert(!Number.isNaN(totalBytes), "Sanity check of content-length protocol");
-
-    log.debug("Downloading file of", totalBytes, "bytes size from", urlString, "to", destFilePath.fsPath);
-
-    let readBytes = 0;
-    res.body.on("data", (chunk: Buffer) => {
-        readBytes += chunk.length;
-        onProgress(readBytes, totalBytes);
-    });
-
-    const destFileStream = fs.createWriteStream(destFilePath.fsPath, { mode });
-    const srcStream = gunzip ? res.body.pipe(zlib.createGunzip()) : res.body;
-
-    await pipeline(srcStream, destFileStream);
-}