public void SetUp() { listLatestDeploymentsCommands = new ListLatestDeploymentsCommand(RepositoryFactory, FileSystem, ClientFactory, CommandOutputProvider); var dashboardResources = new DashboardResource { Items = new List <DashboardItemResource> { new DashboardItemResource { EnvironmentId = "environmentid1", ProjectId = "projectaid", TenantId = "tenantid1", ReleaseId = "Release1" }, new DashboardItemResource { EnvironmentId = "environmentid1", ProjectId = "projectaid", TenantId = "tenantid2", ReleaseId = "Release2" } }, Tenants = new List <DashboardTenantResource> { new DashboardTenantResource { Id = "tenantid1", Name = "tenant1" } } }; Repository.Projects.FindByNames(Arg.Any <IEnumerable <string> >()) .Returns(Task.FromResult( new List <ProjectResource> { new ProjectResource { Name = "ProjectA", Id = "projectaid" } })); Repository.Environments.FindAll() .Returns(Task.FromResult( new List <EnvironmentResource> { new EnvironmentResource { Name = "EnvA", Id = "environmentid1" } })); Repository.Releases.Get(Arg.Is("Release1")).Returns(new ReleaseResource { Version = "0.0.1" }); Repository.Releases.Get(Arg.Is("Release2")).Returns(new ReleaseResource { Version = "V1.0.0" }); Repository.Dashboards.GetDynamicDashboard(Arg.Any <string[]>(), Arg.Any <string[]>()).ReturnsForAnyArgs(dashboardResources); }
private void ArrangeDashboardData() { var repo = _container.Resolve <IOctopusRepository>(); repo.Machines.FindByName(MachineName).Returns(new MachineResource { Id = MachineId }); repo.Environments.FindByName(_config.TentacleEnvironment).Returns(new EnvironmentResource { Id = EnvironmentId }); var dashboard = new DashboardResource { Items = new List <DashboardItemResource>() }; dashboard.Items.Add(new DashboardItemResource { EnvironmentId = "ignore" }); dashboard.Items.Add(new DashboardItemResource { EnvironmentId = EnvironmentId, ReleaseId = ReleaseId }); repo.Dashboards.GetDashboard().Returns(dashboard); repo.Deployments.Create(null).ReturnsForAnyArgs(new DeploymentResource { TaskId = TaskId }); repo.Tasks.Get(TaskId).Returns(new TaskResource { State = TaskState.Success }); }
public async Task Request() { projectsById = await LoadProjects().ConfigureAwait(false); projectsFilter = projectsById.Keys.ToArray(); environmentsById = await LoadEnvironments().ConfigureAwait(false); environmentsFilter = environmentsById.Keys.ToArray(); commandOutputProvider.Debug("Loading dashboard..."); dashboard = await Repository.Dashboards.GetDynamicDashboard(projectsFilter, environmentsFilter).ConfigureAwait(false); tenantsById = dashboard.Tenants.ToDictionary(t => t.Id, t => t.Name); dashboardRelatedResourceses = new Dictionary <DashboardItemResource, DeploymentRelatedResources>(); foreach (var dashboardItem in dashboard.Items) { var drr = new DeploymentRelatedResources(); drr.ReleaseResource = await Repository.Releases.Get(dashboardItem.ReleaseId).ConfigureAwait(false); if (!string.IsNullOrEmpty(dashboardItem.ChannelId)) { drr.ChannelResource = await Repository.Channels.Get(dashboardItem.ChannelId).ConfigureAwait(false); } dashboardRelatedResourceses[dashboardItem] = drr; } }
public IActionResult GetDashboard() { try { var dash = new DashboardResource(); var user = _userRepository.GetStudent(GetUserId()); var currentSemester = Repository.GetCurrentSemester(); dash.CurrentSemesterName = currentSemester.Name; if (User.IsInRole(RoleReference.Student)) { dash.Reviewer = user.Reviewer?.FullName; dash.Supervisor = user.Supervisor?.FullName; } if (User.IsInRole(RoleReference.Teacher) || User.IsInRole(RoleReference.Admin)) { dash.NumberOfStudents = _userRepository.GetStudentsByTeacher(user.Id, true).Count; } return(Ok(dash)); } catch (Exception e) { return(BadRequest()); } }
private IEnumerable <DeploymentResult> ManualStepDeployments(DashboardResource dashboard) { var items = from i in dashboard.Items where !i.HasWarningsOrErrors && i.HasPendingInterruptions && !i.IsCompleted select i.ToDeploymentResult(dashboard, DeploymentStatus.ManualStep); if (items.Any()) { var currentItems = new List <DeploymentResult>(); foreach (var item in items) { var interruptions = _repository.Interruptions.List(regardingDocumentId: item.TaskId, pendingOnly: true); if (interruptions.Items.Any(i => i.Created >= _lastElapsed)) { item.EventTime = interruptions.Items.Where(i => i.Created >= _lastElapsed).OrderByDescending(i => i.Created).Select(i => i.Created).First(); currentItems.Add(item); } } return(currentItems); } return(items); }
/// <summary> /// Get a component for an environment /// </summary> /// <param name="dashboard"></param> /// <param name="environmentId"></param> /// <param name="projectId"></param> /// <param name="componentFilter"></param> /// <returns></returns> private Component GetComponentForEnvironment(DashboardResource dashboard, string environmentId, string projectId, ComponentFilter componentFilter) { var dashboardItemResources = dashboard.Items .Where(x => x.EnvironmentId == environmentId && x.ProjectId == projectId); var dashboardItemResource = dashboardItemResources.FirstOrDefault(); if (dashboardItemResource == null || GetSemanticVersionOrNull(dashboardItemResource.ReleaseVersion) == null) { return(null); } var componentDeployedOnEnvironmentFromDuration = dashboardItemResource.CompletedTime - dashboardItemResource.QueueTime; var healthy = dashboardItemResource.State == TaskState.Success; var release = _repository.Releases.Get(dashboardItemResource.ReleaseId); var projectVariables = _repository.VariableSets.Get(release.ProjectVariableSetSnapshotId); var componentDependancies = GetComponentDependancies(componentFilter, projectVariables, dashboardItemResource.ReleaseId); var component = new Component { Healthy = healthy, Version = new SemVer(dashboardItemResource.ReleaseVersion), DeploymentDuration = componentDeployedOnEnvironmentFromDuration, Dependancies = componentDependancies }; return(component); }
private static void ProcessDeployments(object source, ElapsedEventArgs e) { dashboard = octopusServer.Dashboard; var environments = GetMatchingEnvironments(dashboard); var projects = GetMatchingProjects(dashboard); var filteredDeployments = FilterDeploymentsByPreference(dashboard, projects, environments);; ProcessDeployments(filteredDeployments, environments, projects); }
private IEnumerable <DeploymentResult> FailedDeployments(DashboardResource dashboard) { var items = from i in dashboard.Items from p in _failedBuilds where i.ProjectId == p.ProjectId && i.EnvironmentId == p.EnvironmentId && ErrorStates.Contains(i.State) && i.HasWarningsOrErrors && p.HasWarningsOrErrors && i.CompletedTime >= _lastElapsed select i.ToDeploymentResult(dashboard, i.State.ToDeploymentStatus()); return(items); }
private IEnumerable <DeploymentResult> FixedDeployments(DashboardResource dashboard) { var items = from i in dashboard.Items from p in _failedBuilds where i.ProjectId == p.ProjectId && i.EnvironmentId == p.EnvironmentId && i.State == TaskState.Success && !i.HasWarningsOrErrors && p.HasWarningsOrErrors && i.CompletedTime >= _lastElapsed select i.ToDeploymentResult(dashboard, DeploymentStatus.Fixed); return(items); }
public virtual void Setup() { dashboard = new DashboardResource { Environments = new List <DashboardEnvironmentResource> { new DashboardEnvironmentResource { Id = "1234", Name = "1234" }, }, Projects = new List <DashboardProjectResource> { new DashboardProjectResource { Id = "1234", Name = "1234", } }, Id = "1234", Items = new List <DashboardItemResource>(), }; Mock <IDashboardRepository> dashboardMock = new Mock <IDashboardRepository>(); dashboardMock.Setup(d => d.GetDashboard()).Returns(dashboard); Mock <IInterruptionRepository> interruptionMock = new Mock <IInterruptionRepository>(); interruptionMock.Setup(i => i.List(It.IsAny <int>(), true, It.IsAny <string>())).Returns((int i, bool pending, string t) => new ResourceCollection <InterruptionResource>(new List <InterruptionResource> { new InterruptionResource { TaskId = t, Id = t, IsPending = pending, Created = DateTime.Now, } }, new LinkCollection())); Mock <IOctopusRepository> repoMock = new Mock <IOctopusRepository>(); repoMock.SetupGet(r => r.Dashboards).Returns(dashboardMock.Object); repoMock.SetupGet(r => r.Interruptions).Returns(interruptionMock.Object); adapter = new OctopusAdapter(repoMock.Object, 15000); adapter.DeploymentSummaryChanged += Adapter_DeploymentSummaryChanged; }
private IEnumerable <DeploymentResult> NewFailedDeployments(DashboardResource dashboard) { var items = from i in dashboard.Items from p in _failedBuilds where i.ProjectId == p.ProjectId && i.EnvironmentId == p.EnvironmentId && ErrorStates.Contains(i.State) && i.HasWarningsOrErrors && !p.HasWarningsOrErrors && i.CompletedTime >= _lastElapsed select i.ToDeploymentResult(dashboard, i.State.ToDeploymentStatus(100)); // Get any first-time builds items = items.Union(dashboard.Items.Where(i => ErrorStates.Contains(i.State) && i.HasWarningsOrErrors && i.CompletedTime >= _lastElapsed && !_failedBuilds.Any(p => i.ProjectId == p.ProjectId && i.EnvironmentId == p.EnvironmentId)).Select(i => i.ToDeploymentResult(dashboard, DeploymentStatus.FailedNew))); return(items); }
/// <summary> /// Get component for a branch. If release does not exist for branch then master branch is assumed. /// </summary> /// <param name="environmentId"></param> /// <param name="projectId"></param> /// <param name="branch"></param> /// <param name="dashboard"></param> /// <param name="componentFilter"></param> /// <returns></returns> private Component GetComponentForBranch(DashboardResource dashboard, string environmentId, string projectId, string branch, ComponentFilter componentFilter) { var releaseResources = GetReleaseResources(projectId); if (branch == null || branch.Equals("Master", StringComparison.InvariantCultureIgnoreCase)) { branch = string.Empty; } //If we dont have any release in a branch assume master if (!string.IsNullOrEmpty(branch) && releaseResources.All(x => GetSemanticVersionOrNull(x.Version)?.SpecialVersion != branch)) { branch = string.Empty; } //Get release for branch var releaseResource = releaseResources.FirstOrDefault(x => GetSemanticVersionOrNull(x.Version)?.SpecialVersion == branch); if (releaseResource == null) { return(null); } // No other way to calculate duration otherwise :< var dashboardItemResource = GetClosestMatchingDashboardItemResource(dashboard, environmentId, projectId, branch); var healthy = dashboardItemResource != null && dashboardItemResource.State == TaskState.Success; var componentDeployedOnEnvironmentFromDuration = dashboardItemResource == null ? null : dashboardItemResource.CompletedTime - dashboardItemResource.QueueTime; var projectVariables = _repository.VariableSets.Get(releaseResource.ProjectVariableSetSnapshotId); var componentDependancies = GetComponentDependancies(componentFilter, projectVariables, releaseResource.Id); var component = new Component { Healthy = healthy, Version = new SemVer(releaseResource.Version), DeploymentDuration = componentDeployedOnEnvironmentFromDuration, Dependancies = componentDependancies }; return(component); }
private Dictionary <DeploymentStatus, int> GetDeploymentSummary(DashboardResource dashboard) { var results = dashboard.Items.Where(i => i.IsCurrent && (i.IsCompleted || !i.HasPendingInterruptions)).GroupBy(i => i.State).ToDictionary(g => g.Key.ToDeploymentStatus(), g => g.Count()); int manualSteps = dashboard.Items.Count(i => i.IsCurrent && !i.IsCompleted && i.HasPendingInterruptions && !i.HasWarningsOrErrors); if (manualSteps > 0) { results.Add(DeploymentStatus.ManualStep, manualSteps); } int guidedFailures = dashboard.Items.Count(i => i.IsCurrent && !i.IsCompleted && i.HasPendingInterruptions && i.HasWarningsOrErrors); if (guidedFailures > 0) { results.Add(DeploymentStatus.GuidedFailure, guidedFailures); } return(results); }
private void before_each() { var environment = A.Fake <ISnapshotEnvironment>(x => x.Strict()); var repository = A.Fake <IOctopusRepository>(x => x.Strict()); var componentBuilder = A.Fake <IBuildSnapshotComponents>(x => x.Strict()); _builder = new SnapshotComponentVersionBuilder(environment, repository, componentBuilder); var environmentId = "Env01"; var projectId = "Proj01"; _releaseId = "Release01"; _releaseVersion = "ReleaseVersion01"; A.CallTo(() => environment.Id).Returns(environmentId); _expectedComponent = new SnapshotComponent(projectId, "project name", "project group name"); var components = new List <SnapshotComponent> { _expectedComponent }; A.CallTo(() => componentBuilder.Build()).Returns(components); _itemResource = new DashboardItemResource { EnvironmentId = environmentId, ProjectId = projectId, ReleaseId = _releaseId, ReleaseVersion = _releaseVersion }; var dashboardResource = new DashboardResource { Items = new List <DashboardItemResource> { _itemResource } }; var dashboardRepository = A.Fake <IDashboardRepository>(x => x.Strict()); A.CallTo(() => dashboardRepository.GetDashboard()).Returns(dashboardResource); A.CallTo(() => repository.Dashboards).Returns(dashboardRepository); }
public void GivenAnAdapterWithABrokenConnection(bool brokenCconnection) { dashboard = new DashboardResource { Environments = new List <DashboardEnvironmentResource> { new DashboardEnvironmentResource { Id = "1234", Name = "1234" }, }, Projects = new List <DashboardProjectResource> { new DashboardProjectResource { Id = "1234", Name = "1234", } }, Id = "1234", Items = new List <DashboardItemResource>(), PreviousItems = new List <DashboardItemResource>(), }; Mock <IOctopusRepository> repoMock = new Mock <IOctopusRepository>(); repoMock.SetupGet(r => r.Dashboards).Returns(dashboardMock.Object); adapter = new OctopusAdapter(repoMock.Object, 15000); if (brokenCconnection) { dashboardMock.Setup(d => d.GetDashboard()).Throws(new Exception("Test")); adapter.Poll(); } adapter.ConnectionError += Adapter_ConnectionError; adapter.ConnectionRestored += Adapter_ConnectionRestored; }
public static List <Project> ToCCTrayProjects(this DashboardResource dashboard, List <DeploymentTask> previousDeploymentTasks) { var projects = new List <Project>(); // Get the project and it's name from the first project in the dashboard var project = dashboard.Projects.FirstOrDefault(); var projectName = (project != null ? project.Name : string.Empty); foreach (var item in dashboard.Items) { // Get the environment and its name for the current item var environment = dashboard.Environments.FirstOrDefault(x => x.Id == item.EnvironmentId); var environmentName = (environment != null ? environment.Name : string.Empty); // Get the previous deployment task for the item's environment var previousDeploymentTask = previousDeploymentTasks.FirstOrDefault(x => x.EnvironmentId == item.EnvironmentId); projects.Add(item.ToProject(item.ToDeploymentTask(projectName, environmentName), previousDeploymentTask)); } return(projects); }
private DashboardItemResource GetClosestMatchingDashboardItemResource(DashboardResource dashboard, string environmentId, string projectId, string branch) { var dashboardItemResources = dashboard.Items .Where(x => x.ProjectId == projectId); if (dashboardItemResources.Any(x => x.EnvironmentId == environmentId)) { dashboardItemResources = dashboardItemResources .Where(x => x.EnvironmentId == environmentId); } if (dashboardItemResources.Any(x => GetSemanticVersionOrNull(x.ReleaseVersion)?.SpecialVersion == branch)) { dashboardItemResources = dashboardItemResources .Where(x => GetSemanticVersionOrNull(x.ReleaseVersion)?.SpecialVersion == branch); } var dashboardItemResource = dashboardItemResources .FirstOrDefault(); return(dashboardItemResource); }
private void before_each() { _dashboardResource = new DashboardResource { Items = new List <DashboardItemResource> { new DashboardItemResource { EnvironmentId = "Environment01", ProjectId = "Project01.1", ReleaseId = "Release01.1", State = TaskState.Success }, new DashboardItemResource { EnvironmentId = "Environment01", ProjectId = "Project01.2", ReleaseId = "Release01.2", State = TaskState.Failed }, new DashboardItemResource { EnvironmentId = "Environment02", ProjectId = "Project02", ReleaseId = "Release02", State = TaskState.Success } } }; _dashboard = A.Fake <IDashboardRepository>(x => x.Strict()); A.CallTo(() => _dashboard.GetDashboard()).Returns(_dashboardResource); _repository = A.Fake <IOctopusRepository>(x => x.Strict()); A.CallTo(() => _repository.Dashboards).Returns(_dashboard); _validator = new SnapshotStepValidator(_repository); }
public virtual void Setup() { dashboard = new DashboardResource { Environments = new List <DashboardEnvironmentResource> { new DashboardEnvironmentResource { Id = "1234", Name = "1234" }, }, Projects = new List <DashboardProjectResource> { new DashboardProjectResource { Id = "1234", Name = "1234", } }, Id = "1234", }; Mock <IDashboardRepository> dashboardMock = new Mock <IDashboardRepository>(); dashboardMock.Setup(d => d.GetDashboard()).Returns(dashboard); Mock <IOctopusRepository> repoMock = new Mock <IOctopusRepository>(); repoMock.SetupGet(r => r.Dashboards).Returns(dashboardMock.Object); adapter = new OctopusAdapter(repoMock.Object, 15000); eventFiredCount = 0; deploymentEventArgs = null; }
/// <summary> /// Converts a <see cref="DashboardItemResource"/> to a <see cref="DeploymentResult"/>. /// </summary> /// <param name="item">The item to convert.</param> /// <param name="dashboard">The dashboard containing all project and environment information.</param> /// <param name="status">The deployment status to set.</param> /// <returns>A new deployment result.</returns> public static DeploymentResult ToDeploymentResult(this DashboardItemResource item, DashboardResource dashboard, DeploymentStatus status) { return(new DeploymentResult { Status = status, ErrorMessage = item.ErrorMessage, Version = item.ReleaseVersion, Project = dashboard.Projects.Where(p => p.Id == item.ProjectId).Select(p => p.ToProject()).SingleOrDefault(), Environment = dashboard.Environments.Where(e => e.Id == item.EnvironmentId).Select(e => e.ToDeploymentEnvironment()).SingleOrDefault(), TaskId = item.TaskId, DeploymentId = item.DeploymentId, EventTime = item.CompletedTime ?? DateTimeOffset.Now, }); }
public List <OutputOctopusDashboardEntry> GetOctopusDashboard(DashboardResource rawDashboard, string[] projectName, string[] environmentName, string[] deploymentStatus) { var list = new List <OutputOctopusDashboardEntry>(); var environments = new List <DashboardEnvironmentResource>(); var projects = new List <DashboardProjectResource>(); environments = environmentName != null?rawDashboard.Environments.Where(e => environmentName.Any(en => String.Equals(en, e.Name, StringComparison.CurrentCultureIgnoreCase))).ToList() : rawDashboard.Environments; projects = projectName != null?rawDashboard.Projects.Where(p => projectName.Any(pn => String.Equals(pn, p.Name, StringComparison.CurrentCultureIgnoreCase))).ToList() : rawDashboard.Projects; foreach (var deployment in rawDashboard.Items) { var project = projects.FirstOrDefault(p => p.Id == deployment.ProjectId); var environment = environments.FirstOrDefault(e => e.Id == deployment.EnvironmentId); if (deploymentStatus != null && !deploymentStatus.Contains(deployment.State.ToString())) { continue; } if (projects.All(p => p.Id != deployment.ProjectId)) { continue; } if (environments.All(e => e.Id != deployment.EnvironmentId)) { continue; } DateTime endDate; string duration; if (deployment.CompletedTime != null) { TimeSpan?durationSpan = deployment.CompletedTime - deployment.Created; duration = string.Format("{0:D2}:{1:D2}:{2:D2}", durationSpan.Value.Hours, durationSpan.Value.Minutes, durationSpan.Value.Seconds); endDate = deployment.CompletedTime.Value.DateTime; } else { endDate = DateTime.Now.Date; TimeSpan?durationSpan = endDate - deployment.Created; duration = string.Format("{0:D2}:{1:D2}:{2:D2}", durationSpan.Value.Hours, durationSpan.Value.Minutes, durationSpan.Value.Seconds); } list.Add(new OutputOctopusDashboardEntry() { ProjectName = project.Name, EnvironmentName = environment.Name, ReleaseVersion = deployment.ReleaseVersion, DeploymentStatus = deployment.State.ToString(), StartDate = deployment.QueueTime.DateTime, EndDate = endDate, Duration = duration, IsCompleted = deployment.IsCompleted, HasPendingInterruptions = deployment.HasPendingInterruptions, HasWarninsOrErrors = deployment.HasWarningsOrErrors }); } return(list); }
private IDictionary <string, List <string> > ToFriendlyProjectEnvironments(IDictionary <string, ReferenceCollection> tenantProjectEnvironments, DashboardResource dashboardResource) { var friendlyProjectEnvironments = new Dictionary <string, List <string> >(); var dashboard = dashboardResource; foreach (var tPE in tenantProjectEnvironments) { var projectName = dashboard.Projects.FirstOrDefault(x => x.Id == tPE.Key)?.Name; var environmentNames = new List <string>(); environmentNames.AddRange(dashboard.Environments.Where(e => tPE.Value.Contains(e.Id)).Select(e => e.Name).ToList()); friendlyProjectEnvironments.Add(projectName, environmentNames); } return(friendlyProjectEnvironments); }
private static IEnumerable <DashboardProjectResource> GetMatchingProjects(DashboardResource dashboard) { return(dashboard.Projects.Where(x => preferences.Projects.Select(project => project.Name).Contains(x.Name))); }
private static IEnumerable <DashboardEnvironmentResource> GetMatchingEnvironments(DashboardResource dashboard) { var environmentsOfInterest = preferences.Projects.SelectMany(project => project.Environments).Select(x => x.Name); var environments = dashboard.Environments.Where(environmet => environmentsOfInterest.Contains(environmet.Name)); return(environments); }
private static IEnumerable <DashboardItemResource> FilterDeploymentsByPreference(DashboardResource dashboard, IEnumerable <DashboardProjectResource> projects, IEnumerable <DashboardEnvironmentResource> environments) { var matches = dashboard.Items.Where(x => projects.Any(project => project.Id == x.ProjectId)); matches = matches.Where(x => environments.Any(environment => environment.Id == x.EnvironmentId)); System.Console.WriteLine("Found {0} matching projects", matches.Count()); return(matches.OrderBy(project => project.ProjectId)); }