func (r *retryClient) Do(req *http.Request) (*http.Response, error) { requestRetryable := NewRequestRetryable(req, r.delegate, r.logger) retryStrategy := boshretry.NewAttemptRetryStrategy(int(r.maxAttempts), r.retryDelay, requestRetryable, r.logger) err := retryStrategy.Try() return requestRetryable.Response(), err }
func (p *provider) Get(source Source, stage biui.Stage) (string, error) { if strings.HasPrefix(source.GetURL(), "file://") { filePath := strings.TrimPrefix(source.GetURL(), "file://") expandedPath, err := p.fs.ExpandPath(filePath) if err != nil { p.logger.Warn(p.logTag, "Failed to expand file path %s, using original URL", filePath) return filePath, nil } p.logger.Debug(p.logTag, "Using the tarball from file source: '%s'", filePath) return expandedPath, nil } if !strings.HasPrefix(source.GetURL(), "http") { return "", bosherr.Errorf("Invalid source URL: '%s', must be either file:// or http(s)://", source.GetURL()) } var cachedPath string err := stage.Perform(fmt.Sprintf("Downloading %s", source.Description()), func() error { var found bool cachedPath, found = p.cache.Get(source) if found { p.logger.Debug(p.logTag, "Using the tarball from cache: '%s'", cachedPath) return biui.NewSkipStageError(bosherr.Error("Already downloaded"), "Found in local cache") } retryStrategy := boshretry.NewAttemptRetryStrategy(p.downloadAttempts, p.delayTimeout, p.downloadRetryable(source), p.logger) err := retryStrategy.Try() if err != nil { return bosherr.WrapErrorf(err, "Failed to download from '%s'", source.GetURL()) } p.logger.Debug(p.logTag, "Using the downloaded tarball: '%s'", cachedPath) return nil }) if err != nil { return "", err } return p.cache.Path(source), nil }
func (c *agentClient) GetState() (agentclient.AgentState, error) { var response StateResponse getStateRetryable := boshretry.NewRetryable(func() (bool, error) { err := c.agentRequest.Send("get_state", []interface{}{}, &response) if err != nil { return true, bosherr.WrapError(err, "Sending get_state to the agent") } return false, nil }) attemptRetryStrategy := boshretry.NewAttemptRetryStrategy(c.toleratedErrorCount+1, c.getTaskDelay, getStateRetryable, c.logger) err := attemptRetryStrategy.Try() if err != nil { return agentclient.AgentState{}, bosherr.WrapError(err, "Sending get_state to the agent") } agentState := agentclient.AgentState{ JobState: response.Value.JobState, } return agentState, err }
func (vm *vm) WaitToBeRunning(maxAttempts int, delay time.Duration) error { agentGetStateRetryable := biagentclient.NewGetStateRetryable(vm.agentClient) agentGetStateRetryStrategy := boshretry.NewAttemptRetryStrategy(maxAttempts, delay, agentGetStateRetryable, vm.logger) return agentGetStateRetryStrategy.Try() }
func NewProvider(logger boshlog.Logger, dirProvider boshdirs.Provider, statsCollector boshstats.Collector, options Options) Provider { runner := boshsys.NewExecCmdRunner(logger) fs := boshsys.NewOsFileSystem(logger) linuxDiskManager := boshdisk.NewLinuxDiskManager(logger, runner, fs, options.Linux.BindMountPersistentDisk) udev := boshudev.NewConcreteUdevDevice(runner, logger) linuxCdrom := boshcdrom.NewLinuxCdrom("/dev/sr0", udev, runner) linuxCdutil := boshcdrom.NewCdUtil(dirProvider.SettingsDir(), fs, linuxCdrom, logger) compressor := boshcmd.NewTarballCompressor(runner, fs) copier := boshcmd.NewCpCopier(runner, fs, logger) // Kick of stats collection as soon as possible go statsCollector.StartCollecting(SigarStatsCollectionInterval, nil) vitalsService := boshvitals.NewService(statsCollector, dirProvider) ipResolver := boship.NewResolver(boship.NetworkInterfaceToAddrsFunc) arping := bosharp.NewArping(runner, fs, logger, ArpIterations, ArpIterationDelay, ArpInterfaceCheckDelay) interfaceConfigurationCreator := boshnet.NewInterfaceConfigurationCreator(logger) centosNetManager := boshnet.NewCentosNetManager(fs, runner, ipResolver, interfaceConfigurationCreator, arping, logger) ubuntuNetManager := boshnet.NewUbuntuNetManager(fs, runner, ipResolver, interfaceConfigurationCreator, arping, logger) centosCertManager := boshcert.NewCentOSCertManager(fs, runner, logger) ubuntuCertManager := boshcert.NewUbuntuCertManager(fs, runner, logger) routesSearcher := boshnet.NewCmdRoutesSearcher(runner) linuxDefaultNetworkResolver := boshnet.NewDefaultNetworkResolver(routesSearcher, ipResolver) monitRetryable := NewMonitRetryable(runner) monitRetryStrategy := boshretry.NewAttemptRetryStrategy(10, 1*time.Second, monitRetryable, logger) var devicePathResolver devicepathresolver.DevicePathResolver switch options.Linux.DevicePathResolutionType { case "virtio": udev := boshudev.NewConcreteUdevDevice(runner, logger) idDevicePathResolver := devicepathresolver.NewIDDevicePathResolver(500*time.Millisecond, udev, fs) mappedDevicePathResolver := devicepathresolver.NewMappedDevicePathResolver(500*time.Millisecond, fs) devicePathResolver = devicepathresolver.NewVirtioDevicePathResolver(idDevicePathResolver, mappedDevicePathResolver, logger) case "scsi": devicePathResolver = devicepathresolver.NewScsiDevicePathResolver(500*time.Millisecond, fs) default: devicePathResolver = devicepathresolver.NewIdentityDevicePathResolver() } centos := NewLinuxPlatform( fs, runner, statsCollector, compressor, copier, dirProvider, vitalsService, linuxCdutil, linuxDiskManager, centosNetManager, centosCertManager, monitRetryStrategy, devicePathResolver, 500*time.Millisecond, options.Linux, logger, linuxDefaultNetworkResolver, ) ubuntu := NewLinuxPlatform( fs, runner, statsCollector, compressor, copier, dirProvider, vitalsService, linuxCdutil, linuxDiskManager, ubuntuNetManager, ubuntuCertManager, monitRetryStrategy, devicePathResolver, 500*time.Millisecond, options.Linux, logger, linuxDefaultNetworkResolver, ) return provider{ platforms: map[string]Platform{ "ubuntu": ubuntu, "centos": centos, "dummy": NewDummyPlatform(statsCollector, fs, runner, dirProvider, devicePathResolver, logger), }, } }