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