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{}