func (a DrainAction) determineParams(drainType DrainType, currentSpec boshas.V1ApplySpec, newSpecs []boshas.V1ApplySpec) (boshdrain.ScriptParams, error) {
var newSpec *boshas.V1ApplySpec
var params boshdrain.ScriptParams
if len(newSpecs) > 0 {
newSpec = &newSpecs[0]
}
switch drainType {
case DrainTypeStatus:
// Status was used in the past when dynamic drain was implemented in the Director.
// Now that we implement it in the agent, we should never get a call for this type.
return params, bosherr.Error("Unexpected call with drain type 'status'")
case DrainTypeUpdate:
if newSpec == nil {
return params, bosherr.Error("Drain update requires new spec")
}
params = boshdrain.NewUpdateParams(currentSpec, *newSpec)
case DrainTypeShutdown:
err := a.notifier.NotifyShutdown()
if err != nil {
return params, bosherr.WrapError(err, "Notifying shutdown")
}
params = boshdrain.NewShutdownParams(currentSpec, newSpec)
}
return params, nil
}
func (r concreteRunner) Run(action Action, payloadBytes []byte) (value interface{}, err error) {
payloadArgs, err := r.extractJSONArguments(payloadBytes)
if err != nil {
err = bosherr.WrapError(err, "Extracting json arguments")
return
}
actionValue := reflect.ValueOf(action)
runMethodValue := actionValue.MethodByName("Run")
if runMethodValue.Kind() != reflect.Func {
err = bosherr.Error("Run method not found")
return
}
runMethodType := runMethodValue.Type()
if r.invalidReturnTypes(runMethodType) {
err = bosherr.Error("Run method should return a value and an error")
return
}
methodArgs, err := r.extractMethodArgs(runMethodType, payloadArgs)
if err != nil {
err = bosherr.WrapError(err, "Extracting method arguments from payload")
return
}
values := runMethodValue.Call(methodArgs)
return r.extractReturns(values)
}
func (p linux) findRootDevicePathAndNumber() (string, int, error) {
mounts, err := p.diskManager.GetMountsSearcher().SearchMounts()
if err != nil {
return "", 0, bosherr.WrapError(err, "Searching mounts")
}
for _, mount := range mounts {
if mount.MountPoint == "/" && strings.HasPrefix(mount.PartitionPath, "/dev/") {
p.logger.Debug(logTag, "Found root partition: `%s'", mount.PartitionPath)
stdout, _, _, err := p.cmdRunner.RunCommand("readlink", "-f", mount.PartitionPath)
if err != nil {
return "", 0, bosherr.WrapError(err, "Shelling out to readlink")
}
rootPartition := strings.Trim(stdout, "\n")
p.logger.Debug(logTag, "Symlink is: `%s'", rootPartition)
validRootPartition := regexp.MustCompile(`^/dev/[a-z]+\d$`)
if !validRootPartition.MatchString(rootPartition) {
return "", 0, bosherr.Error("Root partition has an invalid name" + rootPartition)
}
devNum, err := strconv.Atoi(rootPartition[len(rootPartition)-1:])
if err != nil {
return "", 0, bosherr.WrapError(err, "Parsing device number failed")
}
devPath := rootPartition[:len(rootPartition)-1]
return devPath, devNum, nil
}
}
return "", 0, bosherr.Error("Getting root partition device")
}
func (v SyntaxValidator) validateJob(job *Job) error {
if job.Name == "" {
return bosherr.Error("Missing job name")
}
if job.Template != nil {
return bosherr.Error("'template' is deprecated in favor of 'templates'")
}
err := v.validateUpdate(&job.Update)
if err != nil {
return bosherr.WrapError(err, "Update")
}
props, err := bputil.NewStringKeyed().ConvertMap(job.PropertiesRaw)
if err != nil {
return bosherr.WrapError(err, "Properties")
}
job.Properties = props
for i, na := range job.NetworkAssociations {
err := v.validateNetworkAssociation(&job.NetworkAssociations[i])
if err != nil {
return bosherr.WrapErrorf(err, "Network association %s (%d)", na.NetworkName, i)
}
}
return nil
}
func (p linux) findRootDevicePath() (string, error) {
mounts, err := p.diskManager.GetMountsSearcher().SearchMounts()
if err != nil {
return "", bosherr.WrapError(err, "Searching mounts")
}
for _, mount := range mounts {
if mount.MountPoint == "/" && strings.HasPrefix(mount.PartitionPath, "/dev/") {
p.logger.Debug(logTag, "Found root partition: `%s'", mount.PartitionPath)
stdout, _, _, err := p.cmdRunner.RunCommand("readlink", "-f", mount.PartitionPath)
if err != nil {
return "", bosherr.WrapError(err, "Shelling out to readlink")
}
rootPartition := strings.Trim(stdout, "\n")
p.logger.Debug(logTag, "Symlink is: `%s'", rootPartition)
validRootPartition := regexp.MustCompile(`^/dev/[a-z]+1$`)
if !validRootPartition.MatchString(rootPartition) {
return "", bosherr.Error("Root partition is not the first partition")
}
return strings.Trim(rootPartition, "1"), nil
}
}
return "", bosherr.Error("Getting root partition device")
}
func (r defaultNetworkResolver) GetDefaultNetwork() (boshsettings.Network, error) {
network := boshsettings.Network{}
routes, err := r.routesSearcher.SearchRoutes()
if err != nil {
return network, bosherr.WrapError(err, "Searching routes")
}
if len(routes) == 0 {
return network, bosherr.Error("No routes found")
}
for _, route := range routes {
if !route.IsDefault() {
continue
}
ip, err := r.ipResolver.GetPrimaryIPv4(route.InterfaceName)
if err != nil {
return network, bosherr.WrapErrorf(err, "Getting primary IPv4 for interface '%s'", route.InterfaceName)
}
return boshsettings.Network{
IP: ip.IP.String(),
Netmask: gonet.IP(ip.Mask).String(),
Gateway: route.Gateway,
}, nil
}
return network, bosherr.Error("Failed to find default route")
}
func (v SyntaxValidator) Validate() error {
if v.release.Name == "" {
return bosherr.Error("Missing release name")
}
if v.release.Version == "" {
return bosherr.Error("Missing release version")
}
if v.release.CommitHash == "" {
return bosherr.Error("Missing release commit_hash")
}
for i, job := range v.release.Jobs {
err := v.validateJob(&v.release.Jobs[i])
if err != nil {
return bosherr.WrapErrorf(err, "Job %s (%d)", job.Name, i)
}
}
for i, pkg := range v.release.Packages {
err := v.validatePkg(&v.release.Packages[i])
if err != nil {
return bosherr.WrapErrorf(err, "Package %s (%d)", pkg.Name, i)
}
}
return nil
}
func (c Config) validate() error {
if c.AssetsDir == "" {
return bosherr.Error("Must provide non-empty assets_dir")
}
if c.ReposDir == "" {
return bosherr.Error("Must provide non-empty repos_dir")
}
err := c.EventLog.Validate()
if err != nil {
return bosherr.WrapError(err, "Validating event_log configuration")
}
if c.Blobstore.Type != bpprov.BlobstoreConfigTypeLocal {
return bosherr.Error("Blobstore type must be local")
}
err = c.Blobstore.Validate()
if err != nil {
return bosherr.WrapError(err, "Validating blobstore configuration")
}
return nil
}
func (f SettingsSourceFactory) buildWithoutRegistry() (boshsettings.Source, error) {
var settingsSources []boshsettings.Source
for _, opts := range f.options.Sources {
var settingsSource boshsettings.Source
switch typedOpts := opts.(type) {
case HTTPSourceOptions:
return nil, bosherr.Error("HTTP source is not supported without registry")
case ConfigDriveSourceOptions:
settingsSource = NewConfigDriveSettingsSource(
typedOpts.DiskPaths,
typedOpts.MetaDataPath,
typedOpts.SettingsPath,
f.platform,
f.logger,
)
case FileSourceOptions:
return nil, bosherr.Error("File source is not supported without registry")
case CDROMSourceOptions:
settingsSource = NewCDROMSettingsSource(
typedOpts.FileName,
f.platform,
f.logger,
)
}
settingsSources = append(settingsSources, settingsSource)
}
return NewMultiSettingsSource(settingsSources...)
}
func (c BaremetalCreator) validate_arguments(memory int, processor int, disksize int, host string, domain string, ostype string, datacenter string) error {
if memory <= 0 {
return bosherr.Errorf("memory can not be negative: %d", memory)
}
if processor <= 0 {
return bosherr.Errorf("processor can not be negative: %d", processor)
}
if disksize <= 0 {
return bosherr.Errorf("disk size can not be negative: %d", disksize)
}
if host == "" {
return bosherr.Error("host can not be empty.")
}
if domain == "" {
return bosherr.Error("domain can not be empty.")
}
if ostype == "" {
return bosherr.Error("os type can not be empty.")
}
if datacenter == "" {
return bosherr.Error("data center can not be empty.")
}
return nil
}
// Precompile prepares release jobs to be later combined with instance properties
func (tc ConcreteTemplatesCompiler) Precompile(release bprel.Release) error {
var allPkgs []bprel.Package
for _, pkg := range release.Packages {
if pkg == nil {
// todo panic or should not be here?
return bosherr.Error("Expected release to not have nil package")
}
allPkgs = append(allPkgs, *pkg)
}
for _, pkg := range release.CompiledPackages {
if pkg == nil {
// todo panic or should not be here?
return bosherr.Error("Expected release to not have nil package")
}
allPkgs = append(allPkgs, *pkg)
}
for _, job := range release.Jobs {
jobRec, found, err := tc.jobsRepo.Find(job)
if err != nil {
return bosherr.WrapErrorf(err, "Finding job source blob %s", job.Name)
}
if !found {
blobID, fingerprint, err := tc.blobstore.Create(job.TarPath)
if err != nil {
return bosherr.WrapErrorf(err, "Creating job source blob %s", job.Name)
}
jobRec = bpjobsrepo.JobRecord{
BlobID: blobID,
SHA1: fingerprint,
}
err = tc.jobsRepo.Save(job, jobRec)
if err != nil {
return bosherr.WrapErrorf(err, "Saving job record %s", job.Name)
}
}
releaseJobRec, err := tc.tplToJobRepo.SaveForJob(release, job)
if err != nil {
return bosherr.WrapErrorf(err, "Saving release job %s", job.Name)
}
// todo associate to release instead
err = tc.runPkgsRepo.SaveAll(releaseJobRec, allPkgs)
if err != nil {
return bosherr.WrapErrorf(err, "Saving release job %s", job.Name)
}
}
return nil
}
func (f SettingsSourceFactory) buildWithRegistry() (boshsettings.Source, error) {
var metadataServices []MetadataService
digDNSResolver := NewDigDNSResolver(f.platform.GetRunner(), f.logger)
resolver := NewRegistryEndpointResolver(digDNSResolver)
for _, opts := range f.options.Sources {
var metadataService MetadataService
switch typedOpts := opts.(type) {
case HTTPSourceOptions:
metadataService = NewHTTPMetadataService(
typedOpts.URI,
typedOpts.Headers,
typedOpts.UserDataPath,
typedOpts.InstanceIDPath,
typedOpts.SSHKeysPath,
resolver,
f.platform,
f.logger,
)
case ConfigDriveSourceOptions:
metadataService = NewConfigDriveMetadataService(
resolver,
f.platform,
typedOpts.DiskPaths,
typedOpts.MetaDataPath,
typedOpts.UserDataPath,
f.logger,
)
case FileSourceOptions:
metadataService = NewFileMetadataService(
typedOpts.MetaDataPath,
typedOpts.UserDataPath,
typedOpts.SettingsPath,
f.platform.GetFs(),
f.logger,
)
case CDROMSourceOptions:
return nil, bosherr.Error("CDROM source is not supported when registry is used")
case InstanceMetadataSourceOptions:
return nil, bosherr.Error("Instance Metadata source is not supported when registry is used")
}
metadataServices = append(metadataServices, metadataService)
}
metadataService := NewMultiSourceMetadataService(metadataServices...)
registryProvider := NewRegistryProvider(metadataService, f.platform, f.options.UseServerName, f.platform.GetFs(), f.logger)
settingsSource := NewComplexSettingsSource(metadataService, registryProvider, f.logger)
return settingsSource, nil
}
func (vm SoftLayerVM) Delete(agentID string) error {
if strings.ToUpper(common.GetOSEnvVariable("OS_RELOAD_ENABLED", "TRUE")) == "FALSE" {
if strings.ToUpper(common.GetOSEnvVariable("DEL_NOT_ALLOWED", "FALSE")) == "FALSE" {
return vm.DeleteVM()
} else {
return bosherr.Error("DEL_NOT_ALLOWED is set to TRUE, the VM deletion reqeust is refused.")
}
}
err := bslcvmpool.InitVMPoolDB(bslcvmpool.DB_RETRY_TIMEOUT, bslcvmpool.DB_RETRY_INTERVAL, vm.logger)
if err != nil {
return bosherr.WrapError(err, "Failed to initialize VM pool DB")
}
db, err := bslcvmpool.OpenDB(bslcvmpool.SQLITE_DB_FILE_PATH)
if err != nil {
return bosherr.WrapError(err, "Opening DB")
}
vmInfoDB := bslcvmpool.NewVMInfoDB(vm.id, "", "", "", "", vm.logger, db)
defer vmInfoDB.CloseDB()
err = vmInfoDB.QueryVMInfobyID(bslcvmpool.DB_RETRY_TIMEOUT, bslcvmpool.DB_RETRY_INTERVAL)
if err != nil {
return bosherr.WrapError(err, fmt.Sprintf("Failed to query VM info by given ID %d", vm.id))
}
vm.logger.Info(SOFTLAYER_VM_LOG_TAG, fmt.Sprintf("vmInfoDB.vmProperties.id is %d", vmInfoDB.VmProperties.Id))
if vmInfoDB.VmProperties.Id != 0 {
if agentID != "" {
vm.logger.Info(SOFTLAYER_VM_LOG_TAG, fmt.Sprintf("Release the VM with id %d back to the VM pool", vmInfoDB.VmProperties.Id))
vmInfoDB.VmProperties.InUse = "f"
err = vmInfoDB.UpdateVMInfoByID(bslcvmpool.DB_RETRY_TIMEOUT, bslcvmpool.DB_RETRY_INTERVAL)
if err != nil {
return bosherr.WrapError(err, fmt.Sprintf("Failed to update in_use to %s by given ID %d", vmInfoDB.VmProperties.InUse, vm.id))
} else {
return nil
}
} else {
if strings.ToUpper(common.GetOSEnvVariable("DEL_NOT_ALLOWED", "FALSE")) == "FALSE" {
return vm.DeleteVM()
} else {
return bosherr.Error("DEL_NOT_ALLOWED is set to TRUE, the VM deletion reqeust is refused.")
}
}
} else {
if strings.ToUpper(common.GetOSEnvVariable("DEL_NOT_ALLOWED", "FALSE")) == "FALSE" {
return vm.DeleteVM()
} else {
return bosherr.Error("DEL_NOT_ALLOWED is set to TRUE, the VM deletion reqeust is refused.")
}
}
}
func (c SoftLayerConfig) Validate() error {
if c.Username == "" {
return bosherr.Error("Must provide non-empty Username")
}
if c.ApiKey == "" {
return bosherr.Error("Must provide non-empty ApiKey")
}
return nil
}
func (v SemanticValidator) validateNetworkAssociation(na NetworkAssociation) error {
if na.Network == nil {
return bosherr.Error("Missing associated network")
}
if na.MustHaveStaticIP && na.StaticIP == nil {
return bosherr.Error("Missing static IP assignment")
}
return nil
}
func (b localBlobstore) Validate() error {
path, found := b.options["blobstore_path"]
if !found {
return bosherr.Error("missing blobstore_path")
}
_, ok := path.(string)
if !ok {
return bosherr.Error("blobstore_path must be a string")
}
return nil
}
func (bc FileBundleCollection) Get(definition BundleDefinition) (Bundle, error) {
if len(definition.BundleName()) == 0 {
return nil, bosherr.Error("Missing bundle name")
}
if len(definition.BundleVersion()) == 0 {
return nil, bosherr.Error("Missing bundle version")
}
installPath := path.Join(bc.installPath, bc.name, definition.BundleName(), definition.BundleVersion())
enablePath := path.Join(bc.enablePath, bc.name, definition.BundleName())
return NewFileBundle(installPath, enablePath, bc.fs, bc.logger), nil
}
func (v SyntaxValidator) validateRelease(release *Release) error {
if release.Name == "" {
return bosherr.Error("Missing release name")
}
if release.Version == "" {
return bosherr.Error("Missing release version")
}
if release.URL == "" {
return bosherr.Error("Missing release URL")
}
return nil
}
func (d *deployWrapper) RunWithDebug(args ...string) (string, error) {
output, err := d.cliRunner.RunWithOutput(args...)
taskId := ""
if err != nil {
re := regexp.MustCompile("bosh task ([0-9]+) --debug")
matches := re.FindAllStringSubmatch(output, -1)
if len(matches) > 0 && len(matches[0]) > 1 {
taskId = matches[0][1]
debugErr := d.cliRunner.RunWithArgs("task", taskId, "--debug")
if debugErr != nil {
return taskId, debugErr
}
}
} else {
re := regexp.MustCompile("Task ([0-9]+) done")
matches := re.FindAllStringSubmatch(output, -1)
if len(matches) > 0 && len(matches[0]) > 1 {
taskId = matches[0][1]
}
}
if taskId == "" {
return "", bosherr.Error("Failed to get task id")
}
return taskId, err
}
func (udev ConcreteUdevDevice) readByte(filePath string) error {
udev.logger.Debug(udev.logtag, "readBytes from file: %s", filePath)
device, err := os.Open(filePath)
if err != nil {
return err
}
defer func() {
if err = device.Close(); err != nil {
udev.logger.Warn(udev.logtag, "Failed to close device: %s", err.Error())
}
}()
udev.logger.Debug(udev.logtag, "Successfully open file: %s", filePath)
bytes := make([]byte, 1, 1)
read, err := device.Read(bytes)
if err != nil {
return err
}
udev.logger.Debug(udev.logtag, "Successfully read %d bytes from file: %s", read, filePath)
if read != 1 {
return bosherr.Error("Device readable but zero length")
}
return nil
}
func (o BlobstoreOptions) Validate() error {
if o.Type == "" {
return bosherr.Error("Must provide non-empty Type")
}
return nil
}
// compilePackages compiles the specified packages, in the order specified, uploads them to the Blobstore, and returns the blob references
func (c *dependencyCompiler) compilePackages(requiredPackages []*birelpkg.Package, stage biui.Stage) ([]CompiledPackageRef, error) {
packageRefs := make([]CompiledPackageRef, 0, len(requiredPackages))
for _, pkg := range requiredPackages {
stepName := fmt.Sprintf("Compiling package '%s/%s'", pkg.Name, pkg.Fingerprint)
err := stage.Perform(stepName, func() error {
compiledPackageRecord, isAlreadyCompiled, err := c.packageCompiler.Compile(pkg)
if err != nil {
return err
}
packageRef := CompiledPackageRef{
Name: pkg.Name,
Version: pkg.Fingerprint,
BlobstoreID: compiledPackageRecord.BlobID,
SHA1: compiledPackageRecord.BlobSHA1,
}
packageRefs = append(packageRefs, packageRef)
if isAlreadyCompiled {
return biui.NewSkipStageError(bosherr.Error(fmt.Sprintf("Package '%s' is already compiled. Skipped compilation", pkg.Name)), "Package already compiled")
}
return nil
})
if err != nil {
return nil, err
}
}
return packageRefs, nil
}
func (b retryableBlobstore) Validate() error {
if b.maxTries < 1 {
return bosherr.Error("Max tries must be > 0")
}
return b.blobstore.Validate()
}
func (v SemanticValidator) validateNetwork(network Network) error {
if network.Type == NetworkTypeManual {
return bosherr.Error("Manual networking is not supported")
}
return nil
}
func (v SemanticValidator) validateRelease(release Release) error {
if release.Version == "latest" {
return bosherr.Error("Version 'latest' is not supported")
}
return nil
}
func (v SemanticValidator) validateTemplate(template Template) error {
if template.Release == nil {
return bosherr.Error("Missing associated release")
}
return nil
}
func (r identityDevicePathResolver) GetRealDevicePath(diskSettings boshsettings.DiskSettings) (string, bool, error) {
if len(diskSettings.Path) == 0 {
return "", false, bosherr.Error("Getting real device path: path is missing")
}
return diskSettings.Path, false, nil
}
func (v SyntaxValidator) validateCompilation(compilation *Compilation) error {
if compilation.NetworkName == "" {
return bosherr.Error("Missing network name")
}
return nil
}
func (v SyntaxValidator) validateNetwork(network *Network) error {
if network.Name == "" {
return bosherr.Error("Missing network name")
}
return v.validateNetworkType(network.Type)
}
func (s windowsRoutesSearcher) SearchRoutes() ([]Route, error) {
ifs, err := net.Interfaces()
if err != nil {
return nil, bosherr.WrapError(err, "Running route")
}
var routes []Route
var first error
for _, fs := range ifs {
gateway, err := getGateway(fs.Index)
if err != nil {
if first == nil {
first = err
}
continue
}
route := Route{
InterfaceName: fs.Name,
Gateway: gateway,
Destination: "0.0.0.0",
}
routes = append(routes, route)
}
if len(routes) == 0 {
if first != nil {
return nil, first
}
return nil, bosherr.Error("no routes")
}
return routes, nil
}
