public void Start(int projectVersionId, Action <int> projectBuildStarted, Action <int, bool> projectBuildComplete)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
ProjectVersion projectVersion = entities.ProjectVersion
.Include("Properties")
.First(pv => pv.Id == projectVersionId);
SourceControlVersion sourceControlVersion = entities.SourceControlVersion
.Include("Properties")
.First(scv => scv.Id == projectVersion.SourceControlVersionId);
IDictionary <int, DateTime> buildTiming = new Dictionary <int, DateTime>();
BuildManager buildManager = Factory.GetInstance <BuildManager>();
buildManager.Build(
sourceControlVersion.Id,
projectVersionId,
projectVersionBuildId =>
{
projectBuildStarted(projectVersionBuildId);
if (buildTiming.ContainsKey(projectVersionBuildId))
{
buildTiming.Remove(projectVersionBuildId);
}
ProjectVersion projectVersionBuild = entities.ProjectVersion
.Include("Properties")
.First(pv => pv.Id == projectVersionBuildId);
projectVersionBuild.SetStringProperty("LastBuildStartDate", DateTime.UtcNow.ToString(CultureInfo.InvariantCulture));
entities.SaveChanges();
buildTiming[projectVersionBuildId] = DateTime.UtcNow;
},
(projectVersionBuildId, isSuccess) =>
{
projectBuildComplete(projectVersionBuildId, isSuccess);
ProjectVersion projectVersionBuild = entities.ProjectVersion
.Include("Properties")
.First(pv => pv.Id == projectVersionBuildId);
projectVersionBuild.SetStringProperty("LastBuildRevision", sourceControlVersion.GetStringProperty("Revision"));
projectVersionBuild.SetStringProperty("LastBuildDate", DateTime.UtcNow.ToString(CultureInfo.InvariantCulture));
projectVersionBuild.SetStringProperty("LastBuildResult", isSuccess ? "Done" : "Error");
projectVersionBuild.SetStringProperty("LastBuildDuration", (DateTime.UtcNow - buildTiming[projectVersionBuildId]).TotalSeconds.ToString(CultureInfo.InvariantCulture));
entities.SaveChanges();
});
entities.SaveChanges();
}
private IDictionary <Machine, MachinePublication> CreateMachinePublications(IList <Machine> affectedMachines, Publication publication, AspNetDeployEntities entities)
{
IDictionary <Machine, MachinePublication> machinePublications = new Dictionary <Machine, MachinePublication>();
foreach (Machine machine in affectedMachines)
{
MachinePublication machinePublication = entities.MachinePublication.FirstOrDefault(mp => mp.MachineId == machine.Id && mp.PublicationId == publication.Id);
if (machinePublication == null)
{
machinePublication = new MachinePublication
{
Publication = publication,
Machine = machine,
CreatedDate = DateTime.UtcNow
};
entities.MachinePublication.Add(machinePublication);
entities.SaveChanges();
}
machinePublications.Add(machine, machinePublication);
}
return(machinePublications);
}
private void RecordException(AspNetDeployEntities entities, ExceptionEntry parentException, Exception exception)
{
ExceptionEntry exceptionEntry = new ExceptionEntry();
exceptionEntry.Message = exception.Message;
exceptionEntry.Source = exception.Source;
exceptionEntry.StackTrace = exception.StackTrace;
exceptionEntry.TypeName = exception.GetType().FullName;
entities.ExceptionEntry.Add(exceptionEntry);
if (parentException != null)
{
parentException.InnerExceptionEntry = exceptionEntry;
}
else
{
AspNetDeployExceptionEntry aspNetDeployExceptionEntry = new AspNetDeployExceptionEntry();
aspNetDeployExceptionEntry.TimeStamp = DateTime.UtcNow;
aspNetDeployExceptionEntry.ExceptionEntry = exceptionEntry;
entities.AspNetDeployExceptionEntry.Add(aspNetDeployExceptionEntry);
}
if (exception.InnerException != null)
{
this.RecordException(entities, exceptionEntry, exception.InnerException);
}
entities.SaveChanges();
}
public void Start(int publicationId, Action <int> machineDeploymentStarted, Action <int, bool> machineDeploymentComplete)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
Publication publication = entities.Publication
.Include("Package.BundleVersion.Properties")
.Include("Environment")
.First(p => p.Id == publicationId);
DeploymentManager deploymentManager = Factory.GetInstance <DeploymentManager>();
DateTime deploymentStart = DateTime.UtcNow;
deploymentManager.Deploy(
publication.Id,
machineId =>
{
machineDeploymentStarted(machineId);
},
(machineId, isSuccess) =>
{
machineDeploymentComplete(machineId, isSuccess);
});
publication.Package.BundleVersion.SetStringProperty("LastPublicationAttemptPackage", publication.PackageId.ToString());
publication.Package.BundleVersion.SetStringProperty("LastDeploymentDuration-e" + publication.EnvironmentId, (DateTime.UtcNow - deploymentStart).TotalSeconds.ToString(CultureInfo.InvariantCulture));
entities.SaveChanges();
}
public void Start(int bundleId)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
BundleVersion bundleVersion = entities.BundleVersion
.Include("ProjectVersions.Properties")
.Include("ProjectVersions.SourceControlVersion.Properties")
.Include("Properties")
.First(bv => bv.Id == bundleId);
DateTime packageStart = DateTime.UtcNow;
PackageManager packageManager = Factory.GetInstance <PackageManager>();
packageManager.PackageBundle(bundleId);
foreach (ProjectVersion projectVersion in bundleVersion.ProjectVersions)
{
projectVersion.SetStringProperty("LastPackageRevision", projectVersion.SourceControlVersion.GetStringProperty("Revision"));
projectVersion.SetStringProperty("LastPackageDate", DateTime.UtcNow.ToString(CultureInfo.InvariantCulture));
}
bundleVersion.SetStringProperty("LastPackageDuration", (DateTime.UtcNow - packageStart).TotalSeconds.ToString(CultureInfo.InvariantCulture));
entities.SaveChanges();
}
public void Log(Exception exception, int?userId)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
AspNetDeployExceptionEntry aspNetDeployExceptionEntry = new AspNetDeployExceptionEntry();
aspNetDeployExceptionEntry.TimeStamp = DateTime.UtcNow;
aspNetDeployExceptionEntry.UserId = userId;
aspNetDeployExceptionEntry.ExceptionEntry = this.CreateAndSaveExceptionEntryRecursive(entities, null, exception);
entities.AspNetDeployExceptionEntry.Add(aspNetDeployExceptionEntry);
entities.SaveChanges();
}
public UpdateAndParseResult UpdateAndParse(int sourceControlVersionId)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
SourceControlVersion sourceControlVersion = entities.SourceControlVersion
.Include("Properties")
.Include("Revisions")
.Include("SourceControl.Properties")
.First(svc => svc.Id == sourceControlVersionId);
SourceControl sourceControl = sourceControlVersion.SourceControl;
string sourcesFolder = this.pathServices.GetSourceControlVersionPath(sourceControl.Id, sourceControlVersion.Id);
LoadSourcesResult loadSourcesResult = this.LoadSources(sourceControlVersion, sourcesFolder);
if (loadSourcesResult.RevisionId == sourceControlVersion.GetStringProperty("Revision"))
{
return(new UpdateAndParseResult());
}
sourceControlVersion.SetStringProperty("Revision", loadSourcesResult.RevisionId);
Revision previousRevision = sourceControlVersion.Revisions.OrderByDescending(r => r.CreatedDate).FirstOrDefault();
Revision newRevision = new Revision
{
CreatedDate = DateTime.UtcNow,
Name = loadSourcesResult.RevisionId,
ParentRevision = previousRevision
};
sourceControlVersion.Revisions.Add(newRevision);
LoadSourcesInfoResult loadSourcesInfoResult = this.LoadSourcesInfo(sourceControlVersion, sourcesFolder);
newRevision.RevisionInfos = loadSourcesInfoResult.SourcesInfos.Select(i => new RevisionInfo
{
Author = i.Author,
CreatedDate = i.CreatedDate,
Message = i.Message
}).ToList();
entities.SaveChanges();
this.projectParsingService.UpdateProjects(sourceControlVersionId);
return(new UpdateAndParseResult
{
HasChanges = true,
Projects = entities.Project.Where(p => p.SourceControlId == sourceControlVersion.Id).Select(p => p.Id).ToList()
});
}
private static void ScheduleAutoDeployToTest(AspNetDeployEntities entities)
{
List <BundleVersion> bundleVersions = entities.BundleVersion
.Include("Properties")
.Include("Packages.Publications.Environment")
.Include("ProjectVersions.SourceControlVersion.Properties")
.Where(bv => !bv.IsDeleted)
.ToList();
List <BundleVersion> bundleVersionsWithAutoDeploy = bundleVersions
.Where(bv =>
bv.GetIntProperty("AutoDeployToEnvironment") > 0 &&
bv.Packages.Any() &&
bv.ProjectVersions.All(pv => pv.SourceControlVersion.ArchiveState == SourceControlVersionArchiveState.Normal))
.ToList();
bundleVersionsWithAutoDeploy.ForEach(bundleVersion =>
{
int deployToEnvironmentId = bundleVersion.GetIntProperty("AutoDeployToEnvironment");
if (bundleVersion.Packages.Any(p => p.Publications.Any(pub => pub.EnvironmentId == deployToEnvironmentId && pub.State == PublicationState.Queued)))
{
return;
}
if (TaskRunnerContext.GetBundleVersionState(bundleVersion.Id) != BundleState.Idle)
{
return;
}
Package latestPackage = bundleVersion.Packages.OrderByDescending(p => p.CreatedDate).First();
List <Publication> latestPackagePublications = latestPackage.Publications.OrderByDescending(p => p.CreatedDate).ToList();
if (latestPackagePublications.Count == 0)
{
Publication publication = new Publication();
publication.CreatedDate = DateTime.UtcNow;
publication.EnvironmentId = deployToEnvironmentId;
publication.Package = latestPackage;
publication.State = PublicationState.Queued;
entities.Publication.Add(publication);
}
});
entities.SaveChanges();
}
private void LogMachinePublicationStep(MachinePublication machinePublication, DeploymentStep deploymentStep, AspNetDeployEntities entities, MachinePublicationLogEvent @event, IExceptionInfo lastException = null)
{
MachinePublicationLog machinePublicationLog = new MachinePublicationLog();
machinePublicationLog.CreatedDate = DateTime.UtcNow;
machinePublicationLog.MachinePublication = machinePublication;
machinePublicationLog.Event = @event;
machinePublicationLog.DeploymentStepId = deploymentStep.Id;
entities.MachinePublicationLog.Add(machinePublicationLog);
if (lastException != null)
{
this.RecordException(entities, null, lastException, machinePublicationLog);
}
entities.SaveChanges();
}
public ArhiveResult Archive(int sourceControlVersionId)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
SourceControlVersion sourceControlVersion = entities.SourceControlVersion
.Include("Properties")
.First(sc => sc.Id == sourceControlVersionId);
ISourceControlRepository repository = this.sourceControlRepositoryFactory.Create(sourceControlVersion.SourceControl.Type);
string sourcesFolder = this.pathServices.GetSourceControlVersionPath(sourceControlVersion.SourceControlId, sourceControlVersion.Id);
repository.Archive(sourceControlVersion, sourcesFolder);
sourceControlVersion.ArchiveState = SourceControlVersionArchiveState.Archived;
entities.SaveChanges();
return(new ArhiveResult()
{
IsSuccess = true
});
}
public void Build(List <ProjectVersion> projectVersions)
{
ProjectVersion activeProjectVersion = null;
try
{
foreach (ProjectVersion projectVersion in projectVersions.Distinct())
{
activeProjectVersion = projectVersion;
projectVersion.SetStringProperty("LastBuildResult", "Not started");
entities.SaveChanges();
BuildJob job = new BuildJob();
job.Start(
projectVersion.Id,
projectId => TaskRunnerContext.SetProjectVersionState(projectId, ProjectState.Building),
(projectId, isSuccess) =>
{
TaskRunnerContext.SetProjectVersionState(projectId, isSuccess ? ProjectState.Idle : ProjectState.Error);
});
}
}
catch (Exception e)
{
AspNetDeployException aspNetDeployException = new AspNetDeployException("Build project failed", e);
aspNetDeployException.Data.Add("SourceControl version Id", activeProjectVersion.SourceControlVersion.Id);
aspNetDeployException.Data.Add("Solution file", activeProjectVersion.SolutionFile);
Factory.GetInstance <ILoggingService>().Log(aspNetDeployException, null);
if (e.IsCritical())
{
throw;
}
}
}
public void PackageBundle(int bundleVersionId)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
BundleVersion bundleVersion = entities.BundleVersion
.Include("Bundle")
.Include("Packages")
.Include("ProjectVersions.Project")
.Include("ProjectVersions.SourceControlVersion.SourceControl")
.First(bv => bv.Id == bundleVersionId);
Package package = new Package
{
BundleVersion = bundleVersion,
CreatedDate = DateTime.UtcNow
};
entities.Package.Add(package);
using (ZipFile zipFile = new ZipFile(Encoding.UTF8))
{
zipFile.AlternateEncoding = Encoding.UTF8;
zipFile.AlternateEncodingUsage = ZipOption.Always;
foreach (ProjectVersion projectVersion in bundleVersion.ProjectVersions)
{
string sourcesFolder = this.pathServices.GetSourceControlVersionPath(projectVersion.SourceControlVersion.SourceControl.Id, projectVersion.SourceControlVersion.Id);
string projectPackagePath = this.pathServices.GetProjectPackagePath(projectVersion.Id, projectVersion.SourceControlVersion.GetStringProperty("Revision"));
string projectPath = Path.Combine(sourcesFolder, projectVersion.ProjectFile);
IProjectPackager projectPackager = projectPackagerFactory.Create(projectVersion.ProjectType);
if (projectPackager == null) // no need to package
{
projectVersion.SetStringProperty("LastPackageDuration", "0");
entities.SaveChanges();
continue;
}
if (!File.Exists(projectPackagePath))
{
DateTime packageStartDate = DateTime.UtcNow;
projectPackager.Package(projectPath, projectPackagePath);
projectVersion.SetStringProperty("LastPackageDuration", (DateTime.UtcNow - packageStartDate).TotalSeconds.ToString(CultureInfo.InvariantCulture));
entities.SaveChanges();
}
zipFile.AddFile(projectPackagePath, "/");
PackageEntry packageEntry = new PackageEntry
{
Package = package,
ProjectVersion = projectVersion,
Revision = projectVersion.SourceControlVersion.GetStringProperty("Revision")
};
entities.PackageEntry.Add(packageEntry);
}
zipFile.Save(this.pathServices.GetBundlePackagePath(bundleVersionId, package.Id));
}
package.PackageDate = DateTime.UtcNow;
entities.SaveChanges();
foreach (ProjectVersion projectVersion in bundleVersion.ProjectVersions)
{
string projectPackagePath = this.pathServices.GetProjectPackagePath(projectVersion.Id, projectVersion.SourceControlVersion.GetStringProperty("Revision"));
File.Delete(projectPackagePath);
}
}
private void ChangeMachinePublication(MachinePublication machinePublication, MachinePublicationState result, AspNetDeployEntities entities)
{
machinePublication.State = result;
entities.SaveChanges();
}
private void ChangePublicationResult(Publication publication, PublicationState result, AspNetDeployEntities entities)
{
publication.State = result;
entities.SaveChanges();
}
private static void BuildProjects(AspNetDeployEntities entities)
{
List <BundleVersion> bundleVersions = entities.BundleVersion
.Include("Properties")
.Include("ProjectVersions.SourceControlVersion.Properties")
.ToList();
foreach (BundleVersion bundleVersion in bundleVersions)
{
List <ProjectVersion> projectVersions = bundleVersion.ProjectVersions.Where(pv =>
(
pv.ProjectType.HasFlag(ProjectType.Database) ||
pv.ProjectType.HasFlag(ProjectType.WindowsApplication) ||
pv.ProjectType.HasFlag(ProjectType.Service) ||
pv.ProjectType.HasFlag(ProjectType.Console) ||
pv.ProjectType.HasFlag(ProjectType.Web) ||
pv.ProjectType.HasFlag(ProjectType.GulpFile) ||
pv.ProjectType.HasFlag(ProjectType.Test)
))
.ToList();
IList <ProjectVersion> errorProjects = projectVersions.Where(pv => pv.GetStringProperty("LastBuildResult") == "Error").ToList();
foreach (ProjectVersion projectVersion in errorProjects)
{
TaskRunnerContext.SetProjectVersionState(projectVersion.Id, ProjectState.Error);
}
List <ProjectVersion> projectVersionsToRebuild = projectVersions.Where(pv => pv.SourceControlVersion.GetStringProperty("Revision") != pv.GetStringProperty("LastBuildRevision")).ToList();
if (projectVersionsToRebuild.Count == 0)
{
if (errorProjects.Count > 0)
{
TaskRunnerContext.SetBundleVersionState(bundleVersion.Id, BundleState.Error);
}
continue;
}
List <BundleVersion> affectedBundleVersions = projectVersionsToRebuild
.SelectMany(pv => pv.BundleVersions)
.Where(bv => !bv.IsDeleted)
.ToList();
DateTime buildStartDate = DateTime.UtcNow;
foreach (BundleVersion affectedBundleVersion in affectedBundleVersions)
{
TaskRunnerContext.SetBundleVersionState(affectedBundleVersion.Id, BundleState.Building);
}
bundleVersion.SetStringProperty("LastBuildStartDate", DateTime.UtcNow.ToString(CultureInfo.InvariantCulture));
entities.SaveChanges();
ProjectsBuildStrategy buildStrategy = new ProjectsBuildStrategy(entities);
buildStrategy.Build(projectVersionsToRebuild);
bool buildFailed = projectVersionsToRebuild.Any(pv => pv.GetStringProperty("LastBuildResult") == "Error");
foreach (BundleVersion affectedBundleVersion in affectedBundleVersions)
{
if (buildFailed)
{
TaskRunnerContext.SetBundleVersionState(affectedBundleVersion.Id, BundleState.Error);
continue;
}
TaskRunnerContext.SetBundleVersionState(affectedBundleVersion.Id, BundleState.Idle);
}
if (bundleVersion.ProjectVersions.All(pv => TaskRunnerContext.GetProjectVersionState(pv.Id) == ProjectState.Idle))
{
bundleVersion.SetStringProperty("LastBuildDuration", (DateTime.UtcNow - buildStartDate).TotalSeconds.ToString(CultureInfo.InvariantCulture));
}
entities.SaveChanges();
}
}
