func (p *ipPoolProvider) NewIpPool(numOfNeededIPs int) *bftinput.IpPool {
if numOfNeededIPs == 0 {
numOfNeededIPs = rand.Intn(10)
}
if p.gatewayFourthOctet == 1 {
p.gatewayFourthOctet = 254
} else {
p.gatewayFourthOctet = 1
}
prefix := fmt.Sprintf("192.168.%d", p.called)
p.called += 1
numberOfReservedBorders := rand.Intn(6) // up to 6 borders of reserved ranges
usedIps := []int{}
reservedBorders := []int{}
firstStaticIp := 200
for _, i := range rand.Perm(firstStaticIp) {
if i != 0 && i != p.gatewayFourthOctet {
if len(usedIps) < numOfNeededIPs {
usedIps = append(usedIps, i)
} else if len(reservedBorders) < numberOfReservedBorders {
reservedBorders = append(reservedBorders, i)
} else {
break
}
}
}
sort.Ints(usedIps)
sort.Ints(reservedBorders)
decider := bftdecider.NewRandomDecider()
reservedRangeGenerator := NewReservedRangeGenerator(prefix, decider)
reservedRanges := reservedRangeGenerator.Generate(usedIps, reservedBorders)
return bftinput.NewIpPool(
prefix,
p.gatewayFourthOctet,
reservedRanges,
)
}
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!")
}
