func runAgent(logger logger.Logger) chan error {
errCh := make(chan error, 1)
go func() {
defer logger.HandlePanic("Main")
logger.Debug(mainLogTag, "Starting agent")
fs := boshsys.NewOsFileSystem(logger)
app := boshapp.New(logger, fs)
err := app.Setup(os.Args)
if err != nil {
logger.Error(mainLogTag, "App setup %s", err.Error())
errCh <- err
return
}
err = app.Run()
if err != nil {
logger.Error(mainLogTag, "App run %s", err.Error())
errCh <- err
return
}
}()
return errCh
}
func basicDeps() (boshlog.Logger, boshsys.FileSystem, boshsys.CmdRunner) {
logger := boshlog.NewWriterLogger(boshlog.LevelDebug, os.Stderr, os.Stderr)
fs := boshsys.NewOsFileSystem(logger)
cmdRunner := boshsys.NewExecCmdRunner(logger)
return logger, fs, cmdRunner
}
func basicDeps() (boshlog.Logger, boshsys.FileSystem, boshsys.CmdRunner, boshuuid.Generator) {
logger := boshlog.NewWriterLogger(boshlog.LevelDebug, os.Stderr, os.Stderr)
fs := boshsys.NewOsFileSystem(logger)
runner := boshsys.NewExecCmdRunner(logger)
uuidGen := boshuuid.NewGenerator()
return logger, fs, runner, uuidGen
}
func newSignalableFileLogger(logPath string, level boshlog.LogLevel) boshlog.Logger {
// Log file logger errors to the STDERR logger
logger := boshlog.NewLogger(boshlog.LevelError)
fileSystem := boshsys.NewOsFileSystem(logger)
// log file will be closed by process exit
// log file readable by all
logfileLogger, _, err := boshlogfile.New(level, logPath, boshlogfile.DefaultLogFileMode, fileSystem)
if err != nil {
logger := boshlog.NewLogger(boshlog.LevelError)
ui := biui.NewConsoleUI(logger)
fail(err, ui, logger, nil)
}
return newSignalableLogger(logfileLogger)
}
func main() {
logger := newSignalableLogger(boshlog.NewLogger(boshlog.LevelDebug))
defer logger.HandlePanic("Main")
logger.Debug(mainLogTag, "Starting agent")
fs := boshsys.NewOsFileSystem(logger)
app := boshapp.New(logger, fs)
err := app.Setup(os.Args)
if err != nil {
logger.Error(mainLogTag, "App setup %s", err.Error())
os.Exit(1)
}
err = app.Run()
if err != nil {
logger.Error(mainLogTag, "App run %s", err.Error())
os.Exit(1)
}
}
. "github.com/onsi/gomega"
)
var _ = Describe("Blob Manager", func() {
var (
fs boshsys.FileSystem
logger boshlog.Logger
basePath string
blobPath string
blobId string
toWrite io.Reader
)
BeforeEach(func() {
logger = boshlog.NewLogger(boshlog.LevelNone)
fs = boshsys.NewOsFileSystem(logger)
blobId = "105d33ae-655c-493d-bf9f-1df5cf3ca847"
basePath = os.TempDir()
blobPath = filepath.Join(basePath, blobId)
toWrite = bytes.NewReader([]byte("new data"))
})
readFile := func(fileIO boshsys.File) []byte {
fileStat, _ := fileIO.Stat()
fileBytes := make([]byte, fileStat.Size())
fileIO.Read(fileBytes)
return fileBytes
}
It("fetches", func() {
blobManager := NewBlobManager(fs, basePath)
func init() {
Describe("App", func() {
var (
baseDir string
agentConfPath string
agentConfJSON string
app App
)
BeforeEach(func() {
var err error
baseDir, err = ioutil.TempDir("", "go-agent-test")
Expect(err).ToNot(HaveOccurred())
err = os.Mkdir(filepath.Join(baseDir, "bosh"), os.ModePerm)
Expect(err).ToNot(HaveOccurred())
})
BeforeEach(func() {
agentConfPath = filepath.Join(baseDir, "bosh", "agent.json")
agentConfJSON = `{
"Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } }
}`
settingsPath := filepath.Join(baseDir, "bosh", "settings.json")
settingsJSON := `{
"agent_id": "my-agent-id",
"blobstore": {
"options": {
"bucket_name": "george",
"encryption_key": "optional encryption key",
"access_key_id": "optional access key id",
"secret_access_key": "optional secret access key"
},
"provider": "dummy"
},
"disks": {
"ephemeral": "/dev/sdb",
"persistent": {
"vol-xxxxxx": "/dev/sdf"
},
"system": "/dev/sda1"
},
"env": {
"bosh": {
"password": "******"
}
},
"networks": {
"netA": {
"default": ["dns", "gateway"],
"ip": "ww.ww.ww.ww",
"dns": [
"xx.xx.xx.xx",
"yy.yy.yy.yy"
]
},
"netB": {
"dns": [
"zz.zz.zz.zz"
]
}
},
"Mbus": "https://*****:*****@0.0.0.0:6868",
"ntp": [
"0.north-america.pool.ntp.org",
"1.north-america.pool.ntp.org"
],
"vm": {
"name": "vm-abc-def"
}
}`
err := ioutil.WriteFile(settingsPath, []byte(settingsJSON), 0640)
Expect(err).ToNot(HaveOccurred())
})
JustBeforeEach(func() {
err := ioutil.WriteFile(agentConfPath, []byte(agentConfJSON), 0640)
Expect(err).ToNot(HaveOccurred())
logger := boshlog.NewLogger(boshlog.LevelNone)
fakefs := boshsys.NewOsFileSystem(logger)
app = New(logger, fakefs)
})
AfterEach(func() {
os.RemoveAll(baseDir)
})
It("Sets up device path resolver on platform specific to infrastructure", func() {
err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(err).ToNot(HaveOccurred())
Expect(app.GetPlatform().GetDevicePathResolver()).To(Equal(devicepathresolver.NewIdentityDevicePathResolver()))
})
Context("when DevicePathResolutionType is 'virtio'", func() {
BeforeEach(func() {
agentConfJSON = `{
"Platform": { "Linux": { "DevicePathResolutionType": "virtio" } },
"Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } }
}`
})
It("uses a VirtioDevicePathResolver", func() {
err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(err).ToNot(HaveOccurred())
logLevel, err := boshlog.Levelify("DEBUG")
Expect(err).NotTo(HaveOccurred())
Expect(app.GetPlatform().GetDevicePathResolver()).To(
BeAssignableToTypeOf(devicepathresolver.NewVirtioDevicePathResolver(nil, nil, boshlog.NewLogger(logLevel))))
})
})
Context("when DevicePathResolutionType is 'scsi'", func() {
BeforeEach(func() {
agentConfJSON = `{
"Platform": { "Linux": { "DevicePathResolutionType": "scsi" } },
"Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } }
}`
})
It("uses a VirtioDevicePathResolver", func() {
err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(err).ToNot(HaveOccurred())
Expect(app.GetPlatform().GetDevicePathResolver()).To(
BeAssignableToTypeOf(devicepathresolver.NewScsiDevicePathResolver(nil, nil, nil)))
})
})
Context("logging stemcell version and git sha", func() {
var (
logger boshlog.Logger
outBuf *bytes.Buffer
fakeFs boshsys.FileSystem
stemcellVersionFilePath string
stemcellSha1FilePath string
)
JustBeforeEach(func() {
outBuf = bytes.NewBufferString("")
errBuf := bytes.NewBufferString("")
logger = boshlog.NewWriterLogger(boshlog.LevelDebug, outBuf, errBuf)
fakeFs = fakesys.NewFakeFileSystem()
dirProvider := boshdirs.NewProvider(baseDir)
stemcellVersionFilePath = filepath.Join(dirProvider.EtcDir(), "stemcell_version")
stemcellSha1FilePath = filepath.Join(dirProvider.EtcDir(), "stemcell_git_sha1")
app = New(logger, fakeFs)
})
Context("when stemcell version and sha files are present", func() {
It("should print out the stemcell version and sha in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah")
fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: sha1-blah)"))
})
})
Context("when stemcell version file is NOT present", func() {
It("should print out the sha in the logs", func() {
fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: sha1-blah)"))
})
})
Context("when sha version file is NOT present", func() {
It("should print out the stemcell version in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: ?)"))
})
})
Context("when stemcell version file is empty", func() {
It("should print out the sha in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "")
fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: sha1-blah)"))
})
})
Context("when sha version file is empty", func() {
It("should print out the stemcell version in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah")
fakeFs.WriteFileString(stemcellSha1FilePath, "")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: ?)"))
})
})
Context("when stemcell version and sha files are NOT present", func() {
It("should print unknown version and sha in the logs", func() {
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: ?)"))
})
})
})
})
}
func NewDnsUpdater(cfg config.Config, log logger.Logger) *DnsUpdater {
fs := system.NewOsFileSystem(log)
cmdRunner := system.NewExecCmdRunner(log)
return &DnsUpdater{cfg: cfg, logger: log, fs: fs, cmdRunner: cmdRunner}
}
func (app *app) loadConfig(path string) (Config, error) {
// Use one off copy of file system to read configuration file
fs := boshsys.NewOsFileSystem(app.logger)
return LoadConfigFromPath(fs, path)
}
"github.com/cloudfoundry/bosh-init/installation"
"github.com/cloudfoundry/bosh-utils/logger"
"github.com/cloudfoundry/bosh-utils/system"
"github.com/cloudfoundry/bosh-utils/system/fakes"
"github.com/onsi/gomega/gbytes"
)
var _ = Describe("Uninstaller", func() {
Describe("Uninstall", func() {
It("deletes the installation target directory", func() {
logBuffer := gbytes.NewBuffer()
goLogger := log.New(logBuffer, "", log.LstdFlags)
boshlogger := logger.New(logger.LevelInfo, goLogger, goLogger)
fs := system.NewOsFileSystem(boshlogger)
installationPath, err := fs.TempDir("some-installation-dir")
Expect(err).ToNot(HaveOccurred())
err = fs.WriteFileString(filepath.Join(installationPath, "some-installation-artifact"), "something-blah")
Expect(err).ToNot(HaveOccurred())
installationTarget := installation.NewTarget(installationPath)
uninstaller := installation.NewUninstaller(fs, boshlogger)
Expect(fs.FileExists(installationPath)).To(BeTrue())
err = uninstaller.Uninstall(installationTarget)
Expect(err).ToNot(HaveOccurred())
func main() {
if len(os.Args) < 2 || len(os.Args) > 3 {
println("Usage: blt path/to/config.json [path/to/state.json]")
os.Exit(1)
}
logger := boshlog.NewLogger(boshlog.LevelDebug)
fs := boshsys.NewOsFileSystem(logger)
cmdRunner := boshsys.NewExecCmdRunner(logger)
config := bltconfig.NewConfig(fs)
err := config.Load(os.Args[1])
if err != nil {
panic(err)
}
assetsProvider := bltassets.NewProvider(config.AssetsPath)
logger.Debug("main", "Setting up environment")
environmentProvider := bltenv.NewProvider(config, fs, cmdRunner, assetsProvider)
environment := environmentProvider.Get()
err = environment.Setup()
if err != nil {
panic(err)
}
defer environment.Shutdown()
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
go func() {
<-c
environment.Shutdown()
os.Exit(1)
}()
logger.Debug("main", "Starting deploy")
cliRunnerFactory := bltclirunner.NewFactory(config.CliCmd, cmdRunner, fs)
directorInfo, err := bltaction.NewDirectorInfo(environment.DirectorURL(), cliRunnerFactory)
if err != nil {
panic(err)
}
actionFactory := bltaction.NewFactory(directorInfo, fs, assetsProvider)
prepareActionFlow := bltflow.NewFlow(1, []bltflow.ActionInfo{{Name: "prepare"}}, actionFactory, cliRunnerFactory)
err = prepareActionFlow.Run(false)
if err != nil {
panic(err)
}
if !config.UsingLegacyManifest {
uploadCloudConfigActionFlow := bltflow.NewFlow(2, []bltflow.ActionInfo{{Name: "upload_cloud_config"}}, actionFactory, cliRunnerFactory)
err := uploadCloudConfigActionFlow.Run(false)
if err != nil {
panic(err)
}
}
randomizer := bltflow.NewRandomizer(actionFactory, cliRunnerFactory, fs, logger)
if len(os.Args) == 3 {
err := randomizer.Configure(os.Args[2])
if err != nil {
panic(err)
}
} else {
err := randomizer.Prepare(config.Flows, config.NumberOfDeployments)
if err != nil {
panic(err)
}
}
doneCh := make(chan error)
for i := 0; i < config.NumberOfDeployments; i++ {
go func(i int) {
doneCh <- randomizer.RunFlow(i, config.UsingLegacyManifest)
}(i)
}
for i := 0; i < config.NumberOfDeployments; i++ {
err := <-doneCh
if err != nil {
panic(err)
}
}
println("Done!")
}
func main() {
if len(os.Args) < 2 || len(os.Args) > 3 {
println("Usage: bft path/to/config.json seed")
os.Exit(1)
}
logger := boshlog.NewLogger(boshlog.LevelDebug)
fs := boshsys.NewOsFileSystem(logger)
cmdRunner := boshsys.NewExecCmdRunner(logger)
testConfig := bftconfig.NewConfig(fs)
err := testConfig.Load(os.Args[1])
if err != nil {
panic(err)
}
envConfig := bltconfig.NewConfig(fs)
err = envConfig.Load(os.Args[1])
if err != nil {
panic(err)
}
assetsProvider := bltassets.NewProvider(envConfig.AssetsPath)
logger.Debug("main", "Setting up environment")
environmentProvider := bltenv.NewProvider(envConfig, fs, cmdRunner, assetsProvider)
environment := environmentProvider.Get()
if !testConfig.GenerateManifestOnly {
err = environment.Setup()
if err != nil {
panic(err)
}
defer environment.Shutdown()
}
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
go func() {
<-c
environment.Shutdown()
os.Exit(1)
}()
cliRunnerFactory := bltclirunner.NewFactory(envConfig.CliCmd, cmdRunner, fs)
var directorInfo bltaction.DirectorInfo
if testConfig.GenerateManifestOnly {
directorInfo = bltaction.DirectorInfo{
UUID: "blah",
URL: "xxx",
}
} else {
directorInfo, err = bltaction.NewDirectorInfo(environment.DirectorURL(), cliRunnerFactory)
}
if err != nil {
panic(err)
}
cliRunner := cliRunnerFactory.Create()
cliRunner.Configure()
defer cliRunner.Clean()
if !testConfig.GenerateManifestOnly {
logger.Debug("main", "Preparing to deploy")
preparer := bftdeployment.NewPreparer(directorInfo, cliRunner, fs, assetsProvider)
err = preparer.Prepare()
if err != nil {
panic(err)
}
}
logger.Debug("main", "Starting deploy")
renderer := bftdeployment.NewRenderer(fs)
var seed int64
if len(os.Args) == 3 {
seed, _ = strconv.ParseInt(os.Args[2], 10, 64)
} else {
seed = time.Now().Unix()
}
logger.Info("main", "Seeding with %d", seed)
rand.Seed(seed)
nameGenerator := bftnamegen.NewNameGenerator()
decider := bftdecider.NewRandomDecider()
ipPoolProvider := bftnetwork.NewIpPoolProvider()
networksAssigner := bftnetwork.NewAssigner(testConfig.Parameters.Networks, nameGenerator, ipPoolProvider, decider, logger)
parameterProvider := bftparam.NewParameterProvider(testConfig.Parameters, nameGenerator, decider, networksAssigner, logger)
inputGenerator := bftdeployment.NewInputGenerator(testConfig.Parameters, parameterProvider, testConfig.NumberOfConsequentDeploys, nameGenerator, decider, logger)
analyzer := bftanalyzer.NewAnalyzer(logger)
deployer := bftdeployment.NewDeployer(
cliRunner,
directorInfo,
renderer,
inputGenerator,
analyzer,
fs,
logger,
testConfig.GenerateManifestOnly,
)
err = deployer.RunDeploys()
if err != nil {
panic(err)
}
println("Done!")
}
