func main() {
sharedWriter := &logWriter{
writer: os.Stderr,
}
logger := log.New(sharedWriter, "", log.LstdFlags)
configPath := flag.String("c", "", "Path to the JSON configuration file")
machineImagePath := flag.String("image", "", "Path to the input machine image (root.img)")
machineImageFormat := flag.String("format", resources.VolumeRawFormat, "Format of the input machine image (RAW or vmdk). Defaults to RAW.")
imageVolumeSize := flag.Int("volume-size", 0, "Block device size (in GB) of the input machine image")
manifestPath := flag.String("manifest", "", "Path to the input stemcell.MF")
flag.Parse()
if *configPath == "" {
usage("-c flag is required")
}
if *machineImagePath == "" {
usage("--image flag is required")
}
if *manifestPath == "" {
usage("--manifest flag is required")
}
if *imageVolumeSize == 0 && *machineImageFormat != resources.VolumeRawFormat {
usage("--volume-size flag is required for formats other than RAW")
}
configFile, err := os.Open(*configPath)
if err != nil {
logger.Fatalf("Error opening config file: %s", err)
}
defer func() {
closeErr := configFile.Close()
if closeErr != nil {
logger.Fatalf("Error closing config file: %s", closeErr)
}
}()
if err != nil {
logger.Fatalf("Error opening config file: %s", err)
}
c, err := config.NewFromReader(configFile)
if err != nil {
logger.Fatalf("Error parsing config file: %s. Message: %s", *configPath, err)
}
if _, err := os.Stat(*machineImagePath); os.IsNotExist(err) {
logger.Fatalf("machine image not found at: %s", *machineImagePath)
}
if _, err := os.Stat(*manifestPath); os.IsNotExist(err) {
logger.Fatalf("manifest not found at: %s", *manifestPath)
}
manifestBytes, err := ioutil.ReadFile(*manifestPath)
if err != nil {
logger.Fatalf("opening manifest: %s", err)
}
m, err := manifest.NewFromReader(bytes.NewReader(manifestBytes))
if err != nil {
logger.Fatalf("reading manifest: %s", err)
}
amiCollection := collection.Ami{}
errCollection := collection.Error{}
var wg sync.WaitGroup
wg.Add(len(c.AmiRegions))
imageConfig := publisher.MachineImageConfig{
LocalPath: *machineImagePath,
FileFormat: *machineImageFormat,
VolumeSizeGB: int64(*imageVolumeSize),
}
for i := range c.AmiRegions {
go func(regionConfig config.AmiRegion) {
defer wg.Done()
switch {
case regionConfig.IsolatedRegion:
ds := driverset.NewIsolatedRegionDriverSet(sharedWriter, regionConfig.Credentials)
p := publisher.NewIsolatedRegionPublisher(sharedWriter, publisher.Config{
AmiRegion: regionConfig,
AmiConfiguration: c.AmiConfiguration,
})
amis, err := p.Publish(ds, imageConfig)
if err != nil {
errCollection.Add(fmt.Errorf("Error publishing AMIs to %s: %s", regionConfig.RegionName, err))
} else {
amiCollection.Merge(amis)
}
default:
ds := driverset.NewStandardRegionDriverSet(sharedWriter, regionConfig.Credentials)
p := publisher.NewStandardRegionPublisher(sharedWriter, publisher.Config{
AmiRegion: regionConfig,
AmiConfiguration: c.AmiConfiguration,
})
amis, err := p.Publish(ds, imageConfig)
if err != nil {
errCollection.Add(fmt.Errorf("Error publishing AMIs to %s: %s", regionConfig.RegionName, err))
} else {
amiCollection.Merge(amis)
}
}
}(c.AmiRegions[i])
}
logger.Println("Waiting for publishers to finish...")
wg.Wait()
combinedErr := errCollection.Error()
if combinedErr != nil {
logger.Fatal(combinedErr)
}
m.PublishedAmis = amiCollection.GetAll()
m.Sha1 = shasum([]byte{})
err = m.Write(os.Stdout)
if err != nil {
logger.Fatalf("writing manifest: %s", err)
}
logger.Println("Publishing finished successfully")
}
if machineImageFormat != "RAW" {
args = append(args,
fmt.Sprintf("--format=%s", machineImageFormat),
fmt.Sprintf("--volume-size=%s", machineImageSize),
)
}
command := exec.Command(pathToBinary, args...)
gexecSession, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
Expect(err).ToNot(HaveOccurred())
gexecSession.Wait(60 * time.Minute)
Expect(gexecSession.ExitCode()).To(BeZero())
stdout := bytes.NewReader(gexecSession.Out.Contents())
m, err := manifest.NewFromReader(stdout)
Expect(err).ToNot(HaveOccurred())
Expect(m.Name).To(Equal("bosh-aws-xen-hvm-ubuntu-trusty-go_agent"))
Expect(m.Version).To(Equal("9999"))
Expect(m.BoshProtocol).To(Equal("1"))
Expect(m.Sha1).To(Equal("da39a3ee5e6b4b0d3255bfef95601890afd80709"))
Expect(m.OperatingSystem).To(Equal("ubuntu-trusty"))
amis := m.CloudProperties.Amis
Expect(amis).To(HaveLen(len(expectedRegions)))
for _, region := range expectedRegions {
Expect(amis).To(HaveKey(region))
Expect(amis[region]).ToNot(BeEmpty())
}
cloud_properties:
name: bosh-aws-xen-ubuntu-trusty-go_agent
version: blah
infrastructure: aws
hypervisor: xen
disk: 3072
disk_format: raw
container_format: bare
os_type: linux
os_distro: ubuntu
architecture: x86_64
root_device_name: /dev/sda1`)
It("writes the expected YAML file", func() {
manifestReader := bytes.NewReader(manifestBytes)
m, err := manifest.NewFromReader(manifestReader)
Expect(err).ToNot(HaveOccurred())
m.PublishedAmis = []resources.Ami{
resources.Ami{
Region: "fake-region",
ID: "fake-ami-id",
VirtualizationType: resources.PvAmiVirtualization,
},
}
writer := &bytes.Buffer{}
err = m.Write(writer)
Expect(err).ToNot(HaveOccurred())
resultManifest := &manifest.Manifest{}