GitTools/actions
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

split the common.ts into several files

Browse Source
This commit is contained in:
Artur Stolear
2020-02-07 22:18:42 +02:00
parent 237764149f
commit 7dee6ba225
20 changed files with 2354 additions and 1468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

248
src/core/common.ts
View File

@@ -1,23 +1,21 @@
export const TYPES = {
IBuildAgent: Symbol.for("BuildAgent"),
IDotnetTool: Symbol.for("DotnetTool"),
IGitVersionTool: Symbol.for("GitVersionTool"),
IGitReleaseManagerTool: Symbol.for("GitReleaseManagerTool"),
IVersionManager: Symbol.for("VersionManager"),
};
import * as fs from "fs";
import * as os from "os";
import * as path from "path";
import * as semver from "semver";
import * as http from "typed-rest-client/HttpClient";
export const SetupOptions = {
includePrerelease: "includePrerelease",
versionSpec: "versionSpec",
};
import cmp from "semver-compare";
import { inject, injectable } from "inversify";
import { BuildAgent } from "../agent/mock/build-agent";
import { Container } from "inversify";
const container = new Container();
export interface IVersionManager {
isExplicitVersion(versionSpec: string): boolean;
evaluateVersions(versions: string[], versionSpec: string): string;
cleanVersion(version: string): string;
export interface IExecResult {
stdout: string;
stderr: string;
code: number;
error: Error;
}
export interface IBuildAgent {
@@ -42,216 +40,4 @@ export interface IBuildAgent {
setOutput(name: string, value: string): void;
getInput(input: string, required?: boolean): string;
getBooleanInput(input: string, required?: boolean): boolean;
}
export interface IDotnetTool {
run(args: string[]): Promise<IExecResult>;
toolInstall(toolName: string, versionSpec: string, checkLatest: boolean, includePre: boolean): Promise<string>;
}
export interface IExecResult {
stdout: string;
stderr: string;
code: number;
error: Error;
}
export const TYPES = {
IBuildAgent: Symbol.for("BuildAgent"),
IDotnetTool: Symbol.for("DotnetTool"),
IGitVersionTool: Symbol.for("GitVersionTool"),
IGitReleaseManagerTool: Symbol.for("GitReleaseManagerTool"),
IVersionManager: Symbol.for("VersionManager"),
};
export const SetupOptions = {
includePrerelease: "includePrerelease",
versionSpec: "versionSpec",
};
@injectable()
class DotnetTool implements IDotnetTool {
private buildAgent: IBuildAgent;
private versionManager: IVersionManager;
private httpClient: http.HttpClient;
constructor(
@inject(TYPES.IBuildAgent) buildAgent: IBuildAgent,
@inject(TYPES.IVersionManager) versionManager: IVersionManager,
) {
this.buildAgent = buildAgent;
this.versionManager = versionManager;
this.httpClient = new http.HttpClient("dotnet");
}
public run(args: string[]): Promise<IExecResult> {
return this.buildAgent.exec("dotnet", args);
}
public async toolInstall(toolName: string, versionSpec: string, checkLatest: boolean, includePre: boolean)
: Promise<string> {
console.log("");
console.log("--------------------------");
console.log(`Installing ${toolName} version ` + versionSpec);
console.log("--------------------------");
if (this.versionManager.isExplicitVersion(versionSpec)) {
checkLatest = false; // check latest doesn't make sense when explicit version
}
let toolPath: string;
if (!checkLatest) {
//
// Let's try and resolve the version spec locally first
//
toolPath = this.buildAgent.find(toolName, versionSpec);
}
if (!toolPath) {
let version: string;
if (this.versionManager.isExplicitVersion(versionSpec)) {
//
// Explicit version was specified. No need to query for list of versions.
//
version = versionSpec;
} else {
//
// Let's query and resolve the latest version for the versionSpec.
// If the version is an explicit version (1.1.1 or v1.1.1) then no need to query.
// If your tool doesn't offer a mechanism to query,
// then it can only support exact version inputs.
//
version = await this.queryLatestMatch(toolName, versionSpec, includePre);
if (!version) {
throw new Error(`Unable to find ${toolName} version '${versionSpec}'.`);
}
//
// Check the cache for the resolved version.
//
toolPath = this.buildAgent.find(toolName, version);
}
if (!toolPath) {
//
// Download, extract, cache
//
toolPath = await this.acquireTool(toolName, version);
}
}
//
// Prepend the tools path. This prepends the PATH for the current process and
// instructs the agent to prepend for each task that follows.
//
this.buildAgent.debug(`toolPath: ${toolPath}`);
if (os.platform() !== "win32") {
const dotnetRoot = path.dirname(fs.readlinkSync(await this.buildAgent.which("dotnet")));
this.buildAgent.exportVariable("DOTNET_ROOT", dotnetRoot);
}
this.buildAgent.addPath(toolPath);
return toolPath;
}
private async queryLatestMatch(toolName: string, versionSpec: string, includePrerelease: boolean): Promise<string> {
this.buildAgent.debug(`querying tool versions for ${toolName}${versionSpec ? `@${versionSpec}` : ""} ${includePrerelease ? "including pre-releases" : ""}`);
const downloadPath = `https://api-v2v3search-0.nuget.org/query?q=${encodeURIComponent(toolName.toLowerCase())}&prerelease=${includePrerelease ? "true" : "false"}&semVerLevel=2.0.0`;
const res = await this.httpClient.get(downloadPath);
if (!res || res.message.statusCode !== 200) {
return null;
}
const body: string = await res.readBody();
const data = JSON.parse(body).data;
const versions = (data[0].versions as { version: string }[]).map((x) => x.version);
if (!versions || !versions.length) {
return null;
}
this.buildAgent.debug(`got versions: ${versions.join(", ")}`);
return this.versionManager.evaluateVersions(versions, versionSpec);
}
private async acquireTool(toolName: string, version: string): Promise<string> {
const tempDirectory = await this.buildAgent.createTempDir();
let args = ["tool", "install", toolName, "--tool-path", tempDirectory];
if (version) {
version = this.versionManager.cleanVersion(version);
args = args.concat(["--version", version]);
}
const result = await this.run(args);
const status = result.code === 0 ? "success" : "failure";
const message = result.code === 0 ? result.stdout : result.stderr;
this.buildAgent.debug(`tool install result: ${status} ${message}`);
if (result.code) {
throw new Error("Error installing tool");
}
return await this.buildAgent.cacheDir(tempDirectory, toolName, version);
}
}
@injectable()
class VersionManager implements IVersionManager {
private buildAgent: IBuildAgent;
constructor(
@inject(TYPES.IBuildAgent) buildAgent: IBuildAgent,
) {
this.buildAgent = buildAgent;
}
public isExplicitVersion(versionSpec: string): boolean {
const c = semver.clean(versionSpec);
this.buildAgent.debug("isExplicit: " + c);
const valid = semver.valid(c) != null;
this.buildAgent.debug("explicit? " + valid);
return valid;
}
public evaluateVersions(versions: string[], versionSpec: string): string {
let version: string;
this.buildAgent.debug("evaluating " + versions.length + " versions");
versions = versions.sort(cmp);
for (let i = versions.length - 1; i >= 0; i--) {
const potential: string = versions[i];
const satisfied: boolean = semver.satisfies(potential, versionSpec);
if (satisfied) {
version = potential;
break;
}
}
if (version) {
this.buildAgent.debug("matched: " + version);
} else {
this.buildAgent.debug("match not found");
}
return version;
}
public cleanVersion(version: string): string {
this.buildAgent.debug("cleaning: " + version);
return semver.clean(version);
}
}
container.bind<IVersionManager>(TYPES.IVersionManager).to(VersionManager);
container.bind<IBuildAgent>(TYPES.IBuildAgent).to(BuildAgent);
container.bind<IDotnetTool>(TYPES.IDotnetTool).to(DotnetTool);
export { container };
}

146
src/core/dotnet-tool.ts Normal file
View File

@@ -0,0 +1,146 @@
import * as fs from "fs";
import * as os from "os";
import * as path from "path";
import * as http from "typed-rest-client/HttpClient";
import { inject, injectable } from "inversify";
import { TYPES, IExecResult, IBuildAgent } from "./common";
import { IVersionManager } from "./versionManager";
export interface IDotnetTool {
run(args: string[]): Promise<IExecResult>;
toolInstall(toolName: string, versionSpec: string, checkLatest: boolean, includePre: boolean): Promise<string>;
}
@injectable()
export class DotnetTool implements IDotnetTool {
private buildAgent: IBuildAgent;
private versionManager: IVersionManager;
private httpClient: http.HttpClient;
constructor(
@inject(TYPES.IBuildAgent) buildAgent: IBuildAgent,
@inject(TYPES.IVersionManager) versionManager: IVersionManager,
) {
this.buildAgent = buildAgent;
this.versionManager = versionManager;
this.httpClient = new http.HttpClient("dotnet");
}
public run(args: string[]): Promise<IExecResult> {
return this.buildAgent.exec("dotnet", args);
}
public async toolInstall(toolName: string, versionSpec: string, checkLatest: boolean, includePre: boolean)
: Promise<string> {
console.log("");
console.log("--------------------------");
console.log(`Installing ${toolName} version ` + versionSpec);
console.log("--------------------------");
if (this.versionManager.isExplicitVersion(versionSpec)) {
checkLatest = false; // check latest doesn't make sense when explicit version
}
let toolPath: string;
if (!checkLatest) {
//
// Let's try and resolve the version spec locally first
//
toolPath = this.buildAgent.find(toolName, versionSpec);
}
if (!toolPath) {
let version: string;
if (this.versionManager.isExplicitVersion(versionSpec)) {
//
// Explicit version was specified. No need to query for list of versions.
//
version = versionSpec;
} else {
//
// Let's query and resolve the latest version for the versionSpec.
// If the version is an explicit version (1.1.1 or v1.1.1) then no need to query.
// If your tool doesn't offer a mechanism to query,
// then it can only support exact version inputs.
//
version = await this.queryLatestMatch(toolName, versionSpec, includePre);
if (!version) {
throw new Error(`Unable to find ${toolName} version '${versionSpec}'.`);
}
//
// Check the cache for the resolved version.
//
toolPath = this.buildAgent.find(toolName, version);
}
if (!toolPath) {
//
// Download, extract, cache
//
toolPath = await this.acquireTool(toolName, version);
}
}
//
// Prepend the tools path. This prepends the PATH for the current process and
// instructs the agent to prepend for each task that follows.
//
this.buildAgent.debug(`toolPath: ${toolPath}`);
if (os.platform() !== "win32") {
const dotnetRoot = path.dirname(fs.readlinkSync(await this.buildAgent.which("dotnet")));
this.buildAgent.exportVariable("DOTNET_ROOT", dotnetRoot);
}
this.buildAgent.addPath(toolPath);
return toolPath;
}
private async queryLatestMatch(toolName: string, versionSpec: string, includePrerelease: boolean): Promise<string> {
this.buildAgent.debug(`querying tool versions for ${toolName}${versionSpec ? `@${versionSpec}` : ""} ${includePrerelease ? "including pre-releases" : ""}`);
const downloadPath = `https://api-v2v3search-0.nuget.org/query?q=${encodeURIComponent(toolName.toLowerCase())}&prerelease=${includePrerelease ? "true" : "false"}&semVerLevel=2.0.0`;
const res = await this.httpClient.get(downloadPath);
if (!res || res.message.statusCode !== 200) {
return null;
}
const body: string = await res.readBody();
const data = JSON.parse(body).data;
const versions = (data[0].versions as { version: string }[]).map((x) => x.version);
if (!versions || !versions.length) {
return null;
}
this.buildAgent.debug(`got versions: ${versions.join(", ")}`);
return this.versionManager.evaluateVersions(versions, versionSpec);
}
private async acquireTool(toolName: string, version: string): Promise<string> {
const tempDirectory = await this.buildAgent.createTempDir();
let args = ["tool", "install", toolName, "--tool-path", tempDirectory];
if (version) {
version = this.versionManager.cleanVersion(version);
args = args.concat(["--version", version]);
}
const result = await this.run(args);
const status = result.code === 0 ? "success" : "failure";
const message = result.code === 0 ? result.stdout : result.stderr;
this.buildAgent.debug(`tool install result: ${status} ${message}`);
if (result.code) {
throw new Error("Error installing tool");
}
return await this.buildAgent.cacheDir(tempDirectory, toolName, version);
}
}

23
src/core/gitreleasemanager.ts
View File

@@ -1,23 +0,0 @@
import { IDotnetTool, IBuildAgent, TYPES } from "./common";
import { injectable, inject } from "inversify";
export interface IGitReleaseManagerTool {
install(versionSpec: string, includePrerelease: boolean): Promise<void>;
}
@injectable()
export class GitReleaseManagerTool implements IGitReleaseManagerTool {
private dotnetTool: IDotnetTool;
constructor(
@inject(TYPES.IBuildAgent) buildAgent: IBuildAgent,
@inject(TYPES.IDotnetTool) dotnetTool: IDotnetTool,
) {
this.dotnetTool = dotnetTool;
}
public async install(versionSpec: string, includePrerelease: boolean): Promise<void> {
await this.dotnetTool.toolInstall("GitReleaseManager.Tool", versionSpec, false, includePrerelease);
}
}

201
src/core/gitversion.ts
View File

@@ -1,201 +0,0 @@
import { IBuildAgent, IDotnetTool, IExecResult, TYPES } from "./common";
import { injectable, inject } from "inversify";
import path = require("path");
export interface IGitVersionArguments {
targetPath: string;
useConfigFile: boolean;
configFilePath: string;
updateAssemblyInfo: boolean;
updateAssemblyInfoFilename: string;
additionalArguments: string;
srcDir: string;
}
export const GitVersionRunOptions = {
targetPath: "targetPath",
useConfigFile: "useConfigFile",
configFilePath: "configFilePath",
updateAssemblyInfo: "configFilePath",
updateAssemblyInfoFilename: "configFilePath",
additionalArguments: "additionalArguments",
};
export interface IGitVersion {
Major: number;
Minor: number;
Patch: number;
PreReleaseTag: string;
PreReleaseTagWithDash: string;
PreReleaseLabel: string;
PreReleaseNumber: number;
WeightedPreReleaseNumber: number;
BuildMetaData: number;
BuildMetaDataPadded: string;
FullBuildMetaData: string;
MajorMinorPatch: string;
SemVer: string;
LegacySemVer: string;
LegacySemVerPadded: string;
AssemblySemVer: string;
AssemblySemFileVer: string;
FullSemVer: string;
InformationalVersion: string;
BranchName: string;
Sha: string;
ShortSha: string;
NuGetVersionV2: string;
NuGetVersion: string;
NuGetPreReleaseTagV2: string;
NuGetPreReleaseTag: string;
VersionSourceSha: string;
CommitsSinceVersionSource: number;
CommitsSinceVersionSourcePadded: string;
CommitDate: string;
}
export interface IGitVersionTool {
install(versionSpec: string, includePrerelease: boolean): Promise<void>;
run(options: IGitVersionArguments): Promise<IExecResult>;
writeGitVersionToAgent(gitversion: IGitVersion): void;
getGitVersionOptions(): IGitVersionArguments;
}
@injectable()
export class GitVersionTool implements IGitVersionTool {
private buildAgent: IBuildAgent;
private dotnetTool: IDotnetTool;
constructor(
@inject(TYPES.IBuildAgent) buildAgent: IBuildAgent,
@inject(TYPES.IDotnetTool) dotnetTool: IDotnetTool,
) {
this.buildAgent = buildAgent;
this.dotnetTool = dotnetTool;
}
public async install(versionSpec: string, includePrerelease: boolean): Promise<void> {
await this.dotnetTool.toolInstall("GitVersion.Tool", versionSpec, false, includePrerelease);
}
public run(options: IGitVersionArguments): Promise<IExecResult> {
const workDir = this.getRepoDir(options.targetPath);
const args = this.getArguments(workDir, options);
return this.buildAgent.exec("dotnet-gitversion", args);
}
private getRepoDir(targetPath: string): string {
let workDir: string;
const srcDir = this.buildAgent.getSourceDir();
if (!targetPath) {
workDir = srcDir;
} else {
if (this.buildAgent.directoryExists(targetPath)) {
workDir = path.join(srcDir, targetPath);
} else {
throw new Error("Directory not found at " + targetPath);
}
}
return workDir.replace(/\\/g, "/");
}
private getArguments(workDir: string, options: IGitVersionArguments): string[] {
const args = [
workDir,
"/output",
"json", // need to use buildserver later
];
const {
useConfigFile,
configFilePath,
updateAssemblyInfo,
updateAssemblyInfoFilename,
additionalArguments,
} = options;
if (useConfigFile) {
if (this.buildAgent.isValidInputFile("configFilePath", configFilePath)) {
args.push("/config", configFilePath);
} else {
throw new Error("GitVersion configuration file not found at " + configFilePath);
}
}
if (updateAssemblyInfo) {
args.push("/updateassemblyinfo");
if (this.buildAgent.isValidInputFile("updateAssemblyInfoFilename", updateAssemblyInfoFilename)) {
args.push(updateAssemblyInfoFilename);
} else {
throw new Error("AssemblyInfoFilename file not found at " + updateAssemblyInfoFilename);
}
}
args.push(additionalArguments);
return args;
}
public getGitVersionOptions(): IGitVersionArguments {
const targetPath = this.buildAgent.getInput(GitVersionRunOptions.targetPath);
const useConfigFile = this.buildAgent.getBooleanInput(GitVersionRunOptions.useConfigFile);
const configFilePath = this.buildAgent.getInput(GitVersionRunOptions.configFilePath);
const updateAssemblyInfo = this.buildAgent.getBooleanInput(GitVersionRunOptions.updateAssemblyInfo);
const updateAssemblyInfoFilename = this.buildAgent.getInput(GitVersionRunOptions.updateAssemblyInfoFilename);
const additionalArguments = this.buildAgent.getInput(GitVersionRunOptions.additionalArguments);
const srcDir = this.buildAgent.getSourceDir().replace(/\\/g, "/");
return {
targetPath,
useConfigFile,
configFilePath,
updateAssemblyInfo,
updateAssemblyInfoFilename,
additionalArguments,
srcDir,
};
}
public writeGitVersionToAgent(gitversion: IGitVersion): void {
this.buildAgent.setOutput("major", gitversion.Major.toString());
this.buildAgent.setOutput("minor", gitversion.Minor.toString());
this.buildAgent.setOutput("patch", gitversion.Patch.toString());
this.buildAgent.setOutput("preReleaseTag", gitversion.PreReleaseTag);
this.buildAgent.setOutput("preReleaseTagWithDash", gitversion.PreReleaseTagWithDash);
this.buildAgent.setOutput("preReleaseLabel", gitversion.PreReleaseLabel);
this.buildAgent.setOutput("preReleaseNumber", gitversion.PreReleaseNumber.toString());
this.buildAgent.setOutput("weightedPreReleaseNumber", gitversion.WeightedPreReleaseNumber.toString());
this.buildAgent.setOutput("buildMetaData", gitversion.BuildMetaData.toString());
this.buildAgent.setOutput("buildMetaDataPadded", gitversion.BuildMetaDataPadded);
this.buildAgent.setOutput("fullBuildMetaData", gitversion.FullBuildMetaData);
this.buildAgent.setOutput("majorMinorPatch", gitversion.MajorMinorPatch);
this.buildAgent.setOutput("semVer", gitversion.SemVer);
this.buildAgent.setOutput("legacySemVer", gitversion.LegacySemVer);
this.buildAgent.setOutput("legacySemVerPadded", gitversion.LegacySemVerPadded);
this.buildAgent.setOutput("assemblySemVer", gitversion.AssemblySemVer);
this.buildAgent.setOutput("assemblySemFileVer", gitversion.AssemblySemFileVer);
this.buildAgent.setOutput("fullSemVer", gitversion.FullSemVer);
this.buildAgent.setOutput("informationalVersion", gitversion.InformationalVersion);
this.buildAgent.setOutput("branchName", gitversion.BranchName);
this.buildAgent.setOutput("sha", gitversion.Sha);
this.buildAgent.setOutput("shortSha", gitversion.ShortSha);
this.buildAgent.setOutput("nuGetVersionV2", gitversion.NuGetVersionV2);
this.buildAgent.setOutput("nuGetVersion", gitversion.NuGetVersion);
this.buildAgent.setOutput("nuGetPreReleaseTagV2", gitversion.NuGetPreReleaseTagV2);
this.buildAgent.setOutput("nuGetPreReleaseTag", gitversion.NuGetPreReleaseTag);
this.buildAgent.setOutput("versionSourceSha", gitversion.VersionSourceSha);
this.buildAgent.setOutput("commitsSinceVersionSource", gitversion.CommitsSinceVersionSource.toString());
this.buildAgent.setOutput("commitsSinceVersionSourcePadded", gitversion.CommitsSinceVersionSourcePadded);
this.buildAgent.setOutput("commitDate", gitversion.CommitDate);
}
}

13
src/core/ioc.ts Normal file
View File

@@ -0,0 +1,13 @@
import { Container } from "inversify";
import { IVersionManager, VersionManager } from "./versionManager";
import { TYPES, IBuildAgent } from "./common";
import { BuildAgent } from "../agent/mock/build-agent";
import { IDotnetTool, DotnetTool } from "./dotnet-tool";
const container = new Container();
container.bind<IVersionManager>(TYPES.IVersionManager).to(VersionManager);
container.bind<IBuildAgent>(TYPES.IBuildAgent).to(BuildAgent);
container.bind<IDotnetTool>(TYPES.IDotnetTool).to(DotnetTool);
export default container;

59
src/core/versionManager.ts Normal file
View File

@@ -0,0 +1,59 @@
import cmp from "semver-compare";
import * as semver from "semver";
import { injectable, inject } from "inversify";
import { IBuildAgent, TYPES } from "./common";
export interface IVersionManager {
isExplicitVersion(versionSpec: string): boolean;
evaluateVersions(versions: string[], versionSpec: string): string;
cleanVersion(version: string): string;
}
@injectable()
export class VersionManager implements IVersionManager {
private buildAgent: IBuildAgent;
constructor(
@inject(TYPES.IBuildAgent) buildAgent: IBuildAgent,
) {
this.buildAgent = buildAgent;
}
public isExplicitVersion(versionSpec: string): boolean {
const c = semver.clean(versionSpec);
this.buildAgent.debug("isExplicit: " + c);
const valid = semver.valid(c) != null;
this.buildAgent.debug("explicit? " + valid);
return valid;
}
public evaluateVersions(versions: string[], versionSpec: string): string {
let version: string;
this.buildAgent.debug("evaluating " + versions.length + " versions");
versions = versions.sort(cmp);
for (let i = versions.length - 1; i >= 0; i--) {
const potential: string = versions[i];
const satisfied: boolean = semver.satisfies(potential, versionSpec);
if (satisfied) {
version = potential;
break;
}
}
if (version) {
this.buildAgent.debug("matched: " + version);
} else {
this.buildAgent.debug("match not found");
}
return version;
}
public cleanVersion(version: string): string {
this.buildAgent.debug("cleaning: " + version);
return semver.clean(version);
}
}