public static async GetSessionId(
feedId: string,
protocol: string,
baseUrl: string,
handlers: VsoBaseInterfaces.IRequestHandler[],
options: VsoBaseInterfaces.IRequestOptions): Promise<string> {
const publishPackageMetadata = tl.getInput("publishPackageMetadata");
let shouldCreateSession = publishPackageMetadata && publishPackageMetadata.toLowerCase() == 'true';
if (shouldCreateSession) {
const useSessionEnabled = tl.getVariable("Packaging.SavePublishMetadata");
shouldCreateSession = shouldCreateSession && !(useSessionEnabled && useSessionEnabled.toLowerCase() == 'false')
}
if (shouldCreateSession) {
tl.debug("Creating provenance session to save pipeline metadata. This can be disabled in the task settings, or by setting build variable Packaging.SavePublishMetadata to false");
const prov = new ProvenanceApi(baseUrl, handlers, options);
const sessionRequest = ProvenanceHelper.CreateSessionRequest(feedId);
try {
const session = await prov.createSession(sessionRequest, protocol);
return session.sessionId;
} catch (error) {
tl.warning(tl.loc("Warning_SessionCreationFailed", JSON.stringify(error)));
}
}
return feedId;
}
function _logUniversalStartupVariables(artifactToolPath: string) {
try {
let universalPackagesTelemetry = {
"command": tl.getInput("command"),
"buildProperties": tl.getInput("buildProperties"),
"basePath": tl.getInput("basePath"),
"System.TeamFoundationCollectionUri": tl.getVariable("System.TeamFoundationCollectionUri"),
"verbosity": tl.getInput("verbosity"),
"solution": tl.getInput("solution"),
"artifactToolPath": artifactToolPath,
};
telemetry.emitTelemetry("Packaging", "UniversalPackages", universalPackagesTelemetry);
} catch (err) {
tl.debug(`Unable to log Universal Packages task init telemetry. Err:( ${err} )`);
}
}
function publishPackageUsingArtifactTool(publishDir: string, options: artifactToolRunner.IArtifactToolOptions, execOptions: IExecOptions) {
let command = new Array<string>();
command.push("universal", "publish",
"--feed", options.feedId,
"--service", options.accountUrl,
"--package-name", options.packageName,
"--package-version", options.packageVersion,
"--path", publishDir,
"--patvar", "UNIVERSAL_PUBLISH_PAT",
"--verbosity", tl.getInput("verbosity"),
"--description", tl.getInput("packagePublishDescription"));
console.log(tl.loc("Info_Publishing", options.packageName, options.packageVersion, options.feedId));
const execResult: IExecSyncResult = artifactToolRunner.runArtifactTool(options.artifactToolPath, command, execOptions);
if (execResult.code === 0) {
return;
}
telemetry.logResult("Packaging", "UniversalPackagesCommand", execResult.code);
throw new Error(tl.loc("Error_UnexpectedErrorArtifactTool",
execResult.code,
execResult.stderr ? execResult.stderr.trim() : execResult.stderr));
}
async function main(): Promise<void> {
tl.setResourcePath(path.join(__dirname, "task.json"));
// Getting artifact tool
tl.debug("Getting artifact tool");
let artifactToolPath: string;
try {
const localAccessToken = pkgLocationUtils.getSystemAccessToken();
const serviceUri = tl.getEndpointUrl("SYSTEMVSSCONNECTION", false);
const blobUri = await pkgLocationUtils.getBlobstoreUriFromBaseServiceUri(
serviceUri,
localAccessToken);
// Finding the artifact tool directory
artifactToolPath = await artifactToolUtilities.getArtifactToolFromService(
blobUri,
localAccessToken,
"artifacttool");
}
catch (error) {
tl.setResult(tl.TaskResult.Failed, error.message);
return;
} finally{
_logUniversalStartupVariables(artifactToolPath);
}
// Calling the command. download/publish
const universalPackageCommand = tl.getInput("command", true);
switch (universalPackageCommand) {
case "download":
universalDownload.run(artifactToolPath);
break;
case "publish":
universalPublish.run(artifactToolPath);
break;
default:
tl.setResult(tl.TaskResult.Failed, tl.loc("Error_CommandNotRecognized", universalPackageCommand));
break;
}
}
export async function run(artifactToolPath: string): Promise<void> {
let buildIdentityDisplayName: string = null;
let buildIdentityAccount: string = null;
try {
// Get directory to publish
let downloadDir: string = tl.getInput("downloadDirectory");
if (downloadDir.length < 1)
{
tl.warning(tl.loc("Info_DownloadDirectoryNotFound"));
return;
}
let serviceUri: string;
let feedId: string;
let packageName: string;
let version: string;
// Feed Auth
let feedType = tl.getInput("internalOrExternalDownload") || "internal";
const normalizedFeedType = ["internal", "external"].find((x) =>
feedType.toUpperCase() === x.toUpperCase());
if (!normalizedFeedType) {
throw new Error(tl.loc("UnknownFeedType", feedType));
}
feedType = normalizedFeedType;
let internalAuthInfo: auth.InternalAuthInfo;
let toolRunnerOptions = artifactToolRunner.getOptions();
if (feedType === "internal")
{
// getting inputs
serviceUri = tl.getEndpointUrl("SYSTEMVSSCONNECTION", false);
feedId = tl.getInput("feedListDownload");
// Getting package name from package Id
const packageId = tl.getInput("packageListDownload");
const accessToken = pkgLocationUtils.getSystemAccessToken();
internalAuthInfo = new auth.InternalAuthInfo([], accessToken);
const feedUri = await pkgLocationUtils.getFeedUriFromBaseServiceUri(serviceUri, accessToken);
packageName = await artifactToolUtilities.getPackageNameFromId(feedUri, accessToken, feedId, packageId);
version = tl.getInput("versionListDownload");
toolRunnerOptions.env.UNIVERSAL_DOWNLOAD_PAT = internalAuthInfo.accessToken;
}
else {
let externalAuthInfo = auth.GetExternalAuthInfo("externalEndpoint");
if (!externalAuthInfo)
{
tl.setResult(tl.TaskResult.Failed, tl.loc("Error_NoSourceSpecifiedForDownload"));
return;
}
serviceUri = externalAuthInfo.packageSource.accountUrl;
feedId = tl.getInput("feedDownloadExternal");
packageName = tl.getInput("packageDownloadExternal");
version = tl.getInput("versionDownloadExternal");
// Assuming only auth via PAT works for now
const tokenAuth = externalAuthInfo as auth.TokenExternalAuthInfo;
toolRunnerOptions.env.UNIVERSAL_DOWNLOAD_PAT = tokenAuth.token;
}
tl.debug(tl.loc("Info_UsingArtifactToolDownload"));
const downloadOptions = {
artifactToolPath,
feedId,
accountUrl: serviceUri,
packageName,
packageVersion: version,
} as artifactToolRunner.IArtifactToolOptions;
downloadPackageUsingArtifactTool(downloadDir, downloadOptions, toolRunnerOptions);
tl.setResult(tl.TaskResult.Succeeded, tl.loc("PackagesDownloadedSuccessfully"));
} catch (err) {
tl.error(err);
if (buildIdentityDisplayName || buildIdentityAccount) {
tl.warning(tl.loc("BuildIdentityPermissionsHint", buildIdentityDisplayName, buildIdentityAccount));
}
tl.setResult(tl.TaskResult.Failed, tl.loc("PackagesFailedToDownload"));
}
}
export async function run(artifactToolPath: string): Promise<void> {
let buildIdentityDisplayName: string = null;
let buildIdentityAccount: string = null;
try {
// Get directory to publish
let publishDir: string = tl.getInput("publishDirectory");
if (publishDir.length < 1)
{
tl.debug(tl.loc("Info_PublishDirectoryNotFound"));
return;
}
let serviceUri: string;
let feedId: string;
let packageName: string;
let version: string;
let accessToken: string;
let feedUri: string;
const versionRadio = tl.getInput("versionPublishSelector");
// Feed Auth
let feedType = tl.getInput("internalOrExternalPublish") || "internal";
const normalizedFeedType = ["internal", "external"].find((x) =>
feedType.toUpperCase() === x.toUpperCase());
if (!normalizedFeedType) {
throw new Error(tl.loc("UnknownFeedType", feedType));
}
feedType = normalizedFeedType;
let internalAuthInfo: auth.InternalAuthInfo;
let toolRunnerOptions = artifactToolRunner.getOptions();
if (feedType === "internal")
{
// getting inputs
serviceUri = tl.getEndpointUrl("SYSTEMVSSCONNECTION", false);
packageName = tl.getInput("packageListPublish");
feedId = tl.getInput("feedListPublish");
// Setting up auth info
accessToken = pkgLocationUtils.getSystemAccessToken();
internalAuthInfo = new auth.InternalAuthInfo([], accessToken);
toolRunnerOptions.env.UNIVERSAL_PUBLISH_PAT = internalAuthInfo.accessToken;
}
else {
const externalAuthInfo = auth.GetExternalAuthInfo("externalEndpoints");
if (!externalAuthInfo)
{
tl.setResult(tl.TaskResult.Failed, tl.loc("Error_NoSourceSpecifiedForPublish"));
return;
}
serviceUri = externalAuthInfo.packageSource.accountUrl;
feedId = tl.getInput("feedPublishExternal");
packageName = tl.getInput("packagePublishExternal");
// Assuming only auth via PAT works for now
accessToken = (externalAuthInfo as auth.TokenExternalAuthInfo).token;
toolRunnerOptions.env.UNIVERSAL_PUBLISH_PAT = accessToken;
}
if (versionRadio === "custom"){
version = tl.getInput("versionPublish");
}
else{
feedUri = await pkgLocationUtils.getFeedUriFromBaseServiceUri(serviceUri, accessToken);
let highestVersion = await artifactToolUtilities.getHighestPackageVersionFromFeed(feedUri, accessToken, feedId, packageName);
version = artifactToolUtilities.getVersionUtility(tl.getInput("versionPublishSelector"), highestVersion);
}
tl.debug(tl.loc("Info_UsingArtifactToolPublish"));
// tslint:disable-next-line:no-object-literal-type-assertion
const publishOptions = {
artifactToolPath,
feedId,
accountUrl: serviceUri,
packageName,
packageVersion: version,
} as artifactToolRunner.IArtifactToolOptions;
publishPackageUsingArtifactTool(publishDir, publishOptions, toolRunnerOptions);
tl.setResult(tl.TaskResult.Succeeded, tl.loc("PackagesPublishedSuccessfully"));
} catch (err) {
tl.error(err);
if (buildIdentityDisplayName || buildIdentityAccount) {
tl.warning(tl.loc("BuildIdentityPermissionsHint", buildIdentityDisplayName, buildIdentityAccount));
}
tl.setResult(tl.TaskResult.Failed, tl.loc("PackagesFailedToPublish"));
}
}