public override async Task PrepareWorkDirectoryAsync()
{
await base.PrepareWorkDirectoryAsync();
var metadata = await ProjectPackageTools.UnpackAsync(ProjectPackageFilename, BinDirectory);
AssemblyFilename = metadata.AssemblyFilename;
ScriptName = metadata.ScriptName;
}
public async Task Add(string filename)
{
var metadata = await ProjectPackageTools.GetMetadataAsync(filename);
if (metadata == null)
{
throw new Exception("No metadata file found in package!");
}
await base.Add(filename, metadata);
}
private async Task <ProjectPackage> LoadItem(string packageId, string version)
{
var packageMgr = PhotonServer.Instance.ProjectPackages;
if (!packageMgr.TryGet(packageId, version, out var filename))
{
throw new ApplicationException($"Package '{packageId}' version '{version}' not found!");
}
return(await ProjectPackageTools.GetMetadataAsync(filename));
}
private void PackageClient_OnPushProjectPackage(string filename, RemoteTaskCompletionSource taskHandle)
{
Task.Run(async() => {
var metadata = await ProjectPackageTools.GetMetadataAsync(filename);
if (metadata == null)
{
throw new ApplicationException($"Invalid Project Package '{filename}'! No metadata found.");
}
await projectPackages.Add(filename);
PushedProjectPackageList.Add(new PackageReference(metadata.Id, metadata.Version));
}).ContinueWith(taskHandle.FromTask);
}
private async Task CreateProjectPackage(string version, CancellationToken token)
{
var projectPath = Path.Combine(Context.ContentDirectory, "Jenkins.Net.Publishing");
var packageDefFile = Path.Combine(projectPath, "Jenkins.Net.Publishing.json");
var output = Path.Combine(Context.ContentDirectory, "PublishPackage", "Jenkins.Net.zip");
try {
Context.WriteTagLine("Creating project package...", ConsoleColor.White);
var packageDef = ProjectPackageTools.LoadDefinition(packageDefFile);
await ProjectPackageTools.CreatePackage(
definition : packageDef,
rootPath : projectPath,
version : version,
outputFilename : output);
Context.WriteTagLine("Created project package successfully.", ConsoleColor.White);
}
catch (Exception error) {
Context.WriteErrorBlock("Failed to create project package!", error.UnfoldMessages());
throw;
}
try {
Context.WriteTagLine("Publishing project package...", ConsoleColor.White);
await Context.Packages.PushProjectPackageAsync(output, token);
Context.WriteTagLine("Published project package successfully.", ConsoleColor.White);
}
catch (Exception error) {
Context.WriteErrorBlock("Failed to publish project package!", error.UnfoldMessages());
throw;
}
}
public override async Task <HttpHandlerResult> PostAsync(CancellationToken token)
{
var qProjectId = GetQuery("project");
var projectPackageId = GetQuery("package");
var projectPackageVersion = GetQuery("version");
var environmentName = GetQuery("env");
if (string.IsNullOrWhiteSpace(projectPackageId))
{
return(Response.BadRequest().SetText("'package' is undefined!"));
}
if (string.IsNullOrWhiteSpace(projectPackageVersion))
{
return(Response.BadRequest().SetText("'version' is undefined!"));
}
try {
if (!PhotonServer.Instance.ProjectPackages.TryGet(projectPackageId, projectPackageVersion, out var packageFilename))
{
return(Response.BadRequest().SetText($"Project Package '{projectPackageId}.{projectPackageVersion}' was not found!"));
}
var metadata = await ProjectPackageTools.GetMetadataAsync(packageFilename);
var projectId = metadata.ProjectId;
if (!string.IsNullOrEmpty(qProjectId))
{
projectId = qProjectId;
}
if (string.IsNullOrEmpty(projectId))
{
throw new ApplicationException("'project' is undefined!");
}
if (!PhotonServer.Instance.Projects.TryGet(projectId, out var project))
{
return(Response.BadRequest().SetText($"Project '{projectId}' was not found!"));
}
var deployment = await project.StartNewDeployment();
deployment.PackageId = projectPackageId;
deployment.PackageVersion = projectPackageVersion;
deployment.EnvironmentName = environmentName;
//deployment.ScriptName = ?;
var session = new ServerDeploySession {
Project = project.Description,
Deployment = deployment,
ProjectPackageId = projectPackageId,
ProjectPackageVersion = projectPackageVersion,
ProjectPackageFilename = packageFilename,
EnvironmentName = environmentName,
};
deployment.ServerSessionId = session.SessionId;
PhotonServer.Instance.Sessions.BeginSession(session);
PhotonServer.Instance.Queue.Add(session);
var response = new HttpDeployStartResponse {
SessionId = session.SessionId,
};
return(Response.Json(response));
}
catch (Exception error) {
Log.Error($"Deployment of Project Package '{projectPackageId}.{projectPackageVersion}' has failed!", error);
return(Response.Exception(error));
}
}
public async Task Run()
{
var rootPath = Path.GetDirectoryName(MetadataFilename);
var metadata = ProjectPackageTools.LoadDefinition(MetadataFilename);
await ProjectPackageTools.CreatePackage(metadata, rootPath, PackageVersion, PackageFilename);
}
public async Task Run()
{
await ProjectPackageTools.CreatePackage(MetadataFilename, PackageVersion, PackageFilename);
}
