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); }