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();
}
private ExceptionEntry CreateAndSaveExceptionEntryRecursive(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;
}
foreach (ExceptionEntryData entryData in this.GetExceptionData(exception).Union(GetReflectionInfo(exception)).ToList())
{
entryData.ExceptionEntry = exceptionEntry;
entities.ExceptionEntryData.Add(entryData);
}
if (exception.InnerException != null)
{
this.CreateAndSaveExceptionEntryRecursive(entities, exceptionEntry, exception.InnerException);
}
return(exceptionEntry);
}
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();
}
private static void ArchiveSources(AspNetDeployEntities entities)
{
List <SourceControlVersion> sourceControlVersions = entities.SourceControlVersion
.Include("ProjectVersions")
.Include("Properties")
.Include("ProjectVersions.BundleVersions")
.Include("SourceControl.Properties")
.Where(scv => scv.ArchiveState == SourceControlVersionArchiveState.Archiving)
.ToList();
sourceControlVersions
.ForEach(sourceControlVersion =>
{
TaskRunnerContext.SetSourceControlVersionState(sourceControlVersion.Id, SourceControlState.Archiving);
try
{
(new SourceControlJob(sourceControlVersion.Id)).Archive();
TaskRunnerContext.SetSourceControlVersionState(sourceControlVersion.Id, SourceControlState.Idle);
}
catch (Exception e)
{
TaskRunnerContext.SetSourceControlVersionState(sourceControlVersion.Id, SourceControlState.Error);
Factory.GetInstance <ILoggingService>().Log(new AspNetDeployException("Archive sources failed: " + sourceControlVersion.Id, e), null);
if (e.IsCritical())
{
throw;
}
}
});
}
public IVariableProcessor Create(int bundleVersionId, int machineId)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
List <DataField> globalDataFields = entities.DataField
.Include("DataFieldValues.Environment")
.Include("DataFieldValues.Machine")
.Where(df => !df.IsDeleted && df.Mode == DataFieldMode.Global)
.ToList();
BundleVersion bundleVersion = entities.BundleVersion
.Include("Bundle")
.Include("ParentBundleVersion")
.Include("DataFields.DataFieldValues.Environment")
.Include("DataFields.DataFieldValues.Machine")
.First(bv => bv.Id == bundleVersionId);
List <DataField> bundleDataFields = bundleVersion.DataFields
.Where(df => !df.IsDeleted)
.ToList();
int environmentId = entities.Machine.First(m => m.Id == machineId).Environments.First().Id;
IDictionary <string, string> dataFieldsDictionary = this.CreateDataFieldsDictionary(machineId, globalDataFields, bundleDataFields, environmentId);
IDictionary <string, string> environmentDictionary = this.CreateEnvironmentDictionary(bundleVersion);
return(new VariableProcessor(dataFieldsDictionary, environmentDictionary, new Dictionary <string, Func <string, string> >()
{
{ "domainSafe".ToLower(), s => s.Replace(".", "-") }
}));
}
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 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 static void DeployScheduledPublications(AspNetDeployEntities entities)
{
List <Publication> publications = entities.Publication
.Include("Package.BundleVersion")
.Include("Environment")
.Where(p =>
p.State == PublicationState.Queued &&
!p.Package.Publications.Any(p2 =>
p2.CreatedDate > p.CreatedDate &&
p2.EnvironmentId == p.EnvironmentId))
.ToList();
List <IGrouping <BundleVersion, Publication> > groupedPublications = publications
.GroupBy(p => p.Package.BundleVersion)
.Where(bv => !bv.Key.IsDeleted)
.ToList();
groupedPublications.ForEach(group =>
{
TaskRunnerContext.SetBundleVersionState(group.Key.Id, BundleState.Deploying);
try
{
foreach (Publication publication in group)
{
try
{
DeploymentJob job = new DeploymentJob();
job.Start(
publication.Id,
machineId => TaskRunnerContext.SetMachineState(machineId, MachineState.Deploying),
(machineId, isSuccess) => TaskRunnerContext.SetMachineState(machineId, isSuccess ? MachineState.Idle : MachineState.Error));
}
catch (Exception e)
{
throw new AspNetDeployException("Publication failed: " + publication.Id, e);
}
}
}
catch (Exception e)
{
TaskRunnerContext.SetBundleVersionState(group.Key.Id, BundleState.Error);
Factory.GetInstance <ILoggingService>().Log(e, null);
if (e.IsCritical())
{
throw;
}
return;
}
TaskRunnerContext.SetBundleVersionState(group.Key.Id, BundleState.Idle);
});
}
protected override void OnActionExecuting(ActionExecutingContext filterContext)
{
this.Entities = new AspNetDeployEntities();
if (this.IsSetupState() && !filterContext.RouteData.Values["controller"].Equals("Setup"))
{
filterContext.Result = this.RedirectToAction(ConfigurationManager.AppSettings["Settings.SetupState"], "Setup");
}
base.OnActionExecuting(filterContext);
}
public static void ProcessTasks()
{
AspNetDeployEntities entities = new AspNetDeployEntities();
ArchiveSources(entities);
TakeSources(entities);
BuildProjects(entities);
PackageBundles(entities);
ScheduleAutoDeployToTest(entities);
DeployScheduledPublications(entities);
}
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()
});
}
public void Package(int projectVersionId)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
ProjectVersion projectVersion = entities.ProjectVersion
.Include("SourceControlVersion.Properties")
.Include("SourceControlVersion.SourceControl.Properties")
.First(pv => pv.Id == projectVersionId);
string sourcesFolder = string.Format(@"H:\AspNetDeployWorkingFolder\Sources\{0}\{1}", projectVersion.SourceControlVersion.SourceControl.Id, projectVersion.SourceControlVersion.Id);
XDocument xDocument = XDocument.Load(projectFile);
XNamespace fileNamespace = "http://schemas.microsoft.com/developer/msbuild/2003";
}
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 static void TakeSources(AspNetDeployEntities entities)
{
List <SourceControlVersion> sourceControlVersions = entities.SourceControlVersion
.Include("ProjectVersions")
.Include("Properties")
.Include("ProjectVersions.BundleVersions")
.Include("SourceControl.Properties")
.Where(scv => scv.ArchiveState == SourceControlVersionArchiveState.Normal)
.ToList();
sourceControlVersions
.ForEach(sourceControlVersion =>
{
TaskRunnerContext.SetSourceControlVersionState(sourceControlVersion.Id, SourceControlState.Loading);
sourceControlVersion.ProjectVersions
.SelectMany(pv => pv.BundleVersions)
.Where(bv => !bv.IsDeleted)
.ToList()
.ForEach(bv => TaskRunnerContext.SetBundleVersionState(bv.Id, BundleState.Loading));
try
{
(new SourceControlJob(sourceControlVersion.Id)).UpdateAndParse();
TaskRunnerContext.SetSourceControlVersionState(sourceControlVersion.Id, SourceControlState.Idle);
}
catch (Exception e)
{
TaskRunnerContext.SetSourceControlVersionState(sourceControlVersion.Id, SourceControlState.Error);
Factory.GetInstance <ILoggingService>().Log(new AspNetDeployException("Take sources failed: " + sourceControlVersion.Id, e), null);
if (e.IsCritical())
{
throw;
}
}
sourceControlVersion.ProjectVersions
.SelectMany(pv => pv.BundleVersions)
.Where(bv => !bv.IsDeleted)
.ToList()
.ForEach(bv => TaskRunnerContext.SetBundleVersionState(bv.Id, BundleState.Idle));
});
}
public void Initialize(int sourceControlVersionId)
{
this.entities = new AspNetDeployEntities();
this.sourceControlVersion = this.entities.SourceControlVersion
.Include("Properties")
.Include("SourceControl.Properties")
.First(svc => svc.Id == sourceControlVersionId);
this.existingProjects = this.entities.Project
.Include("ProjectVersions")
.Where(p => p.SourceControlId == sourceControlVersion.SourceControlId)
.ToList();
this.existingProjectVersions = existingProjects
.SelectMany(p => p.ProjectVersions)
.Where(pv => pv.SourceControlVersionId == sourceControlVersion.Id)
.ToList();
}
public void Build(int sourceControlVersionId, int projectVersionId, Action <int> projectBuildStarted, Action <int, bool> projectBuildComplete)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
SourceControlVersion sourceControlVersion = entities.SourceControlVersion.Include("SourceControl").First(scv => scv.Id == sourceControlVersionId);
ProjectVersion projectVersion = entities.ProjectVersion.Include("Properties").First(pv => pv.Id == projectVersionId);
string sourcesFolder = this.pathServices.GetSourceControlVersionPath(sourceControlVersion.SourceControl.Id, sourceControlVersion.Id);
IBuildService buildService = buildServiceFactory.Create(projectVersion.ProjectType);
BuildSolutionResult buildSolutionResult = buildService.Build(
sourcesFolder,
projectVersion,
projectFileName =>
{
ProjectVersion projectVersionBuild = entities.ProjectVersion
.Where(p => p.SourceControlVersionId == sourceControlVersionId)
.ToList()
.FirstOrDefault(p => !p.IsDeleted && Path.Combine(sourcesFolder, p.ProjectFile).ToLowerInvariant() == projectFileName.ToLowerInvariant());
if (projectVersionBuild != null)
{
projectBuildStarted(projectVersionBuild.Id);
}
},
(projectFileName, success, message) =>
{
ProjectVersion projectVersionBuild = entities.ProjectVersion
.Where(p => p.SourceControlVersionId == sourceControlVersionId)
.ToList()
.FirstOrDefault(p => !p.IsDeleted && Path.Combine(sourcesFolder, p.ProjectFile).ToLowerInvariant() == projectFileName.ToLowerInvariant());
if (projectVersionBuild != null)
{
projectBuildComplete(projectVersionBuild.Id, success);
}
},
(projectFile, exception) =>
{
this.loggingService.Log(new AspNetDeployException("Project build failed: " + projectFile, exception), null);
});
}
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
});
}
private void RecordException(AspNetDeployEntities entities, ExceptionEntry parentException, IExceptionInfo lastException, MachinePublicationLog machinePublicationLog)
{
ExceptionEntry exceptionEntry = new ExceptionEntry();
machinePublicationLog.Exception = exceptionEntry;
exceptionEntry.Message = lastException.Message;
exceptionEntry.Source = lastException.Source;
exceptionEntry.StackTrace = lastException.StackTrace;
exceptionEntry.TypeName = lastException.TypeName;
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);
}
foreach (IExceptionDataInfo exceptionDataInfo in lastException.ExceptionData)
{
ExceptionEntryData data = new ExceptionEntryData();
data.ExceptionEntry = exceptionEntry;
data.IsProperty = exceptionDataInfo.IsProperty;
data.Name = exceptionDataInfo.Name;
data.Value = exceptionDataInfo.Value;
entities.ExceptionEntryData.Add(data);
}
if (lastException.InnerException != null)
{
this.RecordException(entities, exceptionEntry, lastException.InnerException, machinePublicationLog);
}
}
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();
}
}
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);
}
}
public DeploymentStepEditModelFactory()
{
this.entities = entities;
}
private static void RunScheduler()
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (sender, eventArgs) => ThreadTaskRunner.ProcessTasks();
worker.RunWorkerCompleted += (sender, eventArgs) =>
{
WriteLine("---------------");
WriteLine("Worker Complete");
WorkerComplete = true;
};
worker.RunWorkerAsync();
AspNetDeployEntities entities = new AspNetDeployEntities();
while (true)
{
WriteLine(DateTime.Now.ToString());
List <SourceControlVersion> sourceControls = entities.SourceControlVersion.Include("SourceControl").ToList();
List <BundleVersion> bundleVersions = entities.BundleVersion.Include("Bundle").ToList();
List <ProjectVersion> projectVersions = entities.ProjectVersion.Include("Project").ToList();
List <Machine> machines = entities.Machine.ToList();
foreach (SourceControlVersion sourceControlVersion in sourceControls)
{
WriteLine(sourceControlVersion.Id + " - " + sourceControlVersion.SourceControl.Name + " / " + sourceControlVersion.Name + " - " + TaskRunnerContext.GetSourceControlVersionState(sourceControlVersion.Id));
}
WriteLine("");
foreach (BundleVersion bundleVersion in bundleVersions)
{
WriteLine(bundleVersion.Id + " - " + bundleVersion.Bundle.Name + " / " + bundleVersion.Name + " - " + TaskRunnerContext.GetBundleVersionState(bundleVersion.Id));
}
WriteLine("");
foreach (ProjectVersion projectVersion in projectVersions.Where(p => TaskRunnerContext.GetProjectVersionState(p.Id) != ProjectState.Idle))
{
WriteLine(
projectVersion.SourceControlVersion.SourceControl.Name + "/ " +
projectVersion.SourceControlVersion.Name + "/ " +
projectVersion.Id + " - " + projectVersion.Project.Name + " - " + TaskRunnerContext.GetProjectVersionState(projectVersion.Id));
}
WriteLine("");
foreach (Machine machine in machines)
{
WriteLine(
machine.Name + " - " + TaskRunnerContext.GetMachineState(machine.Id));
}
WriteLine("");
/*if (sourceControls.All(scv => TaskRunnerContext.GetSourceControlVersionState(scv.Id) == SourceControlState.Idle) &&
* bundleVersions.All(bv => TaskRunnerContext.GetBundleVersionState(bv.Id) == BundleState.Idle))
* {
* break;
* }*/
if (WorkerComplete)
{
break;
}
Thread.Sleep(200);
Console.SetCursorPosition(0, 0);
}
}
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 ProjectsBuildStrategy(AspNetDeployEntities entities)
{
this.entities = entities;
}
private static void PackageBundles(AspNetDeployEntities entities)
{
List <BundleVersion> bundleVersions = entities.BundleVersion
.Include("ProjectVersions.SourceControlVersion.Properties")
.Where(bv => !bv.IsDeleted)
.ToList();
List <ProjectVersion> projectVersions = bundleVersions
.SelectMany(scv => scv.ProjectVersions)
.Where(pv =>
pv.ProjectType.HasFlag(ProjectType.WindowsApplication) ||
pv.ProjectType.HasFlag(ProjectType.Database) ||
pv.ProjectType.HasFlag(ProjectType.ZipArchive) ||
pv.ProjectType.HasFlag(ProjectType.GulpFile) ||
pv.ProjectType.HasFlag(ProjectType.Service) ||
pv.ProjectType.HasFlag(ProjectType.Console) ||
pv.ProjectType.HasFlag(ProjectType.Web)
)
.Where(pv =>
pv.SourceControlVersion.GetStringProperty("Revision") != pv.GetStringProperty("LastPackageRevision"))
.ToList();
List <BundleVersion> bundleVersionsToPack = projectVersions
.SelectMany(pv => pv.BundleVersions)
.Distinct()
.Where(bv => bv.ProjectVersions.All(
pv => pv.SourceControlVersion.ArchiveState == SourceControlVersionArchiveState.Normal &&
(
pv.ProjectType == ProjectType.ZipArchive || pv.GetStringProperty("LastBuildResult") == "Done")
))
.ToList();
List <BundleVersion> errorBundles = new List <BundleVersion>();
bundleVersionsToPack.ForEach(bundleVersion =>
{
/*if (bundleVersion.ProjectVersions.Any( pv =>
* TaskRunnerContext.GetProjectVersionState(pv.Id) != ProjectState.Idle ||
* pv.GetStringProperty("LastBuildResult") != "Done"))
* {
* return;
* }*/
TaskRunnerContext.SetBundleVersionState(bundleVersion.Id, BundleState.Packaging);
try
{
PackageJob job = new PackageJob();
job.Start(bundleVersion.Id);
}
catch (Exception e)
{
TaskRunnerContext.SetBundleVersionState(bundleVersion.Id, BundleState.Error);
Factory.GetInstance <ILoggingService>().Log(e, null);
errorBundles.Add(bundleVersion);
if (e.IsCritical())
{
throw;
}
}
});
bundleVersionsToPack
.Except(errorBundles)
.ToList()
.ForEach(bv => TaskRunnerContext.SetBundleVersionState(bv.Id, BundleState.Idle));
}
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 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();
}
public void Deploy(int publicationId, Action <int> machineDeploymentStarted, Action <int, bool> machineDeploymentComplete)
{
AspNetDeployEntities entities = new AspNetDeployEntities();
Publication publication = entities.Publication
.Include("Package.BundleVersion.Properties")
.Include("Package.BundleVersion.ProjectVersions")
.Include("Package.BundleVersion.ProjectVersions.SourceControlVersion")
.Include("Package.BundleVersion.DeploymentSteps.Properties")
.Include("Package.BundleVersion.DeploymentSteps.MachineRoles")
.Include("Environment.Properties")
.Include("Environment.Machines.MachineRoles")
.First(p => p.Id == publicationId);
IList <Machine> affectedMachines = this.GetAffectedMachines(publication);
IDictionary <Machine, IDeploymentAgent> agents = this.CreateDeploymentAgents(affectedMachines, publication.Package);
IDictionary <Machine, MachinePublication> machinePublications = this.CreateMachinePublications(affectedMachines, publication, entities);
if (!this.ValidateDeploymentAgents(agents))
{
return;
}
string bundlePackagePath = pathServices.GetBundlePackagePath(publication.Package.BundleVersionId, publication.Package.Id);
if (!this.ValidatePackage(bundlePackagePath))
{
return;
}
this.ChangePublicationResult(publication, PublicationState.InProgress, entities);
foreach (MachinePublication machinePublication in machinePublications.Values)
{
this.ChangeMachinePublication(machinePublication, MachinePublicationState.Queued, entities);
}
foreach (KeyValuePair <Machine, IDeploymentAgent> pair in agents)
{
Machine machine = pair.Key;
IDeploymentAgent deploymentAgent = pair.Value;
MachinePublication machinePublication = machinePublications[machine];
if (!deploymentAgent.IsReady())
{
this.RecordException(entities, null, new AspNetDeployException("Deployment agent not ready"));
this.ChangePublicationResult(publication, PublicationState.Error, entities);
return;
}
machineDeploymentStarted(machine.Id);
try
{
deploymentAgent.BeginPublication(publication.Id);
deploymentAgent.ResetPackage();
this.ChangeMachinePublication(machinePublication, MachinePublicationState.Uploading, entities);
deploymentAgent.UploadPackage(bundlePackagePath);
this.ChangeMachinePublication(machinePublication, MachinePublicationState.Configuring, entities);
IList <DeploymentStep> machineDeploymentSteps = this.GetMachineDeploymentSteps(publication.Package, machine);
foreach (DeploymentStep deploymentStep in machineDeploymentSteps)
{
if (deploymentStep.Type == DeploymentStepType.RunVsTests)
{
this.LogMachinePublicationStep(machinePublication, deploymentStep, entities, MachinePublicationLogEvent.DeploymentStepConfiguringComplete);
continue;
}
try
{
this.LogMachinePublicationStep(machinePublication, deploymentStep, entities, MachinePublicationLogEvent.DeploymentStepConfiguring);
deploymentAgent.ProcessDeploymentStep(deploymentStep);
this.LogMachinePublicationStep(machinePublication, deploymentStep, entities, MachinePublicationLogEvent.DeploymentStepConfiguringComplete);
}
catch (Exception e)
{
this.RecordException(entities, null, e);
this.LogMachinePublicationStep(machinePublication, deploymentStep, entities, MachinePublicationLogEvent.DeploymentStepConfiguringError, this.GetLastExceptionSafe(deploymentAgent));
throw;
}
}
this.ChangeMachinePublication(machinePublication, MachinePublicationState.Running, entities);
for (var i = 0; i < machineDeploymentSteps.Count; i++)
{
DeploymentStep deploymentStep = machineDeploymentSteps[i];
if (deploymentStep.Type == DeploymentStepType.RunVsTests)
{
this.LogMachinePublicationStep(machinePublication, deploymentStep, entities, MachinePublicationLogEvent.DeploymentStepExecuting);
IVariableProcessor variableProcessor = this.variableProcessorFactory.Create(publication.Package.BundleVersionId, machine.Id);
ProjectVersion projectVersion = publication.Package.BundleVersion.ProjectVersions.First(pv => pv.Id == deploymentStep.GetIntProperty("ProjectId"));
IProjectTestRunner projectTestRunner = this.projectTestRunnerFactory.Create(projectVersion.ProjectType, variableProcessor);
IList <TestResult> testResults = projectTestRunner.Run(projectVersion);
if (testResults.All(t => t.IsPass))
{
this.LogMachinePublicationStep(machinePublication, deploymentStep, entities, MachinePublicationLogEvent.DeploymentStepExecutingComplete);
}
else
{
this.LogMachinePublicationStep(
machinePublication,
deploymentStep,
entities,
MachinePublicationLogEvent.DeploymentStepExecutingError,
new ExceptionInfo()
{
Message = string.Join(", ", testResults.Where(t => !t.IsPass).Select(t => t.TestClassName + "." + t.TestName)),
ExceptionData = testResults
.Where(t => !t.IsPass)
.Select((t, index) => new ExceptionDataInfo()
{
Name = index + ". " + t.TestClassName + "." + t.TestName,
Value = t.Message,
IsProperty = true
})
.Cast <IExceptionDataInfo>()
.ToList()
});
}
continue;
}
try
{
this.LogMachinePublicationStep(machinePublication, deploymentStep, entities, MachinePublicationLogEvent.DeploymentStepExecuting);
if (deploymentAgent.ExecuteNextOperation())
{
this.LogMachinePublicationStep(machinePublication, deploymentStep, entities, MachinePublicationLogEvent.DeploymentStepExecutingComplete);
}
else
{
throw new AspNetDeployException("Error executing deploymentStep");
}
}
catch (Exception e)
{
e.Data.Add("Deployment step id", deploymentStep.Id);
e.Data.Add("Deployment ttep index", i + 1);
e.Data.Add("Machine name", machine.Name);
this.RecordException(entities, null, e);
this.LogMachinePublicationStep(
machinePublication,
deploymentStep,
entities,
MachinePublicationLogEvent.DeploymentStepExecutingError,
this.GetLastExceptionSafe(deploymentAgent));
throw;
}
}
deploymentAgent.Complete();
}
catch (Exception e)
{
e.Data.Add("Publication.Id", publication.Id);
e.Data.Add("Publication.Package.Id", publication.Package.Id);
/*deploymentAgent.Rollback();*/
machineDeploymentComplete(machine.Id, false);
this.ChangeMachinePublication(machinePublication, MachinePublicationState.Error, entities);
this.ChangePublicationResult(publication, PublicationState.Error, entities);
this.RecordException(entities, null, e);
return;
}
this.ChangeMachinePublication(machinePublication, MachinePublicationState.Complete, entities);
machineDeploymentComplete(machine.Id, true);
}
this.ChangePublicationResult(publication, PublicationState.Complete, entities);
}
