TeaSpeak-Client/installer/deploy/index.ts
2019-10-26 01:51:40 +02:00

239 lines
8.5 KiB
TypeScript

import * as fs from "fs";
import * as path from "path";
import * as _node_ssh from "node-ssh";
import * as ssh2 from "ssh2";
import * as stream from "stream";
import * as child_process from "child_process";
import * as util from "util";
import {FileEntry} from "ssh2-streams";
declare namespace node_ssh {
export type PutFilesOptions = {
sftp?: Object,
sftpOptions?: Object,
concurrency?: number,
}
export type PutDirectoryOptions = {
sftp?: Object,
sftpOptions?: Object,
concurrency?: number,
recursive?: boolean,
tick?: ((localPath: string, remotePath: string, error?: Error) => void),
validate?: ((localPath: string) => boolean),
}
export type ExecOptions = {
cwd?: string,
options?: Object // passed to ssh2.exec
stdin?: string,
stream?: 'stdout' | 'stderr' | 'both',
onStdout?: ((chunk: Buffer) => void),
onStderr?: ((chunk: Buffer) => void),
}
export class Instance {
connect(config: ssh2.ConnectConfig): Promise<this>
requestSFTP(): Promise<ssh2.SFTPWrapper>
requestShell(): Promise<ssh2.ClientChannel>
mkdir(path: string, method: 'sftp' | 'exec', givenSftp?: Object): Promise<string>
exec(command: string, parameters: Array<string>, options: ExecOptions): Promise<Object | string>
execCommand(command: string, options?: { cwd: string, stdin: string }): Promise<{ stdout: string, options?: Object, stderr: string, signal?: string, code: number }>
putFile(localFile: string, remoteFile: string, sftp?: Object, opts?: Object): Promise<void>
getFile(localFile: string, remoteFile: string, sftp?: Object, opts?: Object): Promise<void>
putFiles(files: Array<{ local: string, remote: string }>, options: PutFilesOptions): Promise<void>
putDirectory(localDirectory: string, remoteDirectory: string, options: PutDirectoryOptions): Promise<boolean>
dispose(): void
}
}
let instance: node_ssh.Instance;
export async function setup() {
if(instance)
throw "already initiaized";
instance = new _node_ssh();
try {
await instance.connect({
host: 'deploy.teaspeak.de',
username: 'TeaSpeak-Jenkins-Client',
privateKey: path.join(__dirname, "ssh_key")
})
} catch(error) {
try { instance.dispose(); } finally { instance = undefined; }
console.error("Failed to connect: %o", error);
throw "failed to connect";
}
}
function read_stream_full(stream: stream.Readable) : Promise<Buffer> {
return new Promise((resolve, reject) => {
const buffers = [];
stream.on('data', buffer => buffers.push(buffer));
stream.on('end', () => resolve(Buffer.concat(buffers)));
stream.on('error', error => reject(error));
});
}
export type PlatformSpecs = {
system: 'linux' | 'windows' | 'osx';
arch: 'amd64' | 'x86';
type: 'indev' | 'debug' | 'optimized' | 'stable';
}
export type Version = {
major: number;
minor: number;
patch: number;
type?: 'indev' | 'beta';
}
//<system>/<arch>_<type>/
function platform_path(platform: PlatformSpecs) {
return platform.system + "/" + platform.arch + "_" + platform.type + "/";
}
function version_string(version: Version) {
return version.major + "." + version.minor + "." + version.patch + (version.type ? "-" + version.type : "");
}
export async function latest_version(platform: PlatformSpecs) {
const path = "versions/" + platform_path(platform);
if(!instance)
throw "Invalid instance";
const sftp = await instance.requestSFTP();
try {
if(!sftp)
throw "failed to request sftp";
try {
const data_stream = sftp.createReadStream(path + "latest");
const data = await read_stream_full(data_stream);
return data.toString();
} catch(error) {
if(error instanceof Error && error.message == "No such file")
return undefined;
console.log("Failed to receive last version: %o", error);
return undefined;
}
} finally {
if(sftp)
sftp.end();
}
}
export async function generate_build_index(platform: PlatformSpecs, version: Version) : Promise<number> {
const path = "versions/" + platform_path(platform);
const version_str = version_string(version);
if(!instance)
throw "Invalid instance";
const sftp = await instance.requestSFTP();
try {
if(!sftp)
throw "failed to request sftp";
try {
const files = await new Promise<FileEntry[]>((resolve, reject) => sftp.readdir(path, (error, result) => error ? reject(error) : resolve(result)));
const version_files = files.filter(e => e.filename.startsWith(version_str));
if(version_files.length == 0)
return 0;
let index = 1;
while(version_files.find(e => e.filename.toLowerCase() === version_str + "-" + index)) index++;
return index;
} catch(error) {
if(error instanceof Error && error.message == "No such file")
return 0;
console.log("Failed to receive versions list: %o", error);
return undefined;
}
} finally {
if(sftp)
sftp.end();
}
}
export type WinDbgFile = {
binary: string,
pdb: string;
};
export async function deploy_win_dbg_files(files: WinDbgFile[], version: Version, path?: string) : Promise<void> {
//symstore add /r /f .\*.node /s \\deploy.teaspeak.de\symbols /t "TeaClient-Windows-amd64" /v "x.y.z"
//symstore add /r /f .\*.* /s \\deploy.teaspeak.de\symbols /t "TeaClient-Windows-amd64" /v "1.0.0"
const server_path = typeof(path) === "string" && path ? path : "\\\\deploy.teaspeak.de\\symbols\\symbols";
const vstring = version_string(version);
const exec = util.promisify(child_process.exec);
for(const file of files) {
console.log("Deploying %s to %s", file, server_path);
let current_file;
try {
{
const result = await exec("symstore add /r /f " + file.binary + " /s " + server_path + " /t \"TeaClient-Windows-amd64\" /v \"" + vstring + "\"");
if(result.stdout)
console.log("Stdout: %s", result.stdout);
if(result.stderr)
console.log("Stderr: %s", result.stderr);
}
{
const result = await exec("symstore add /r /f " + file.pdb + " /s " + server_path + " /t \"TeaClient-Windows-amd64\" /v \"" + vstring + "\"");
if(result.stdout)
console.log("Stdout: %s", result.stdout);
if(result.stderr)
console.log("Stderr: %s", result.stderr);
}
} catch(error) {
if('killed' in error && 'code' in error) {
const perror: {
killed: boolean,
code: number,
signal: any,
cmd: string,
stdout: string,
stderr: string
} = error;
console.error("Failed to deploy %s file %s:", current_file, file);
console.log(" Code: %d", perror.code);
{
console.error(" Stdout: ");
for(const element of perror.stdout.split("\n"))
console.error(" %s", element);
}
{
console.error(" Stderr: ");
for(const element of perror.stderr.split("\n"))
console.error(" %s", element);
}
} else
console.error("Failed to deploy %s file %s: %o", current_file, file, error);
throw "deploy failed";
}
}
}
const test = async () => {
await setup();
console.log(await latest_version({
arch: 'amd64',
system: 'linux',
type: 'optimized'
}));
console.log(await generate_build_index({
arch: 'amd64',
system: 'linux',
type: 'optimized'
}, {
type: 'beta',
patch: 19,
minor: 3,
major: 1
}));
/*
console.log(await deploy_pdb_files(
[path.join(__dirname, "..", "..", "native", "build", "symbols", "teaclient_crash_handler.pdb")], {
type: 'beta',
patch: 19,
minor: 3,
major: 1
}
))
*/
};
test();