func (v *validator) Validate(manifest Manifest, releaseSetManifest birelsetmanifest.Manifest) error {
errs := []error{}
cpiJobName := manifest.Template.Name
if v.isBlank(cpiJobName) {
errs = append(errs, bosherr.Error("cloud_provider.template.name must be provided"))
}
cpiReleaseName := manifest.Template.Release
if v.isBlank(cpiReleaseName) {
errs = append(errs, bosherr.Error("cloud_provider.template.release must be provided"))
}
_, found := releaseSetManifest.FindByName(cpiReleaseName)
if !found {
errs = append(errs, bosherr.Errorf("cloud_provider.template.release '%s' must refer to a release in releases", cpiReleaseName))
}
if len(errs) > 0 {
return bosherr.NewMultiError(errs...)
}
return nil
}
func (c *deploymentDeleter) DeleteDeployment(stage biui.Stage) (err error) {
c.ui.PrintLinef("Deployment state: '%s'", c.deploymentStateService.Path())
if !c.deploymentStateService.Exists() {
c.ui.PrintLinef("No deployment state file found.")
return nil
}
deploymentState, err := c.deploymentStateService.Load()
if err != nil {
return bosherr.WrapError(err, "Loading deployment state")
}
target, err := c.targetProvider.NewTarget()
if err != nil {
return bosherr.WrapError(err, "Determining installation target")
}
err = c.tempRootConfigurator.PrepareAndSetTempRoot(target.TmpPath(), c.logger)
if err != nil {
return bosherr.WrapError(err, "Setting temp root")
}
defer func() {
err := c.releaseManager.DeleteAll()
if err != nil {
c.logger.Warn(c.logTag, "Deleting all extracted releases: %s", err.Error())
}
}()
var installationManifest biinstallmanifest.Manifest
err = stage.PerformComplex("validating", func(stage biui.Stage) error {
var releaseSetManifest birelsetmanifest.Manifest
releaseSetManifest, installationManifest, err = c.releaseSetAndInstallationManifestParser.ReleaseSetAndInstallationManifest(c.deploymentManifestPath)
if err != nil {
return err
}
cpiReleaseName := installationManifest.Template.Release
cpiReleaseRef, found := releaseSetManifest.FindByName(cpiReleaseName)
if !found {
return bosherr.Errorf("installation release '%s' must refer to a release in releases", cpiReleaseName)
}
err = c.releaseFetcher.DownloadAndExtract(cpiReleaseRef, stage)
if err != nil {
return err
}
err = c.cpiInstaller.ValidateCpiRelease(installationManifest, stage)
return err
})
if err != nil {
return err
}
err = c.cpiInstaller.WithInstalledCpiRelease(installationManifest, target, stage, func(localCpiInstallation biinstall.Installation) error {
return localCpiInstallation.WithRunningRegistry(c.logger, stage, func() error {
err = c.findAndDeleteDeployment(stage, localCpiInstallation, deploymentState.DirectorID, installationManifest.Mbus)
if err != nil {
return err
}
return stage.Perform("Uninstalling local artifacts for CPI and deployment", func() error {
err := c.cpiUninstaller.Uninstall(localCpiInstallation.Target())
if err != nil {
return err
}
return c.deploymentStateService.Cleanup()
})
})
})
return err
}
func (v *validator) Validate(deploymentManifest Manifest, releaseSetManifest birelsetmanifest.Manifest) error {
errs := []error{}
if v.isBlank(deploymentManifest.Name) {
errs = append(errs, bosherr.Error("name must be provided"))
}
networksErrors := v.validateNetworks(deploymentManifest.Networks)
errs = append(errs, networksErrors...)
for idx, resourcePool := range deploymentManifest.ResourcePools {
if v.isBlank(resourcePool.Name) {
errs = append(errs, bosherr.Errorf("resource_pools[%d].name must be provided", idx))
}
if v.isBlank(resourcePool.Network) {
errs = append(errs, bosherr.Errorf("resource_pools[%d].network must be provided", idx))
} else if _, ok := v.networkNames(deploymentManifest)[resourcePool.Network]; !ok {
errs = append(errs, bosherr.Errorf("resource_pools[%d].network must be the name of a network", idx))
}
if v.isBlank(resourcePool.Stemcell.URL) {
errs = append(errs, bosherr.Errorf("resource_pools[%d].stemcell.url must be provided", idx))
}
matched, err := regexp.MatchString("^(file|http|https)://", resourcePool.Stemcell.URL)
if err != nil || !matched {
errs = append(errs, bosherr.Errorf("resource_pools[%d].stemcell.url must be a valid URL (file:// or http(s)://)", idx))
}
if strings.HasPrefix(resourcePool.Stemcell.URL, "http") && v.isBlank(resourcePool.Stemcell.SHA1) {
errs = append(errs, bosherr.Errorf("resource_pools[%d].stemcell.sha1 must be provided for http URL", idx))
}
}
for idx, diskPool := range deploymentManifest.DiskPools {
if v.isBlank(diskPool.Name) {
errs = append(errs, bosherr.Errorf("disk_pools[%d].name must be provided", idx))
}
if diskPool.DiskSize <= 0 {
errs = append(errs, bosherr.Errorf("disk_pools[%d].disk_size must be > 0", idx))
}
}
if len(deploymentManifest.Jobs) > 1 {
errs = append(errs, bosherr.Error("jobs must be of size 1"))
}
for idx, job := range deploymentManifest.Jobs {
if v.isBlank(job.Name) {
errs = append(errs, bosherr.Errorf("jobs[%d].name must be provided", idx))
}
if job.PersistentDisk < 0 {
errs = append(errs, bosherr.Errorf("jobs[%d].persistent_disk must be >= 0", idx))
}
if job.PersistentDiskPool != "" {
if _, ok := v.diskPoolNames(deploymentManifest)[job.PersistentDiskPool]; !ok {
errs = append(errs, bosherr.Errorf("jobs[%d].persistent_disk_pool must be the name of a disk pool", idx))
}
}
if job.Instances < 0 {
errs = append(errs, bosherr.Errorf("jobs[%d].instances must be >= 0", idx))
}
if len(job.Networks) == 0 {
errs = append(errs, bosherr.Errorf("jobs[%d].networks must be a non-empty array", idx))
}
if v.isBlank(job.ResourcePool) {
errs = append(errs, bosherr.Errorf("jobs[%d].resource_pool must be provided", idx))
} else {
if _, ok := v.resourcePoolNames(deploymentManifest)[job.ResourcePool]; !ok {
errs = append(errs, bosherr.Errorf("jobs[%d].resource_pool must be the name of a resource pool", idx))
}
}
errs = append(errs, v.validateJobNetworks(job.Networks, deploymentManifest.Networks, idx)...)
if job.Lifecycle != "" && job.Lifecycle != JobLifecycleService {
errs = append(errs, bosherr.Errorf("jobs[%d].lifecycle must be 'service' ('%s' not supported)", idx, job.Lifecycle))
}
templateNames := map[string]struct{}{}
for templateIdx, template := range job.Templates {
if v.isBlank(template.Name) {
errs = append(errs, bosherr.Errorf("jobs[%d].templates[%d].name must be provided", idx, templateIdx))
}
if _, found := templateNames[template.Name]; found {
errs = append(errs, bosherr.Errorf("jobs[%d].templates[%d].name '%s' must be unique", idx, templateIdx, template.Name))
}
templateNames[template.Name] = struct{}{}
if v.isBlank(template.Release) {
errs = append(errs, bosherr.Errorf("jobs[%d].templates[%d].release must be provided", idx, templateIdx))
} else {
_, found := releaseSetManifest.FindByName(template.Release)
if !found {
errs = append(errs, bosherr.Errorf("jobs[%d].templates[%d].release '%s' must refer to release in releases", idx, templateIdx, template.Release))
}
}
}
}
if len(errs) > 0 {
return bosherr.NewMultiError(errs...)
}
return nil
}