func (o *perDeploymentConfigResolver) Resolve() ([]*kapi.ReplicationController, error) {
deploymentConfigs, err := o.dataSet.ListDeploymentConfigs()
if err != nil {
return nil, err
}
completeStates := sets.NewString(string(deployapi.DeploymentStatusComplete))
failedStates := sets.NewString(string(deployapi.DeploymentStatusFailed))
results := []*kapi.ReplicationController{}
for _, deploymentConfig := range deploymentConfigs {
deployments, err := o.dataSet.ListDeploymentsByDeploymentConfig(deploymentConfig)
if err != nil {
return nil, err
}
completeDeployments, failedDeployments := []*kapi.ReplicationController{}, []*kapi.ReplicationController{}
for _, deployment := range deployments {
status := deployutil.DeploymentStatusFor(deployment)
if completeStates.Has(string(status)) {
completeDeployments = append(completeDeployments, deployment)
} else if failedStates.Has(string(status)) {
failedDeployments = append(failedDeployments, deployment)
}
}
sort.Sort(deployutil.ByMostRecent(completeDeployments))
sort.Sort(deployutil.ByMostRecent(failedDeployments))
if o.keepComplete >= 0 && o.keepComplete < len(completeDeployments) {
results = append(results, completeDeployments[o.keepComplete:]...)
}
if o.keepFailed >= 0 && o.keepFailed < len(failedDeployments) {
results = append(results, failedDeployments[o.keepFailed:]...)
}
}
return results, nil
}
func TestPerDeploymentConfigResolver(t *testing.T) {
deploymentStatusOptions := []deployapi.DeploymentStatus{
deployapi.DeploymentStatusComplete,
deployapi.DeploymentStatusFailed,
deployapi.DeploymentStatusNew,
deployapi.DeploymentStatusPending,
deployapi.DeploymentStatusRunning,
}
deploymentConfigs := []*deployapi.DeploymentConfig{
mockDeploymentConfig("a", "deployment-config-1"),
mockDeploymentConfig("b", "deployment-config-2"),
}
deploymentsPerStatus := 100
deployments := []*kapi.ReplicationController{}
for _, deploymentConfig := range deploymentConfigs {
for _, deploymentStatusOption := range deploymentStatusOptions {
for i := 0; i < deploymentsPerStatus; i++ {
deployment := withStatus(mockDeployment(deploymentConfig.Namespace, fmt.Sprintf("%v-%v-%v", deploymentConfig.Name, deploymentStatusOption, i), deploymentConfig), deploymentStatusOption)
deployments = append(deployments, deployment)
}
}
}
now := unversioned.Now()
for i := range deployments {
creationTimestamp := unversioned.NewTime(now.Time.Add(-1 * time.Duration(i) * time.Hour))
deployments[i].CreationTimestamp = creationTimestamp
}
// test number to keep at varying ranges
for keep := 0; keep < deploymentsPerStatus*2; keep++ {
dataSet := NewDataSet(deploymentConfigs, deployments)
expectedNames := sets.String{}
deploymentCompleteStatusFilterSet := sets.NewString(string(deployapi.DeploymentStatusComplete))
deploymentFailedStatusFilterSet := sets.NewString(string(deployapi.DeploymentStatusFailed))
for _, deploymentConfig := range deploymentConfigs {
deploymentItems, err := dataSet.ListDeploymentsByDeploymentConfig(deploymentConfig)
if err != nil {
t.Errorf("Unexpected err %v", err)
}
completedDeployments, failedDeployments := []*kapi.ReplicationController{}, []*kapi.ReplicationController{}
for _, deployment := range deploymentItems {
status := deployment.Annotations[deployapi.DeploymentStatusAnnotation]
if deploymentCompleteStatusFilterSet.Has(status) {
completedDeployments = append(completedDeployments, deployment)
} else if deploymentFailedStatusFilterSet.Has(status) {
failedDeployments = append(failedDeployments, deployment)
}
}
sort.Sort(deployutil.ByMostRecent(completedDeployments))
sort.Sort(deployutil.ByMostRecent(failedDeployments))
purgeCompleted := []*kapi.ReplicationController{}
purgeFailed := []*kapi.ReplicationController{}
if keep >= 0 && keep < len(completedDeployments) {
purgeCompleted = completedDeployments[keep:]
}
if keep >= 0 && keep < len(failedDeployments) {
purgeFailed = failedDeployments[keep:]
}
for _, deployment := range purgeCompleted {
expectedNames.Insert(deployment.Name)
}
for _, deployment := range purgeFailed {
expectedNames.Insert(deployment.Name)
}
}
resolver := NewPerDeploymentConfigResolver(dataSet, keep, keep)
results, err := resolver.Resolve()
if err != nil {
t.Errorf("Unexpected error %v", err)
}
foundNames := sets.String{}
for _, result := range results {
foundNames.Insert(result.Name)
}
if len(foundNames) != len(expectedNames) || !expectedNames.HasAll(foundNames.List()...) {
expectedValues := expectedNames.List()
actualValues := foundNames.List()
sort.Strings(expectedValues)
sort.Strings(actualValues)
t.Errorf("keep %v\n, expected \n\t%v\n, actual \n\t%v\n", keep, expectedValues, actualValues)
}
}
}
