Beispiel #1
0
func (m linuxMounter) shouldMount(partitionPath, mountPoint string) (shouldMount bool, err error) {
	isMounted, err := m.searchMounts(func(mountedPartitionPath, mountedMountPoint string) (found bool, err error) {
		switch {
		case mountedPartitionPath == partitionPath && mountedMountPoint == mountPoint:
			found = true
			return
		case mountedPartitionPath == partitionPath && mountedMountPoint != mountPoint:
			err = bosherr.New("Device %s is already mounted to %s, can't mount to %s",
				mountedPartitionPath, mountedMountPoint, mountPoint)
			return
		case mountedMountPoint == mountPoint:
			err = bosherr.New("Device %s is already mounted to %s, can't mount %s",
				mountedPartitionPath, mountedMountPoint, partitionPath)
			return
		}

		return
	})
	if err != nil {
		err = bosherr.WrapError(err, "Searching mounts")
		return
	}

	shouldMount = !isMounted
	return
}
Beispiel #2
0
func NewWatchTimeFromString(str string) (WatchTime, error) {
	var watchTime WatchTime

	parts := strings.Split(str, "-")
	if len(parts) != 2 {
		return watchTime, bosherr.New("Invalid watch time range %s", str)
	}

	min, err := strconv.Atoi(strings.Trim(parts[0], " "))
	if err != nil {
		return watchTime, bosherr.WrapError(
			err, "Non-positive number as watch time minimum %s", parts[0])
	}

	max, err := strconv.Atoi(strings.Trim(parts[1], " "))
	if err != nil {
		return watchTime, bosherr.WrapError(
			err, "Non-positive number as watch time maximum %s", parts[1])
	}

	if max < min {
		return watchTime, bosherr.New(
			"Watch time must have maximum greater than or equal minimum %s", str)
	}

	watchTime[0], watchTime[1] = min, max

	return watchTime, nil
}
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.New("No routes found")
	}

	for _, route := range routes {
		if !route.IsDefault() {
			continue
		}

		ip, err := r.ipResolver.GetPrimaryIPv4(route.InterfaceName)
		if err != nil {
			return network, bosherr.WrapError(
				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.New("Failed to find default route")
}
func (v SyntaxValidator) Validate() error {
	if v.release.Name == "" {
		return bosherr.New("Missing release name")
	}

	if v.release.Version == "" {
		return bosherr.New("Missing release version")
	}

	if v.release.CommitHash == "" {
		return bosherr.New("Missing release commit_hash")
	}

	for i, job := range v.release.Jobs {
		err := v.validateJob(&v.release.Jobs[i])
		if err != nil {
			return bosherr.WrapError(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.WrapError(err, "Package %s (%d)", pkg.Name, i)
		}
	}

	return nil
}
Beispiel #5
0
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.New("Run method not found")
		return
	}

	runMethodType := runMethodValue.Type()
	if r.invalidReturnTypes(runMethodType) {
		err = bosherr.New("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 (r ipResolver) GetPrimaryIPv4(interfaceName string) (*gonet.IPNet, error) {
	addrs, err := r.ifaceToAddrsFunc(interfaceName)
	if err != nil {
		return nil, bosherr.WrapError(err, "Looking up addresses for interface '%s'", interfaceName)
	}

	if len(addrs) == 0 {
		return nil, bosherr.New("No addresses found for interface '%s'", interfaceName)
	}

	for _, addr := range addrs {
		ip, ok := addr.(*gonet.IPNet)
		if !ok {
			continue
		}

		// ignore ipv6
		if ip.IP.To4() == nil {
			continue
		}

		return ip, nil
	}

	return nil, bosherr.New("Failed to find primary IPv4 address for interface '%s'", interfaceName)
}
func (v SyntaxValidator) validateJob(job *Job) error {
	if job.Name == "" {
		return bosherr.New("Missing job name")
	}

	if job.Template != nil {
		return bosherr.New("'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.WrapError(err, "Network association %s (%d)", na.NetworkName, i)
		}
	}

	return nil
}
func (tc ConcreteTemplatesCompiler) buildJobReaders(job bpdep.Job) ([]jobReader, error) {
	var readers []jobReader

	for _, template := range job.Templates {
		rec, found, err := tc.tplToJobRepo.FindByTemplate(template)
		if err != nil {
			return readers, bosherr.WrapError(err, "Finding dep-template -> release-job record %s", template.Name)
		} else if !found {
			return readers, bosherr.New("Expected to find dep-template -> release-job record %s", template.Name)
		}

		jobRec, found, err := tc.jobsRepo.FindByReleaseJob(rec)
		if err != nil {
			return readers, bosherr.WrapError(err, "Finding job source blob %s", template.Name)
		} else if !found {
			return readers, bosherr.New("Expected to find job source blob %s -- %s", template.Name, rec)
		}

		jobURL := fmt.Sprintf("blobstore:///%s?fingerprint=%s", jobRec.BlobID, jobRec.SHA1)

		reader := jobReader{
			rec:       rec,
			tarReader: tc.jobReaderFactory.NewTarReader(jobURL),
		}

		readers = append(readers, reader)
	}

	return readers, nil
}
Beispiel #9
0
func (a DrainAction) Run(drainType DrainType, newSpecs ...boshas.V1ApplySpec) (int, error) {
	currentSpec, err := a.specService.Get()
	if err != nil {
		return 0, bosherr.WrapError(err, "Getting current spec")
	}

	if len(currentSpec.JobSpec.Template) == 0 {
		if drainType == DrainTypeStatus {
			return 0, bosherr.New("Check Status on Drain action requires job spec")
		} else {
			return 0, nil
		}
	}

	err = a.jobSupervisor.Unmonitor()
	if err != nil {
		return 0, bosherr.WrapError(err, "Unmonitoring services")
	}

	drainScript := a.drainScriptProvider.NewDrainScript(currentSpec.JobSpec.Template)

	var params boshdrain.DrainScriptParams

	switch drainType {
	case DrainTypeUpdate:
		if len(newSpecs) == 0 {
			return 0, bosherr.New("Drain update requires new spec")
		}

		params = boshdrain.NewUpdateDrainParams(currentSpec, newSpecs[0])

	case DrainTypeShutdown:
		err = a.notifier.NotifyShutdown()
		if err != nil {
			return 0, bosherr.WrapError(err, "Notifying shutdown")
		}

		params = boshdrain.NewShutdownDrainParams()

	case DrainTypeStatus:
		params = boshdrain.NewStatusDrainParams()
	}

	if !drainScript.Exists() {
		if drainType == DrainTypeStatus {
			return 0, bosherr.New("Check Status on Drain action requires a valid drain script")
		} else {
			return 0, nil
		}
	}

	value, err := drainScript.Run(params)
	if err != nil {
		return 0, bosherr.WrapError(err, "Running Drain Script")
	}

	return value, nil
}
func (s *FileBundleCollection) checkBundle(bundle Bundle) error {
	if len(bundle.BundleName()) == 0 {
		return bosherr.New("missing bundle name")
	}
	if len(bundle.BundleVersion()) == 0 {
		return bosherr.New("missing bundle version")
	}
	return nil
}
func (s *FileBundleCollection) checkBundle(bundle Bundle) (err error) {
	if len(bundle.BundleName()) == 0 {
		err = bosherr.New("missing bundle name")
		return
	}
	if len(bundle.BundleVersion()) == 0 {
		err = bosherr.New("missing bundle version")
		return
	}
	return
}
func (v SemanticValidator) validateNetworkAssociation(na NetworkAssociation) error {
	if na.Network == nil {
		return bosherr.New("Missing associated network")
	}

	if na.MustHaveStaticIP && na.StaticIP == nil {
		return bosherr.New("Missing static IP assignment")
	}

	return nil
}
func (v SyntaxValidator) validateNetworkType(networkType string) error {
	if networkType == "" {
		return bosherr.New("Missing network type")
	}

	for _, t := range NetworkTypes {
		if networkType == t {
			return nil
		}
	}

	return bosherr.New("Unknown network type %s", networkType)
}
Beispiel #14
0
func (blobstore local) Validate() error {
	path, found := blobstore.options["blobstore_path"]
	if !found {
		return bosherr.New("missing blobstore_path")
	}

	_, ok := path.(string)
	if !ok {
		return bosherr.New("blobstore_path must be a string")
	}

	return nil
}
func (bc FileBundleCollection) Get(definition BundleDefinition) (Bundle, error) {
	if len(definition.BundleName()) == 0 {
		return nil, bosherr.New("Missing bundle name")
	}

	if len(definition.BundleVersion()) == 0 {
		return nil, bosherr.New("Missing bundle version")
	}

	installPath := filepath.Join(bc.installPath, bc.name, definition.BundleName(), definition.BundleVersion())
	enablePath := filepath.Join(bc.enablePath, bc.name, definition.BundleName())
	return NewFileBundle(installPath, enablePath, bc.fs, bc.logger), nil
}
Beispiel #16
0
func (p diskParams) GetDevicePath() (devicePath string, err error) {
	if len(p.payload.Arguments) != 1 {
		err = bosherr.New("Invalid payload missing volume id.")
		return
	}

	volumeId := p.payload.Arguments[0]
	disks := p.settings.GetDisks()
	devicePath, found := disks.Persistent[volumeId]
	if !found {
		err = bosherr.New("Invalid payload volume id does not match")
	}
	return
}
func (v SyntaxValidator) validateRelease(release *Release) error {
	if release.Name == "" {
		return bosherr.New("Missing release name")
	}

	if release.Version == "" {
		return bosherr.New("Missing release version")
	}

	if release.URL == "" {
		return bosherr.New("Missing release URL")
	}

	return nil
}
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.New("No routes")
	}

	for _, route := range routes {
		if !route.IsDefault() {
			continue
		}

		addrs, err := r.ifaceToAddrsFunc(route.InterfaceName)
		if err != nil {
			return network, bosherr.WrapError(err, "Looking addrs for interface %s", route.InterfaceName)
		}

		if len(addrs) == 0 {
			return network, bosherr.New("No addresses")
		}

		for _, addr := range addrs {
			ip, ok := addr.(*gonet.IPNet)
			if !ok {
				continue
			}

			if ip.IP.To4() == nil { // filter out ipv6
				continue
			}

			return boshsettings.Network{
				IP:      ip.IP.String(),
				Netmask: gonet.IP(ip.Mask).String(),
				Gateway: route.Gateway,
			}, nil
		}

		return network, bosherr.New("Failed to find IPv4 address")
	}

	return network, bosherr.New("Failed to find default route")
}
Beispiel #19
0
func (p provider) Get(name string) (Platform, error) {
	plat, found := p.platforms[name]
	if !found {
		return nil, bosherror.New("Platform %s could not be found", name)
	}
	return plat, nil
}
Beispiel #20
0
func (ac HTTPClient) makeQuickRequest(method reqMethod, args reqArgs) (responseEnvelope, error) {
	var responseBody responseEnvelope

	requestBody := requestEnvelope{
		Method:    method,
		Arguments: args,
		ReplyTo:   "n-a",
	}

	requestBytes, err := json.Marshal(requestBody)
	if err != nil {
		return responseBody, bosherr.WrapError(err, "Marshalling request body")
	}

	responseBytes, err := ac.makePlainRequest(string(requestBytes), "application/json")
	if err != nil {
		return responseBody, bosherr.WrapError(err, "Making plain request")
	}

	err = json.Unmarshal(responseBytes, &responseBody)
	if err != nil {
		return responseBody, bosherr.WrapError(err, "Unmarshalling response body")
	}

	if responseBody.HasException() {
		return responseBody, bosherr.New("Ended with exception %#v", responseBody.Exception)
	}

	return responseBody, nil
}
func (v SyntaxValidator) validateNetwork(network *Network) error {
	if network.Name == "" {
		return bosherr.New("Missing network name")
	}

	return v.validateNetworkType(network.Type)
}
Beispiel #22
0
func (a UnmountDiskAction) Run(volumeID string) (value interface{}, err error) {
	disksSettings := a.settings.GetDisks()
	devicePath, found := disksSettings.Persistent[volumeID]
	if !found {
		err = bosherr.New("Persistent disk with volume id '%s' could not be found", volumeID)
		return
	}

	didUnmount, err := a.platform.UnmountPersistentDisk(devicePath)
	if err != nil {
		err = bosherr.WrapError(err, "Unmounting persistent disk")
		return
	}

	msg := fmt.Sprintf("Partition of %s is not mounted", devicePath)

	if didUnmount {
		msg = fmt.Sprintf("Unmounted partition of %s", devicePath)
	}

	type valueType struct {
		Message string `json:"message"`
	}

	value = valueType{Message: msg}
	return
}
func (v SyntaxValidator) validateCompilation(compilation *Compilation) error {
	if compilation.NetworkName == "" {
		return bosherr.New("Missing network name")
	}

	return nil
}
func (p RunitProvisioner) stopRunsv(name string, stopTimeout time.Duration) error {
	p.logger.Info(runitProvisionerLogTag, "Stopping runsv")

	downStdout, _, _, err := p.runner.RunCommand("sv", "down", name)
	if err != nil {
		p.logger.Error(runitProvisionerLogTag, "Ignoring down error %s", err.Error())
	}

	// If runsv configuration does not exist, service was never started
	if strings.Contains(downStdout, "file does not exist") {
		return nil
	}

	var lastStatusStdout string
	var passedDuration time.Duration

	for ; passedDuration < stopTimeout; passedDuration += runitStopStepDuration {
		lastStatusStdout, _, _, _ = p.runner.RunCommand("sv", "status", name)

		if runitStatusDownRegex.MatchString(lastStatusStdout) {
			return nil
		}

		time.Sleep(runitStopStepDuration)
	}

	return bosherr.New("Failed to stop runsv for %s. Output: %s", name, lastStatusStdout)
}
// Symlinked from {{ enablePath }}/{{ name }}/{{ bundle.BundleName }} to installed path
func (s *FileBundleCollection) Enable(bundle Bundle) (err error) {
	err = s.checkBundle(bundle)
	if err != nil {
		return
	}

	installPath := s.buildInstallPath(bundle)
	if !s.fs.FileExists(installPath) {
		err = bosherr.New("bundle must be installed")
		return
	}

	enablePath := s.buildEnablePath(bundle)
	err = s.fs.MkdirAll(filepath.Dir(enablePath), os.FileMode(0755))
	if err != nil {
		err = bosherr.WrapError(err, "failed to create enable dir")
		return
	}

	err = s.fs.Symlink(installPath, enablePath)
	if err != nil {
		err = bosherr.WrapError(err, "failed to enable")
		return
	}

	return
}
Beispiel #26
0
func (p MbusHandlerProvider) Get(
	platform boshplatform.Platform,
	dirProvider boshdir.DirectoriesProvider,
) (handler boshhandler.Handler, err error) {
	if p.handler != nil {
		handler = p.handler
		return
	}

	mbusURL, err := url.Parse(p.settings.GetMbusURL())
	if err != nil {
		err = bosherr.WrapError(err, "Parsing handler URL")
		return
	}

	switch mbusURL.Scheme {
	case "nats":
		handler = NewNatsHandler(p.settings, p.logger, yagnats.NewClient())
	case "https":
		handler = micro.NewHTTPSHandler(mbusURL, p.logger, platform.GetFs(), dirProvider)
	default:
		err = bosherr.New("Message Bus Handler with scheme %s could not be found", mbusURL.Scheme)
	}

	p.handler = handler

	return
}
func (m monitJobSupervisor) Reload() (err error) {
	oldIncarnation, err := m.getIncarnation()
	if err != nil {
		err = bosherr.WrapError(err, "Getting monit incarnation")
		return err
	}

	// Exit code or output cannot be trusted
	m.runner.RunCommand("monit", "reload")

	for attempt := 1; attempt < 60; attempt++ {
		err = nil
		currentIncarnation, err := m.getIncarnation()
		if err != nil {
			err = bosherr.WrapError(err, "Getting monit incarnation")
			return err
		}

		if oldIncarnation < currentIncarnation {
			return nil
		}

		time.Sleep(m.delayBetweenReloadCheckRetries)
	}

	err = bosherr.New("Failed to reload monit")
	return
}
Beispiel #28
0
func (blobstore external) Validate() error {
	if !blobstore.runner.CommandExists(blobstore.executable()) {
		return bosherr.New("executable %s not found in PATH", blobstore.executable())
	}

	return blobstore.writeConfigFile()
}
Beispiel #29
0
func (a mountDiskAction) Run(volumeId string) (value interface{}, err error) {
	err = a.settings.Refresh()
	if err != nil {
		err = bosherr.WrapError(err, "Refreshing the settings")
		return
	}

	disksSettings := a.settings.GetDisks()
	devicePath, found := disksSettings.Persistent[volumeId]
	if !found {
		err = bosherr.New("Persistent disk with volume id '%s' could not be found", volumeId)
		return
	}

	mountPoint := a.dirProvider.StoreDir()

	isMountPoint, err := a.platform.IsMountPoint(mountPoint)
	if err != nil {
		err = bosherr.WrapError(err, "Checking mount point")
		return
	}
	if isMountPoint {
		mountPoint = a.dirProvider.StoreMigrationDir()
	}

	err = a.platform.MountPersistentDisk(devicePath, mountPoint)
	if err != nil {
		err = bosherr.WrapError(err, "Mounting persistent disk")
		return
	}

	value = make(map[string]string)
	return
}
Beispiel #30
0
func (self FileBundleCollection) Get(definition BundleDefinition) (bundle Bundle, err error) {
	if len(definition.BundleName()) == 0 {
		err = bosherr.New("missing bundle name")
		return
	}
	if len(definition.BundleVersion()) == 0 {
		err = bosherr.New("missing bundle version")
		return
	}

	installPath := filepath.Join(self.installPath, self.name, definition.BundleName(), definition.BundleVersion())
	enablePath := filepath.Join(self.enablePath, self.name, definition.BundleName())

	bundle = NewFileBundle(installPath, enablePath, self.fs)
	return
}