Merge lp:~wallyworld/juju-core/improve-image-metadata-command into lp:~go-bot/juju-core/trunk
- improve-image-metadata-command
- Merge into trunk
Proposed by
Ian Booth
| Status: | Merged |
|---|---|
| Approved by: | Ian Booth |
| Approved revision: | no longer in the source branch. |
| Merged at revision: | 1987 |
| Proposed branch: | lp:~wallyworld/juju-core/improve-image-metadata-command |
| Merge into: | lp:~go-bot/juju-core/trunk |
| Diff against target: |
750 lines (+262/-148) 5 files modified
cmd/plugins/juju-metadata/imagemetadata.go (+99/-25) cmd/plugins/juju-metadata/imagemetadata_test.go (+127/-66) cmd/plugins/juju-metadata/validateimagemetadata_test.go (+22/-18) environs/imagemetadata/generate.go (+9/-25) environs/imagemetadata/validation_test.go (+5/-14) |
| To merge this branch: | bzr merge lp:~wallyworld/juju-core/improve-image-metadata-command |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Juju Engineering | Pending | ||
|
Review via email:
|
|||
Commit message
Improve the image metadata generation command
juju metadata generate-image was originally written
as a developer tool to aid simplestreams development.
It now is useful for setting up private clouds so has
been given a facelift to make it more user friendly.
The key feature is it will now use the current environment
to pick up most of what it needs, and the user just has to
supply the image id and architecture (if something different
to amd64 is required).
Description of the change
Improve the image metadata generation command
juju metadata generate-image was originally written
as a developer tool to aid simplestreams development.
It now is useful for setting up private clouds so has
been given a facelift to make it more user friendly.
The key feature is it will now use the current environment
to pick up most of what it needs, and the user just has to
supply the image id and architecture (if something different
to amd64 is required).
To post a comment you must log in.
Revision history for this message
| Ian Booth (wallyworld) wrote : | # |
Revision history for this message
| Andrew Wilkins (axwalk) wrote : | # |
https:/
File cmd/plugins/
https:/
cmd/plugins/
fmt.Errorf(
environ.Name())
What if the user has specified -s, -r, and -e on the command line? Is
this
really an error then?
Just a thought: perhaps ImageMetadataCo
If environ doesn't implement HasRegion, fall back to
ImageMetadataCo
https:/
File cmd/plugins/
https:/
cmd/plugins/
Move me please
https:/
cmd/plugins/
testbase.
You can just use s.PatchEnvironment here, which wraps
testbase.
Revision history for this message
| Ian Booth (wallyworld) wrote : | # |
Please take a look.
https:/
File cmd/plugins/
https:/
cmd/plugins/
fmt.Errorf(
environ.Name())
On 2013/10/15 07:08:34, axw wrote:
> What if the user has specified -s, -r, and -e on the command line? Is
this
> really an error then?
Hmmm. I thought yes when I wrote this. But I changed it so that it works
more as expected.
> Just a thought: perhaps ImageMetadataCo
HasRegion. If
> environ doesn't implement HasRegion, fall back to
ImageMetadataCo
See my changes - I think it's ok as is.
https:/
File cmd/plugins/
https:/
cmd/plugins/
On 2013/10/15 07:08:34, axw wrote:
> Move me please
Done.
https:/
cmd/plugins/
testbase.
On 2013/10/15 07:08:34, axw wrote:
> You can just use s.PatchEnvironment here, which wraps
testbase.
> & AddCleanup.
Done.
Revision history for this message
| Andrew Wilkins (axwalk) wrote : | # |
On 2013/10/16 02:57:49, wallyworld wrote:
> Please take a look.
https:/
> File cmd/plugins/
https:/
> cmd/plugins/
fmt.Errorf(
> cannot provide region and endpoint", environ.Name())
> On 2013/10/15 07:08:34, axw wrote:
> > What if the user has specified -s, -r, and -e on the command line?
Is this
> > really an error then?
> >
> Hmmm. I thought yes when I wrote this. But I changed it so that it
works more as
> expected.
> > Just a thought: perhaps ImageMetadataCo
HasRegion. If
> > environ doesn't implement HasRegion, fall back to
ImageMetadataCo
> See my changes - I think it's ok as is.
https:/
> File cmd/plugins/
https:/
> cmd/plugins/
> On 2013/10/15 07:08:34, axw wrote:
> > Move me please
> Done.
https:/
> cmd/plugins/
> testbase.
> On 2013/10/15 07:08:34, axw wrote:
> > You can just use s.PatchEnvironment here, which wraps
> testbase.
> > & AddCleanup.
> Done.
Thanks, LGTM
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'cmd/plugins/juju-metadata/imagemetadata.go' | |||
| 2 | --- cmd/plugins/juju-metadata/imagemetadata.go 2013-08-07 04:37:43 +0000 | |||
| 3 | +++ cmd/plugins/juju-metadata/imagemetadata.go 2013-10-16 02:57:31 +0000 | |||
| 4 | @@ -5,51 +5,102 @@ | |||
| 5 | 5 | 5 | ||
| 6 | 6 | import ( | 6 | import ( |
| 7 | 7 | "fmt" | 7 | "fmt" |
| 9 | 8 | "strings" | 8 | "os" |
| 10 | 9 | "path/filepath" | ||
| 11 | 9 | 10 | ||
| 12 | 10 | "launchpad.net/gnuflag" | 11 | "launchpad.net/gnuflag" |
| 13 | 11 | "launchpad.net/goose/identity" | ||
| 14 | 12 | 12 | ||
| 15 | 13 | "launchpad.net/juju-core/cmd" | 13 | "launchpad.net/juju-core/cmd" |
| 16 | 14 | "launchpad.net/juju-core/environs" | ||
| 17 | 14 | "launchpad.net/juju-core/environs/config" | 15 | "launchpad.net/juju-core/environs/config" |
| 18 | 16 | "launchpad.net/juju-core/environs/configstore" | ||
| 19 | 15 | "launchpad.net/juju-core/environs/imagemetadata" | 17 | "launchpad.net/juju-core/environs/imagemetadata" |
| 20 | 16 | "launchpad.net/juju-core/environs/simplestreams" | 18 | "launchpad.net/juju-core/environs/simplestreams" |
| 21 | 17 | ) | 19 | ) |
| 22 | 18 | 20 | ||
| 24 | 19 | // ImageMetadataCommand is used to write out a boilerplate environments.yaml file. | 21 | // ImageMetadataCommand is used to write out simplestreams image metadata information. |
| 25 | 20 | type ImageMetadataCommand struct { | 22 | type ImageMetadataCommand struct { |
| 33 | 21 | cmd.CommandBase | 23 | cmd.EnvCommandBase |
| 34 | 22 | Name string | 24 | Dir string |
| 35 | 23 | Series string | 25 | Series string |
| 36 | 24 | Arch string | 26 | Arch string |
| 37 | 25 | ImageId string | 27 | ImageId string |
| 38 | 26 | Region string | 28 | Region string |
| 39 | 27 | Endpoint string | 29 | Endpoint string |
| 40 | 30 | privateStorage string | ||
| 41 | 28 | } | 31 | } |
| 42 | 29 | 32 | ||
| 43 | 33 | var imageMetadataDoc = ` | ||
| 44 | 34 | generate-image creates simplestreams image metadata for the specified cloud. | ||
| 45 | 35 | |||
| 46 | 36 | The cloud specification comes from the current Juju environment, as specified in | ||
| 47 | 37 | the usual way from either ~/.juju/environments.yaml, the -e option, or JUJU_ENV. | ||
| 48 | 38 | |||
| 49 | 39 | Using command arguments, it is possible to override cloud attributes region, endpoint, and series. | ||
| 50 | 40 | By default, "amd64" is used for the architecture but this may also be changed. | ||
| 51 | 41 | ` | ||
| 52 | 42 | |||
| 53 | 30 | func (c *ImageMetadataCommand) Info() *cmd.Info { | 43 | func (c *ImageMetadataCommand) Info() *cmd.Info { |
| 54 | 31 | return &cmd.Info{ | 44 | return &cmd.Info{ |
| 55 | 32 | Name: "generate-image", | 45 | Name: "generate-image", |
| 56 | 33 | Purpose: "generate simplestreams image metadata", | 46 | Purpose: "generate simplestreams image metadata", |
| 57 | 47 | Doc: imageMetadataDoc, | ||
| 58 | 34 | } | 48 | } |
| 59 | 35 | } | 49 | } |
| 60 | 36 | 50 | ||
| 61 | 37 | func (c *ImageMetadataCommand) SetFlags(f *gnuflag.FlagSet) { | 51 | func (c *ImageMetadataCommand) SetFlags(f *gnuflag.FlagSet) { |
| 63 | 38 | f.StringVar(&c.Series, "s", "precise", "the charm series") | 52 | c.EnvCommandBase.SetFlags(f) |
| 64 | 53 | f.StringVar(&c.Series, "s", "", "the charm series") | ||
| 65 | 39 | f.StringVar(&c.Arch, "a", "amd64", "the image achitecture") | 54 | f.StringVar(&c.Arch, "a", "amd64", "the image achitecture") |
| 67 | 40 | f.StringVar(&c.Name, "n", "", "the cloud name, as a prefix for the generated file names") | 55 | f.StringVar(&c.Dir, "d", "", "the destination directory in which to place the metadata files") |
| 68 | 41 | f.StringVar(&c.ImageId, "i", "", "the image id") | 56 | f.StringVar(&c.ImageId, "i", "", "the image id") |
| 69 | 42 | f.StringVar(&c.Region, "r", "", "the region") | 57 | f.StringVar(&c.Region, "r", "", "the region") |
| 70 | 43 | f.StringVar(&c.Endpoint, "u", "", "the cloud endpoint (for Openstack, this is the Identity Service endpoint)") | 58 | f.StringVar(&c.Endpoint, "u", "", "the cloud endpoint (for Openstack, this is the Identity Service endpoint)") |
| 71 | 44 | } | 59 | } |
| 72 | 45 | 60 | ||
| 73 | 46 | func (c *ImageMetadataCommand) Init(args []string) error { | 61 | func (c *ImageMetadataCommand) Init(args []string) error { |
| 80 | 47 | cred := identity.CredentialsFromEnv() | 62 | c.privateStorage = "<private storage name>" |
| 81 | 48 | if c.Region == "" { | 63 | var environ environs.Environ |
| 82 | 49 | c.Region = cred.Region | 64 | if store, err := configstore.Default(); err == nil { |
| 83 | 50 | } | 65 | if environ, err = environs.PrepareFromName(c.EnvName, store); err == nil { |
| 84 | 51 | if c.Endpoint == "" { | 66 | logger.Infof("creating image metadata for environment %q", environ.Name()) |
| 85 | 52 | c.Endpoint = cred.URL | 67 | // If the user has not specified region and endpoint, try and get it from the environment. |
| 86 | 68 | if c.Region == "" || c.Endpoint == "" { | ||
| 87 | 69 | var cloudSpec simplestreams.CloudSpec | ||
| 88 | 70 | if inst, ok := environ.(simplestreams.HasRegion); ok { | ||
| 89 | 71 | if cloudSpec, err = inst.Region(); err != nil { | ||
| 90 | 72 | return err | ||
| 91 | 73 | } | ||
| 92 | 74 | } else { | ||
| 93 | 75 | return fmt.Errorf("environment %q cannot provide region and endpoint", environ.Name()) | ||
| 94 | 76 | } | ||
| 95 | 77 | // If only one of region or endpoint is provided, that is a problem. | ||
| 96 | 78 | if cloudSpec.Region != cloudSpec.Endpoint && (cloudSpec.Region == "" || cloudSpec.Endpoint == "") { | ||
| 97 | 79 | return fmt.Errorf("cannot generate metadata without a complete cloud configuration") | ||
| 98 | 80 | } | ||
| 99 | 81 | if c.Region == "" { | ||
| 100 | 82 | c.Region = cloudSpec.Region | ||
| 101 | 83 | } | ||
| 102 | 84 | if c.Endpoint == "" { | ||
| 103 | 85 | c.Endpoint = cloudSpec.Endpoint | ||
| 104 | 86 | } | ||
| 105 | 87 | } | ||
| 106 | 88 | cfg := environ.Config() | ||
| 107 | 89 | if c.Series == "" { | ||
| 108 | 90 | c.Series = cfg.DefaultSeries() | ||
| 109 | 91 | } | ||
| 110 | 92 | if v, ok := cfg.AllAttrs()["control-bucket"]; ok { | ||
| 111 | 93 | c.privateStorage = v.(string) | ||
| 112 | 94 | } | ||
| 113 | 95 | } else { | ||
| 114 | 96 | logger.Warningf("environment %q could not be opened: %v", c.EnvName, err) | ||
| 115 | 97 | } | ||
| 116 | 98 | } | ||
| 117 | 99 | if environ == nil { | ||
| 118 | 100 | logger.Infof("no environment found, creating image metadata using user supplied data") | ||
| 119 | 101 | } | ||
| 120 | 102 | if c.Series == "" { | ||
| 121 | 103 | c.Series = config.DefaultSeries | ||
| 122 | 53 | } | 104 | } |
| 123 | 54 | if c.ImageId == "" { | 105 | if c.ImageId == "" { |
| 124 | 55 | return fmt.Errorf("image id must be specified") | 106 | return fmt.Errorf("image id must be specified") |
| 125 | @@ -60,10 +111,36 @@ | |||
| 126 | 60 | if c.Endpoint == "" { | 111 | if c.Endpoint == "" { |
| 127 | 61 | return fmt.Errorf("cloud endpoint URL must be specified") | 112 | return fmt.Errorf("cloud endpoint URL must be specified") |
| 128 | 62 | } | 113 | } |
| 129 | 114 | if c.Dir == "" { | ||
| 130 | 115 | logger.Infof("no destination directory specified, using current directory") | ||
| 131 | 116 | var err error | ||
| 132 | 117 | if c.Dir, err = os.Getwd(); err != nil { | ||
| 133 | 118 | return err | ||
| 134 | 119 | } | ||
| 135 | 120 | } | ||
| 136 | 63 | 121 | ||
| 137 | 64 | return cmd.CheckEmpty(args) | 122 | return cmd.CheckEmpty(args) |
| 138 | 65 | } | 123 | } |
| 139 | 66 | 124 | ||
| 140 | 125 | var helpDoc = ` | ||
| 141 | 126 | image metadata files have been written to: | ||
| 142 | 127 | %q. | ||
| 143 | 128 | For Juju to use this metadata, the files need to be put into the | ||
| 144 | 129 | image metadata search path. There are 2 options: | ||
| 145 | 130 | |||
| 146 | 131 | 1. Use tools-url in $JUJU_HOME/environments.yaml | ||
| 147 | 132 | Configure a http server to serve the contents of | ||
| 148 | 133 | %q | ||
| 149 | 134 | and set the value of tools-url accordingly. | ||
| 150 | 135 | |||
| 151 | 136 | 2. Upload the contents of | ||
| 152 | 137 | %q | ||
| 153 | 138 | to your cloud's private storage (for ec2 and openstack). | ||
| 154 | 139 | eg for openstack | ||
| 155 | 140 | "cd %s; swift upload %s streams/v1/*" | ||
| 156 | 141 | |||
| 157 | 142 | ` | ||
| 158 | 143 | |||
| 159 | 67 | func (c *ImageMetadataCommand) Run(context *cmd.Context) error { | 144 | func (c *ImageMetadataCommand) Run(context *cmd.Context) error { |
| 160 | 68 | out := context.Stdout | 145 | out := context.Stdout |
| 161 | 69 | 146 | ||
| 162 | @@ -75,14 +152,11 @@ | |||
| 163 | 75 | Region: c.Region, | 152 | Region: c.Region, |
| 164 | 76 | Endpoint: c.Endpoint, | 153 | Endpoint: c.Endpoint, |
| 165 | 77 | } | 154 | } |
| 167 | 78 | files, err := imagemetadata.Boilerplate(c.Name, c.Series, &im, &cloudSpec) | 155 | _, err := imagemetadata.GenerateMetadata(c.Series, &im, &cloudSpec, c.Dir) |
| 168 | 79 | if err != nil { | 156 | if err != nil { |
| 170 | 80 | return fmt.Errorf("boilerplate image metadata files could not be created: %v", err) | 157 | return fmt.Errorf("image metadata files could not be created: %v", err) |
| 171 | 81 | } | 158 | } |
| 177 | 82 | fmt.Fprintf( | 159 | dest := filepath.Join(c.Dir, "streams", "v1") |
| 178 | 83 | out, | 160 | fmt.Fprintf(out, fmt.Sprintf(helpDoc, dest, c.Dir, c.Dir, c.Dir, c.privateStorage)) |
| 174 | 84 | "Boilerplate image metadata files %q have been written to %s.\n", strings.Join(files, ", "), config.JujuHome()) | ||
| 175 | 85 | fmt.Fprintf(out, `Copy the files to the path "streams/v1" in your cloud's public bucket.`) | ||
| 176 | 86 | fmt.Fprintln(out, "") | ||
| 179 | 87 | return nil | 161 | return nil |
| 180 | 88 | } | 162 | } |
| 181 | 89 | 163 | ||
| 182 | === modified file 'cmd/plugins/juju-metadata/imagemetadata_test.go' | |||
| 183 | --- cmd/plugins/juju-metadata/imagemetadata_test.go 2013-07-30 23:18:16 +0000 | |||
| 184 | +++ cmd/plugins/juju-metadata/imagemetadata_test.go 2013-10-16 02:57:31 +0000 | |||
| 185 | @@ -9,26 +9,45 @@ | |||
| 186 | 9 | "fmt" | 9 | "fmt" |
| 187 | 10 | "io/ioutil" | 10 | "io/ioutil" |
| 188 | 11 | "os" | 11 | "os" |
| 189 | 12 | "path/filepath" | ||
| 190 | 12 | "strings" | 13 | "strings" |
| 191 | 13 | 14 | ||
| 192 | 14 | gc "launchpad.net/gocheck" | 15 | gc "launchpad.net/gocheck" |
| 193 | 15 | 16 | ||
| 194 | 16 | "launchpad.net/juju-core/cmd" | 17 | "launchpad.net/juju-core/cmd" |
| 195 | 17 | "launchpad.net/juju-core/testing" | 18 | "launchpad.net/juju-core/testing" |
| 196 | 19 | jc "launchpad.net/juju-core/testing/checkers" | ||
| 197 | 20 | "launchpad.net/juju-core/testing/testbase" | ||
| 198 | 18 | ) | 21 | ) |
| 199 | 19 | 22 | ||
| 200 | 20 | type ImageMetadataSuite struct { | 23 | type ImageMetadataSuite struct { |
| 201 | 24 | testbase.LoggingSuite | ||
| 202 | 21 | environ []string | 25 | environ []string |
| 203 | 26 | home *testing.FakeHome | ||
| 204 | 27 | dir string | ||
| 205 | 22 | } | 28 | } |
| 206 | 23 | 29 | ||
| 207 | 24 | var _ = gc.Suite(&ImageMetadataSuite{}) | 30 | var _ = gc.Suite(&ImageMetadataSuite{}) |
| 208 | 25 | 31 | ||
| 209 | 26 | func (s *ImageMetadataSuite) SetUpSuite(c *gc.C) { | 32 | func (s *ImageMetadataSuite) SetUpSuite(c *gc.C) { |
| 210 | 33 | s.LoggingSuite.SetUpSuite(c) | ||
| 211 | 27 | s.environ = os.Environ() | 34 | s.environ = os.Environ() |
| 212 | 28 | } | 35 | } |
| 213 | 29 | 36 | ||
| 214 | 30 | func (s *ImageMetadataSuite) SetUpTest(c *gc.C) { | 37 | func (s *ImageMetadataSuite) SetUpTest(c *gc.C) { |
| 215 | 38 | s.LoggingSuite.SetUpTest(c) | ||
| 216 | 31 | os.Clearenv() | 39 | os.Clearenv() |
| 217 | 40 | s.dir = c.MkDir() | ||
| 218 | 41 | // Create a fake certificate so azure test environment can be opened. | ||
| 219 | 42 | certfile, err := ioutil.TempFile(s.dir, "") | ||
| 220 | 43 | c.Assert(err, gc.IsNil) | ||
| 221 | 44 | filename := certfile.Name() | ||
| 222 | 45 | err = ioutil.WriteFile(filename, []byte("test certificate"), 0644) | ||
| 223 | 46 | c.Assert(err, gc.IsNil) | ||
| 224 | 47 | envConfig := strings.Replace(metadataTestEnvConfig, "/home/me/azure.pem", filename, -1) | ||
| 225 | 48 | s.home = testing.MakeFakeHome(c, envConfig) | ||
| 226 | 49 | s.PatchEnvironment("AWS_ACCESS_KEY_ID", "access") | ||
| 227 | 50 | s.PatchEnvironment("AWS_SECRET_ACCESS_KEY", "secret") | ||
| 228 | 32 | } | 51 | } |
| 229 | 33 | 52 | ||
| 230 | 34 | func (s *ImageMetadataSuite) TearDownTest(c *gc.C) { | 53 | func (s *ImageMetadataSuite) TearDownTest(c *gc.C) { |
| 231 | @@ -36,6 +55,8 @@ | |||
| 232 | 36 | kv := strings.SplitN(envstring, "=", 2) | 55 | kv := strings.SplitN(envstring, "=", 2) |
| 233 | 37 | os.Setenv(kv[0], kv[1]) | 56 | os.Setenv(kv[0], kv[1]) |
| 234 | 38 | } | 57 | } |
| 235 | 58 | s.home.Restore() | ||
| 236 | 59 | s.LoggingSuite.TearDownTest(c) | ||
| 237 | 39 | } | 60 | } |
| 238 | 40 | 61 | ||
| 239 | 41 | var seriesVersions map[string]string = map[string]string{ | 62 | var seriesVersions map[string]string = map[string]string{ |
| 240 | @@ -43,31 +64,46 @@ | |||
| 241 | 43 | "raring": "13.04", | 64 | "raring": "13.04", |
| 242 | 44 | } | 65 | } |
| 243 | 45 | 66 | ||
| 245 | 46 | func (*ImageMetadataSuite) assertCommandOutput(c *gc.C, errOut, series, arch, indexFileName, imageFileName string) { | 67 | type expectedMetadata struct { |
| 246 | 68 | series string | ||
| 247 | 69 | arch string | ||
| 248 | 70 | region string | ||
| 249 | 71 | endpoint string | ||
| 250 | 72 | } | ||
| 251 | 73 | |||
| 252 | 74 | func (s *ImageMetadataSuite) assertCommandOutput(c *gc.C, expected expectedMetadata, errOut, indexFileName, imageFileName string) { | ||
| 253 | 75 | if expected.region == "" { | ||
| 254 | 76 | expected.region = "region" | ||
| 255 | 77 | } | ||
| 256 | 78 | if expected.endpoint == "" { | ||
| 257 | 79 | expected.endpoint = "endpoint" | ||
| 258 | 80 | } | ||
| 259 | 47 | strippedOut := strings.Replace(errOut, "\n", "", -1) | 81 | strippedOut := strings.Replace(errOut, "\n", "", -1) |
| 262 | 48 | c.Check(strippedOut, gc.Matches, `Boilerplate image metadata files.*have been written.*Copy the files.*`) | 82 | c.Check(strippedOut, gc.Matches, `image metadata files have been written to.*`) |
| 263 | 49 | indexpath := testing.HomePath(".juju", indexFileName) | 83 | indexpath := filepath.Join(s.dir, "streams", "v1", indexFileName) |
| 264 | 50 | data, err := ioutil.ReadFile(indexpath) | 84 | data, err := ioutil.ReadFile(indexpath) |
| 265 | 51 | c.Assert(err, gc.IsNil) | 85 | c.Assert(err, gc.IsNil) |
| 266 | 86 | content := string(data) | ||
| 267 | 52 | var indices interface{} | 87 | var indices interface{} |
| 268 | 53 | err = json.Unmarshal(data, &indices) | 88 | err = json.Unmarshal(data, &indices) |
| 269 | 54 | c.Assert(err, gc.IsNil) | 89 | c.Assert(err, gc.IsNil) |
| 270 | 55 | c.Assert(indices.(map[string]interface{})["format"], gc.Equals, "index:1.0") | 90 | c.Assert(indices.(map[string]interface{})["format"], gc.Equals, "index:1.0") |
| 276 | 56 | prodId := fmt.Sprintf("com.ubuntu.cloud:server:%s:%s", seriesVersions[series], arch) | 91 | prodId := fmt.Sprintf("com.ubuntu.cloud:server:%s:%s", seriesVersions[expected.series], expected.arch) |
| 277 | 57 | c.Assert(strings.Contains(string(data), prodId), gc.Equals, true) | 92 | c.Assert(strings.Contains(content, prodId), jc.IsTrue) |
| 278 | 58 | c.Assert(strings.Contains(string(data), `"region": "region"`), gc.Equals, true) | 93 | c.Assert(strings.Contains(content, fmt.Sprintf(`"region": %q`, expected.region)), jc.IsTrue) |
| 279 | 59 | c.Assert(strings.Contains(string(data), `"endpoint": "endpoint"`), gc.Equals, true) | 94 | c.Assert(strings.Contains(content, fmt.Sprintf(`"endpoint": %q`, expected.endpoint)), jc.IsTrue) |
| 280 | 60 | c.Assert(strings.Contains(string(data), fmt.Sprintf(`"path": "streams/v1/%s"`, imageFileName)), gc.Equals, true) | 95 | c.Assert(strings.Contains(content, fmt.Sprintf(`"path": "streams/v1/%s"`, imageFileName)), jc.IsTrue) |
| 281 | 61 | 96 | ||
| 283 | 62 | imagepath := testing.HomePath(".juju", imageFileName) | 97 | imagepath := filepath.Join(s.dir, "streams", "v1", imageFileName) |
| 284 | 63 | data, err = ioutil.ReadFile(imagepath) | 98 | data, err = ioutil.ReadFile(imagepath) |
| 285 | 64 | c.Assert(err, gc.IsNil) | 99 | c.Assert(err, gc.IsNil) |
| 286 | 100 | content = string(data) | ||
| 287 | 65 | var images interface{} | 101 | var images interface{} |
| 288 | 66 | err = json.Unmarshal(data, &images) | 102 | err = json.Unmarshal(data, &images) |
| 289 | 67 | c.Assert(err, gc.IsNil) | 103 | c.Assert(err, gc.IsNil) |
| 290 | 68 | c.Assert(images.(map[string]interface{})["format"], gc.Equals, "products:1.0") | 104 | c.Assert(images.(map[string]interface{})["format"], gc.Equals, "products:1.0") |
| 293 | 69 | c.Assert(strings.Contains(string(data), prodId), gc.Equals, true) | 105 | c.Assert(strings.Contains(content, prodId), gc.Equals, true) |
| 294 | 70 | c.Assert(strings.Contains(string(data), `"id": "1234"`), gc.Equals, true) | 106 | c.Assert(strings.Contains(content, `"id": "1234"`), gc.Equals, true) |
| 295 | 71 | } | 107 | } |
| 296 | 72 | 108 | ||
| 297 | 73 | const ( | 109 | const ( |
| 298 | @@ -76,71 +112,92 @@ | |||
| 299 | 76 | ) | 112 | ) |
| 300 | 77 | 113 | ||
| 301 | 78 | func (s *ImageMetadataSuite) TestImageMetadataFilesNoEnv(c *gc.C) { | 114 | func (s *ImageMetadataSuite) TestImageMetadataFilesNoEnv(c *gc.C) { |
| 321 | 79 | defer testing.MakeEmptyFakeHome(c).Restore() | 115 | ctx := testing.Context(c) |
| 322 | 80 | 116 | code := cmd.Main( | |
| 323 | 81 | ctx := testing.Context(c) | 117 | &ImageMetadataCommand{}, ctx, []string{ |
| 324 | 82 | code := cmd.Main( | 118 | "-d", s.dir, "-i", "1234", "-r", "region", "-a", "arch", "-u", "endpoint", "-s", "raring"}) |
| 325 | 83 | &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-r", "region", "-a", "arch", "-u", "endpoint", "-s", "raring"}) | 119 | c.Assert(code, gc.Equals, 0) |
| 326 | 84 | c.Assert(code, gc.Equals, 0) | 120 | errOut := ctx.Stdout.(*bytes.Buffer).String() |
| 327 | 85 | errOut := ctx.Stdout.(*bytes.Buffer).String() | 121 | expected := expectedMetadata{ |
| 328 | 86 | s.assertCommandOutput(c, errOut, "raring", "arch", defaultIndexFileName, defaultImageFileName) | 122 | series: "raring", |
| 329 | 87 | } | 123 | arch: "arch", |
| 330 | 88 | 124 | } | |
| 331 | 89 | func (s *ImageMetadataSuite) TestImageMetadataFilesWithName(c *gc.C) { | 125 | s.assertCommandOutput(c, expected, errOut, defaultIndexFileName, defaultImageFileName) |
| 313 | 90 | defer testing.MakeEmptyFakeHome(c).Restore() | ||
| 314 | 91 | |||
| 315 | 92 | ctx := testing.Context(c) | ||
| 316 | 93 | code := cmd.Main( | ||
| 317 | 94 | &ImageMetadataCommand{}, ctx, []string{"-n", "foo", "-i", "1234", "-r", "region", "-a", "arch", "-u", "endpoint", "-s", "raring"}) | ||
| 318 | 95 | c.Assert(code, gc.Equals, 0) | ||
| 319 | 96 | errOut := ctx.Stdout.(*bytes.Buffer).String() | ||
| 320 | 97 | s.assertCommandOutput(c, errOut, "raring", "arch", "foo-"+defaultIndexFileName, "foo-"+defaultImageFileName) | ||
| 332 | 98 | } | 126 | } |
| 333 | 99 | 127 | ||
| 334 | 100 | func (s *ImageMetadataSuite) TestImageMetadataFilesDefaultArch(c *gc.C) { | 128 | func (s *ImageMetadataSuite) TestImageMetadataFilesDefaultArch(c *gc.C) { |
| 335 | 101 | defer testing.MakeEmptyFakeHome(c).Restore() | ||
| 336 | 102 | |||
| 337 | 103 | ctx := testing.Context(c) | 129 | ctx := testing.Context(c) |
| 338 | 104 | code := cmd.Main( | 130 | code := cmd.Main( |
| 340 | 105 | &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-r", "region", "-u", "endpoint", "-s", "raring"}) | 131 | &ImageMetadataCommand{}, ctx, []string{ |
| 341 | 132 | "-d", s.dir, "-i", "1234", "-r", "region", "-u", "endpoint", "-s", "raring"}) | ||
| 342 | 106 | c.Assert(code, gc.Equals, 0) | 133 | c.Assert(code, gc.Equals, 0) |
| 343 | 107 | errOut := ctx.Stdout.(*bytes.Buffer).String() | 134 | errOut := ctx.Stdout.(*bytes.Buffer).String() |
| 345 | 108 | s.assertCommandOutput(c, errOut, "raring", "amd64", defaultIndexFileName, defaultImageFileName) | 135 | expected := expectedMetadata{ |
| 346 | 136 | series: "raring", | ||
| 347 | 137 | arch: "amd64", | ||
| 348 | 138 | } | ||
| 349 | 139 | s.assertCommandOutput(c, expected, errOut, defaultIndexFileName, defaultImageFileName) | ||
| 350 | 109 | } | 140 | } |
| 351 | 110 | 141 | ||
| 352 | 111 | func (s *ImageMetadataSuite) TestImageMetadataFilesDefaultSeries(c *gc.C) { | 142 | func (s *ImageMetadataSuite) TestImageMetadataFilesDefaultSeries(c *gc.C) { |
| 385 | 112 | defer testing.MakeEmptyFakeHome(c).Restore() | 143 | ctx := testing.Context(c) |
| 386 | 113 | 144 | code := cmd.Main( | |
| 387 | 114 | ctx := testing.Context(c) | 145 | &ImageMetadataCommand{}, ctx, []string{ |
| 388 | 115 | code := cmd.Main( | 146 | "-d", s.dir, "-i", "1234", "-r", "region", "-a", "arch", "-u", "endpoint"}) |
| 389 | 116 | &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-r", "region", "-a", "arch", "-u", "endpoint"}) | 147 | c.Assert(code, gc.Equals, 0) |
| 390 | 117 | c.Assert(code, gc.Equals, 0) | 148 | errOut := ctx.Stdout.(*bytes.Buffer).String() |
| 391 | 118 | errOut := ctx.Stdout.(*bytes.Buffer).String() | 149 | expected := expectedMetadata{ |
| 392 | 119 | s.assertCommandOutput(c, errOut, "precise", "arch", defaultIndexFileName, defaultImageFileName) | 150 | series: "precise", |
| 393 | 120 | } | 151 | arch: "arch", |
| 394 | 121 | 152 | } | |
| 395 | 122 | func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnvRegion(c *gc.C) { | 153 | s.assertCommandOutput(c, expected, errOut, defaultIndexFileName, defaultImageFileName) |
| 396 | 123 | defer testing.MakeEmptyFakeHome(c).Restore() | 154 | } |
| 397 | 124 | 155 | ||
| 398 | 125 | os.Setenv("OS_REGION_NAME", "region") | 156 | func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnv(c *gc.C) { |
| 399 | 126 | ctx := testing.Context(c) | 157 | ctx := testing.Context(c) |
| 400 | 127 | code := cmd.Main( | 158 | code := cmd.Main( |
| 401 | 128 | &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-u", "endpoint"}) | 159 | &ImageMetadataCommand{}, ctx, []string{"-d", s.dir, "-e", "ec2", "-i", "1234"}) |
| 402 | 129 | c.Assert(code, gc.Equals, 0) | 160 | c.Assert(code, gc.Equals, 0) |
| 403 | 130 | errOut := ctx.Stdout.(*bytes.Buffer).String() | 161 | errOut := ctx.Stdout.(*bytes.Buffer).String() |
| 404 | 131 | s.assertCommandOutput(c, errOut, "precise", "amd64", defaultIndexFileName, defaultImageFileName) | 162 | expected := expectedMetadata{ |
| 405 | 132 | } | 163 | series: "precise", |
| 406 | 133 | 164 | arch: "amd64", | |
| 407 | 134 | func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnvEndpoint(c *gc.C) { | 165 | region: "us-east-1", |
| 408 | 135 | defer testing.MakeEmptyFakeHome(c).Restore() | 166 | endpoint: "https://ec2.us-east-1.amazonaws.com", |
| 409 | 136 | 167 | } | |
| 410 | 137 | os.Setenv("OS_AUTH_URL", "endpoint") | 168 | s.assertCommandOutput(c, expected, errOut, defaultIndexFileName, defaultImageFileName) |
| 411 | 138 | ctx := testing.Context(c) | 169 | } |
| 412 | 139 | code := cmd.Main( | 170 | |
| 413 | 140 | &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-r", "region"}) | 171 | func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnvWithRegionOverride(c *gc.C) { |
| 414 | 141 | c.Assert(code, gc.Equals, 0) | 172 | ctx := testing.Context(c) |
| 415 | 142 | errOut := ctx.Stdout.(*bytes.Buffer).String() | 173 | code := cmd.Main( |
| 416 | 143 | s.assertCommandOutput(c, errOut, "precise", "amd64", defaultIndexFileName, defaultImageFileName) | 174 | &ImageMetadataCommand{}, ctx, []string{ |
| 417 | 175 | "-d", s.dir, "-e", "ec2", "-r", "us-west-1", "-u", "https://ec2.us-west-1.amazonaws.com", "-i", "1234"}) | ||
| 418 | 176 | c.Assert(code, gc.Equals, 0) | ||
| 419 | 177 | errOut := ctx.Stdout.(*bytes.Buffer).String() | ||
| 420 | 178 | expected := expectedMetadata{ | ||
| 421 | 179 | series: "precise", | ||
| 422 | 180 | arch: "amd64", | ||
| 423 | 181 | region: "us-west-1", | ||
| 424 | 182 | endpoint: "https://ec2.us-west-1.amazonaws.com", | ||
| 425 | 183 | } | ||
| 426 | 184 | s.assertCommandOutput(c, expected, errOut, defaultIndexFileName, defaultImageFileName) | ||
| 427 | 185 | } | ||
| 428 | 186 | |||
| 429 | 187 | func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnvWithNoHasRegion(c *gc.C) { | ||
| 430 | 188 | ctx := testing.Context(c) | ||
| 431 | 189 | code := cmd.Main( | ||
| 432 | 190 | &ImageMetadataCommand{}, ctx, []string{ | ||
| 433 | 191 | "-d", s.dir, "-e", "azure", "-r", "region", "-u", "endpoint", "-i", "1234"}) | ||
| 434 | 192 | c.Assert(code, gc.Equals, 0) | ||
| 435 | 193 | errOut := ctx.Stdout.(*bytes.Buffer).String() | ||
| 436 | 194 | expected := expectedMetadata{ | ||
| 437 | 195 | series: "raring", | ||
| 438 | 196 | arch: "amd64", | ||
| 439 | 197 | region: "region", | ||
| 440 | 198 | endpoint: "endpoint", | ||
| 441 | 199 | } | ||
| 442 | 200 | s.assertCommandOutput(c, expected, errOut, defaultIndexFileName, defaultImageFileName) | ||
| 443 | 144 | } | 201 | } |
| 444 | 145 | 202 | ||
| 445 | 146 | type errTestParams struct { | 203 | type errTestParams struct { |
| 446 | @@ -160,6 +217,10 @@ | |||
| 447 | 160 | // Missing endpoint | 217 | // Missing endpoint |
| 448 | 161 | args: []string{"-i", "1234", "-u", "endpoint", "-a", "arch", "-s", "precise"}, | 218 | args: []string{"-i", "1234", "-u", "endpoint", "-a", "arch", "-s", "precise"}, |
| 449 | 162 | }, | 219 | }, |
| 450 | 220 | { | ||
| 451 | 221 | // Missing endpoint/region for environment with no HasRegion interface | ||
| 452 | 222 | args: []string{"-i", "1234", "-e", "azure"}, | ||
| 453 | 223 | }, | ||
| 454 | 163 | } | 224 | } |
| 455 | 164 | 225 | ||
| 456 | 165 | func (s *ImageMetadataSuite) TestImageMetadataBadArgs(c *gc.C) { | 226 | func (s *ImageMetadataSuite) TestImageMetadataBadArgs(c *gc.C) { |
| 457 | 166 | 227 | ||
| 458 | === modified file 'cmd/plugins/juju-metadata/validateimagemetadata_test.go' | |||
| 459 | --- cmd/plugins/juju-metadata/validateimagemetadata_test.go 2013-10-10 11:40:54 +0000 | |||
| 460 | +++ cmd/plugins/juju-metadata/validateimagemetadata_test.go 2013-10-16 02:57:31 +0000 | |||
| 461 | @@ -11,7 +11,6 @@ | |||
| 462 | 11 | gc "launchpad.net/gocheck" | 11 | gc "launchpad.net/gocheck" |
| 463 | 12 | 12 | ||
| 464 | 13 | "launchpad.net/juju-core/cmd" | 13 | "launchpad.net/juju-core/cmd" |
| 465 | 14 | "launchpad.net/juju-core/environs/config" | ||
| 466 | 15 | "launchpad.net/juju-core/environs/imagemetadata" | 14 | "launchpad.net/juju-core/environs/imagemetadata" |
| 467 | 16 | "launchpad.net/juju-core/environs/simplestreams" | 15 | "launchpad.net/juju-core/environs/simplestreams" |
| 468 | 17 | coretesting "launchpad.net/juju-core/testing" | 16 | coretesting "launchpad.net/juju-core/testing" |
| 469 | @@ -20,7 +19,8 @@ | |||
| 470 | 20 | 19 | ||
| 471 | 21 | type ValidateImageMetadataSuite struct { | 20 | type ValidateImageMetadataSuite struct { |
| 472 | 22 | testbase.LoggingSuite | 21 | testbase.LoggingSuite |
| 474 | 23 | home *coretesting.FakeHome | 22 | home *coretesting.FakeHome |
| 475 | 23 | metadataDir string | ||
| 476 | 24 | } | 24 | } |
| 477 | 25 | 25 | ||
| 478 | 26 | var _ = gc.Suite(&ValidateImageMetadataSuite{}) | 26 | var _ = gc.Suite(&ValidateImageMetadataSuite{}) |
| 479 | @@ -73,7 +73,7 @@ | |||
| 480 | 73 | Region: region, | 73 | Region: region, |
| 481 | 74 | Endpoint: endpoint, | 74 | Endpoint: endpoint, |
| 482 | 75 | } | 75 | } |
| 484 | 76 | _, err := imagemetadata.MakeBoilerplate("", series, &im, &cloudSpec, false) | 76 | _, err := imagemetadata.GenerateMetadata(series, &im, &cloudSpec, s.metadataDir) |
| 485 | 77 | if err != nil { | 77 | if err != nil { |
| 486 | 78 | return err | 78 | return err |
| 487 | 79 | } | 79 | } |
| 488 | @@ -84,13 +84,21 @@ | |||
| 489 | 84 | environments: | 84 | environments: |
| 490 | 85 | ec2: | 85 | ec2: |
| 491 | 86 | type: ec2 | 86 | type: ec2 |
| 492 | 87 | control-bucket: foo | ||
| 493 | 88 | default-series: precise | 87 | default-series: precise |
| 494 | 89 | region: us-east-1 | 88 | region: us-east-1 |
| 495 | 89 | |||
| 496 | 90 | azure: | ||
| 497 | 91 | type: azure | ||
| 498 | 92 | default-series: raring | ||
| 499 | 93 | location: US West | ||
| 500 | 94 | management-subscription-id: foo | ||
| 501 | 95 | storage-account-name: bar | ||
| 502 | 96 | management-certificate-path: /home/me/azure.pem | ||
| 503 | 90 | ` | 97 | ` |
| 504 | 91 | 98 | ||
| 505 | 92 | func (s *ValidateImageMetadataSuite) SetUpTest(c *gc.C) { | 99 | func (s *ValidateImageMetadataSuite) SetUpTest(c *gc.C) { |
| 506 | 93 | s.LoggingSuite.SetUpTest(c) | 100 | s.LoggingSuite.SetUpTest(c) |
| 507 | 101 | s.metadataDir = c.MkDir() | ||
| 508 | 94 | s.home = coretesting.MakeFakeHome(c, metadataTestEnvConfig) | 102 | s.home = coretesting.MakeFakeHome(c, metadataTestEnvConfig) |
| 509 | 95 | restore := testbase.PatchEnvironment("AWS_ACCESS_KEY_ID", "access") | 103 | restore := testbase.PatchEnvironment("AWS_ACCESS_KEY_ID", "access") |
| 510 | 96 | s.AddCleanup(func(*gc.C) { restore() }) | 104 | s.AddCleanup(func(*gc.C) { restore() }) |
| 511 | @@ -115,9 +123,8 @@ | |||
| 512 | 115 | func (s *ValidateImageMetadataSuite) TestEc2LocalMetadataUsingEnvironment(c *gc.C) { | 123 | func (s *ValidateImageMetadataSuite) TestEc2LocalMetadataUsingEnvironment(c *gc.C) { |
| 513 | 116 | s.setupEc2LocalMetadata(c, "us-east-1") | 124 | s.setupEc2LocalMetadata(c, "us-east-1") |
| 514 | 117 | ctx := coretesting.Context(c) | 125 | ctx := coretesting.Context(c) |
| 515 | 118 | metadataDir := config.JujuHomePath("") | ||
| 516 | 119 | code := cmd.Main( | 126 | code := cmd.Main( |
| 518 | 120 | &ValidateImageMetadataCommand{}, ctx, []string{"-e", "ec2", "-d", metadataDir}, | 127 | &ValidateImageMetadataCommand{}, ctx, []string{"-e", "ec2", "-d", s.metadataDir}, |
| 519 | 121 | ) | 128 | ) |
| 520 | 122 | c.Assert(code, gc.Equals, 0) | 129 | c.Assert(code, gc.Equals, 0) |
| 521 | 123 | errOut := ctx.Stdout.(*bytes.Buffer).String() | 130 | errOut := ctx.Stdout.(*bytes.Buffer).String() |
| 522 | @@ -128,11 +135,12 @@ | |||
| 523 | 128 | func (s *ValidateImageMetadataSuite) TestEc2LocalMetadataUsingIncompleteEnvironment(c *gc.C) { | 135 | func (s *ValidateImageMetadataSuite) TestEc2LocalMetadataUsingIncompleteEnvironment(c *gc.C) { |
| 524 | 129 | testbase.PatchEnvironment("AWS_ACCESS_KEY_ID", "") | 136 | testbase.PatchEnvironment("AWS_ACCESS_KEY_ID", "") |
| 525 | 130 | testbase.PatchEnvironment("AWS_SECRET_ACCESS_KEY", "") | 137 | testbase.PatchEnvironment("AWS_SECRET_ACCESS_KEY", "") |
| 526 | 138 | testbase.PatchEnvironment("EC2_ACCESS_KEY", "") | ||
| 527 | 139 | testbase.PatchEnvironment("EC2_SECRET_KEY", "") | ||
| 528 | 131 | s.setupEc2LocalMetadata(c, "us-east-1") | 140 | s.setupEc2LocalMetadata(c, "us-east-1") |
| 529 | 132 | ctx := coretesting.Context(c) | 141 | ctx := coretesting.Context(c) |
| 530 | 133 | metadataDir := config.JujuHomePath("") | ||
| 531 | 134 | code := cmd.Main( | 142 | code := cmd.Main( |
| 533 | 135 | &ValidateImageMetadataCommand{}, ctx, []string{"-e", "ec2", "-d", metadataDir}, | 143 | &ValidateImageMetadataCommand{}, ctx, []string{"-e", "ec2", "-d", s.metadataDir}, |
| 534 | 136 | ) | 144 | ) |
| 535 | 137 | c.Assert(code, gc.Equals, 1) | 145 | c.Assert(code, gc.Equals, 1) |
| 536 | 138 | errOut := ctx.Stderr.(*bytes.Buffer).String() | 146 | errOut := ctx.Stderr.(*bytes.Buffer).String() |
| 537 | @@ -143,11 +151,10 @@ | |||
| 538 | 143 | func (s *ValidateImageMetadataSuite) TestEc2LocalMetadataWithManualParams(c *gc.C) { | 151 | func (s *ValidateImageMetadataSuite) TestEc2LocalMetadataWithManualParams(c *gc.C) { |
| 539 | 144 | s.setupEc2LocalMetadata(c, "us-west-1") | 152 | s.setupEc2LocalMetadata(c, "us-west-1") |
| 540 | 145 | ctx := coretesting.Context(c) | 153 | ctx := coretesting.Context(c) |
| 541 | 146 | metadataDir := config.JujuHomePath("") | ||
| 542 | 147 | code := cmd.Main( | 154 | code := cmd.Main( |
| 543 | 148 | &ValidateImageMetadataCommand{}, ctx, []string{ | 155 | &ValidateImageMetadataCommand{}, ctx, []string{ |
| 544 | 149 | "-p", "ec2", "-s", "precise", "-r", "us-west-1", | 156 | "-p", "ec2", "-s", "precise", "-r", "us-west-1", |
| 546 | 150 | "-u", "https://ec2.us-west-1.amazonaws.com", "-d", metadataDir}, | 157 | "-u", "https://ec2.us-west-1.amazonaws.com", "-d", s.metadataDir}, |
| 547 | 151 | ) | 158 | ) |
| 548 | 152 | c.Assert(code, gc.Equals, 0) | 159 | c.Assert(code, gc.Equals, 0) |
| 549 | 153 | errOut := ctx.Stdout.(*bytes.Buffer).String() | 160 | errOut := ctx.Stdout.(*bytes.Buffer).String() |
| 550 | @@ -158,17 +165,16 @@ | |||
| 551 | 158 | func (s *ValidateImageMetadataSuite) TestEc2LocalMetadataNoMatch(c *gc.C) { | 165 | func (s *ValidateImageMetadataSuite) TestEc2LocalMetadataNoMatch(c *gc.C) { |
| 552 | 159 | s.setupEc2LocalMetadata(c, "us-east-1") | 166 | s.setupEc2LocalMetadata(c, "us-east-1") |
| 553 | 160 | ctx := coretesting.Context(c) | 167 | ctx := coretesting.Context(c) |
| 554 | 161 | metadataDir := config.JujuHomePath("") | ||
| 555 | 162 | code := cmd.Main( | 168 | code := cmd.Main( |
| 556 | 163 | &ValidateImageMetadataCommand{}, ctx, []string{ | 169 | &ValidateImageMetadataCommand{}, ctx, []string{ |
| 557 | 164 | "-p", "ec2", "-s", "raring", "-r", "us-west-1", | 170 | "-p", "ec2", "-s", "raring", "-r", "us-west-1", |
| 559 | 165 | "-u", "https://ec2.us-west-1.amazonaws.com", "-d", metadataDir}, | 171 | "-u", "https://ec2.us-west-1.amazonaws.com", "-d", s.metadataDir}, |
| 560 | 166 | ) | 172 | ) |
| 561 | 167 | c.Assert(code, gc.Equals, 1) | 173 | c.Assert(code, gc.Equals, 1) |
| 562 | 168 | code = cmd.Main( | 174 | code = cmd.Main( |
| 563 | 169 | &ValidateImageMetadataCommand{}, ctx, []string{ | 175 | &ValidateImageMetadataCommand{}, ctx, []string{ |
| 564 | 170 | "-p", "ec2", "-s", "precise", "-r", "region", | 176 | "-p", "ec2", "-s", "precise", "-r", "region", |
| 566 | 171 | "-u", "https://ec2.region.amazonaws.com", "-d", metadataDir}, | 177 | "-u", "https://ec2.region.amazonaws.com", "-d", s.metadataDir}, |
| 567 | 172 | ) | 178 | ) |
| 568 | 173 | c.Assert(code, gc.Equals, 1) | 179 | c.Assert(code, gc.Equals, 1) |
| 569 | 174 | } | 180 | } |
| 570 | @@ -176,11 +182,10 @@ | |||
| 571 | 176 | func (s *ValidateImageMetadataSuite) TestOpenstackLocalMetadataWithManualParams(c *gc.C) { | 182 | func (s *ValidateImageMetadataSuite) TestOpenstackLocalMetadataWithManualParams(c *gc.C) { |
| 572 | 177 | s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url") | 183 | s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url") |
| 573 | 178 | ctx := coretesting.Context(c) | 184 | ctx := coretesting.Context(c) |
| 574 | 179 | metadataDir := config.JujuHomePath("") | ||
| 575 | 180 | code := cmd.Main( | 185 | code := cmd.Main( |
| 576 | 181 | &ValidateImageMetadataCommand{}, ctx, []string{ | 186 | &ValidateImageMetadataCommand{}, ctx, []string{ |
| 577 | 182 | "-p", "openstack", "-s", "raring", "-r", "region-2", | 187 | "-p", "openstack", "-s", "raring", "-r", "region-2", |
| 579 | 183 | "-u", "some-auth-url", "-d", metadataDir}, | 188 | "-u", "some-auth-url", "-d", s.metadataDir}, |
| 580 | 184 | ) | 189 | ) |
| 581 | 185 | c.Assert(code, gc.Equals, 0) | 190 | c.Assert(code, gc.Equals, 0) |
| 582 | 186 | errOut := ctx.Stdout.(*bytes.Buffer).String() | 191 | errOut := ctx.Stdout.(*bytes.Buffer).String() |
| 583 | @@ -191,17 +196,16 @@ | |||
| 584 | 191 | func (s *ValidateImageMetadataSuite) TestOpenstackLocalMetadataNoMatch(c *gc.C) { | 196 | func (s *ValidateImageMetadataSuite) TestOpenstackLocalMetadataNoMatch(c *gc.C) { |
| 585 | 192 | s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url") | 197 | s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url") |
| 586 | 193 | ctx := coretesting.Context(c) | 198 | ctx := coretesting.Context(c) |
| 587 | 194 | metadataDir := config.JujuHomePath("") | ||
| 588 | 195 | code := cmd.Main( | 199 | code := cmd.Main( |
| 589 | 196 | &ValidateImageMetadataCommand{}, ctx, []string{ | 200 | &ValidateImageMetadataCommand{}, ctx, []string{ |
| 590 | 197 | "-p", "openstack", "-s", "precise", "-r", "region-2", | 201 | "-p", "openstack", "-s", "precise", "-r", "region-2", |
| 592 | 198 | "-u", "some-auth-url", "-d", metadataDir}, | 202 | "-u", "some-auth-url", "-d", s.metadataDir}, |
| 593 | 199 | ) | 203 | ) |
| 594 | 200 | c.Assert(code, gc.Equals, 1) | 204 | c.Assert(code, gc.Equals, 1) |
| 595 | 201 | code = cmd.Main( | 205 | code = cmd.Main( |
| 596 | 202 | &ValidateImageMetadataCommand{}, ctx, []string{ | 206 | &ValidateImageMetadataCommand{}, ctx, []string{ |
| 597 | 203 | "-p", "openstack", "-s", "raring", "-r", "region-3", | 207 | "-p", "openstack", "-s", "raring", "-r", "region-3", |
| 599 | 204 | "-u", "some-auth-url", "-d", metadataDir}, | 208 | "-u", "some-auth-url", "-d", s.metadataDir}, |
| 600 | 205 | ) | 209 | ) |
| 601 | 206 | c.Assert(code, gc.Equals, 1) | 210 | c.Assert(code, gc.Equals, 1) |
| 602 | 207 | } | 211 | } |
| 603 | 208 | 212 | ||
| 604 | === renamed file 'environs/imagemetadata/boilerplate.go' => 'environs/imagemetadata/generate.go' | |||
| 605 | --- environs/imagemetadata/boilerplate.go 2013-08-07 04:34:02 +0000 | |||
| 606 | +++ environs/imagemetadata/generate.go 2013-10-16 02:57:31 +0000 | |||
| 607 | @@ -12,38 +12,25 @@ | |||
| 608 | 12 | "text/template" | 12 | "text/template" |
| 609 | 13 | "time" | 13 | "time" |
| 610 | 14 | 14 | ||
| 611 | 15 | "launchpad.net/juju-core/environs/config" | ||
| 612 | 16 | "launchpad.net/juju-core/environs/simplestreams" | 15 | "launchpad.net/juju-core/environs/simplestreams" |
| 613 | 17 | ) | 16 | ) |
| 614 | 18 | 17 | ||
| 615 | 19 | const ( | 18 | const ( |
| 616 | 20 | defaultIndexFileName = "index.json" | 19 | defaultIndexFileName = "index.json" |
| 617 | 21 | defaultImageFileName = "imagemetadata.json" | 20 | defaultImageFileName = "imagemetadata.json" |
| 618 | 22 | streamsDir = "streams/v1" | ||
| 619 | 23 | ) | 21 | ) |
| 620 | 24 | 22 | ||
| 630 | 25 | // Boilerplate generates some basic simplestreams metadata using the specified cloud and image details. | 23 | // GenerateMetadata generates some basic simplestreams metadata using the specified cloud and image details. |
| 631 | 26 | // If name is non-empty, it will be used as a prefix for the names of the generated index and image files. | 24 | func GenerateMetadata(series string, im *ImageMetadata, cloudSpec *simplestreams.CloudSpec, dest string) ([]string, error) { |
| 623 | 27 | func Boilerplate(name, series string, im *ImageMetadata, cloudSpec *simplestreams.CloudSpec) ([]string, error) { | ||
| 624 | 28 | return MakeBoilerplate(name, series, im, cloudSpec, true) | ||
| 625 | 29 | } | ||
| 626 | 30 | |||
| 627 | 31 | // MakeBoilerplate exists so it can be called by tests. See Boilerplate above. It provides an option to retain | ||
| 628 | 32 | // the streams directories when writing the generated metadata files. | ||
| 629 | 33 | func MakeBoilerplate(name, series string, im *ImageMetadata, cloudSpec *simplestreams.CloudSpec, flattenPath bool) ([]string, error) { | ||
| 632 | 34 | indexFileName := defaultIndexFileName | 25 | indexFileName := defaultIndexFileName |
| 633 | 35 | imageFileName := defaultImageFileName | 26 | imageFileName := defaultImageFileName |
| 634 | 36 | if name != "" { | ||
| 635 | 37 | indexFileName = fmt.Sprintf("%s-%s", name, indexFileName) | ||
| 636 | 38 | imageFileName = fmt.Sprintf("%s-%s", name, imageFileName) | ||
| 637 | 39 | } | ||
| 638 | 40 | now := time.Now() | 27 | now := time.Now() |
| 639 | 41 | imparams := imageMetadataParams{ | 28 | imparams := imageMetadataParams{ |
| 640 | 42 | Id: im.Id, | 29 | Id: im.Id, |
| 641 | 43 | Arch: im.Arch, | 30 | Arch: im.Arch, |
| 642 | 44 | Region: cloudSpec.Region, | 31 | Region: cloudSpec.Region, |
| 643 | 45 | URL: cloudSpec.Endpoint, | 32 | URL: cloudSpec.Endpoint, |
| 645 | 46 | Path: streamsDir, | 33 | Path: "streams/v1", |
| 646 | 47 | ImageFileName: imageFileName, | 34 | ImageFileName: imageFileName, |
| 647 | 48 | Updated: now.Format(time.RFC1123Z), | 35 | Updated: now.Format(time.RFC1123Z), |
| 648 | 49 | VersionKey: now.Format("20060102"), | 36 | VersionKey: now.Format("20060102"), |
| 649 | @@ -55,14 +42,12 @@ | |||
| 650 | 55 | return nil, fmt.Errorf("invalid series %q", series) | 42 | return nil, fmt.Errorf("invalid series %q", series) |
| 651 | 56 | } | 43 | } |
| 652 | 57 | 44 | ||
| 660 | 58 | if !flattenPath { | 45 | streamsPath := filepath.Join(dest, "streams", "v1") |
| 661 | 59 | streamsPath := config.JujuHomePath(streamsDir) | 46 | if err = os.MkdirAll(streamsPath, 0755); err != nil { |
| 662 | 60 | if err = os.MkdirAll(streamsPath, 0755); err != nil { | 47 | return nil, err |
| 656 | 61 | return nil, err | ||
| 657 | 62 | } | ||
| 658 | 63 | indexFileName = filepath.Join(streamsDir, indexFileName) | ||
| 659 | 64 | imageFileName = filepath.Join(streamsDir, imageFileName) | ||
| 663 | 65 | } | 48 | } |
| 664 | 49 | indexFileName = filepath.Join(streamsPath, indexFileName) | ||
| 665 | 50 | imageFileName = filepath.Join(streamsPath, imageFileName) | ||
| 666 | 66 | err = writeJsonFile(imparams, indexFileName, indexBoilerplate) | 51 | err = writeJsonFile(imparams, indexFileName, indexBoilerplate) |
| 667 | 67 | if err != nil { | 52 | if err != nil { |
| 668 | 68 | return nil, err | 53 | return nil, err |
| 669 | @@ -94,8 +79,7 @@ | |||
| 670 | 94 | panic(fmt.Errorf("cannot generate %s metdata: %v", filename, err)) | 79 | panic(fmt.Errorf("cannot generate %s metdata: %v", filename, err)) |
| 671 | 95 | } | 80 | } |
| 672 | 96 | data := metadata.Bytes() | 81 | data := metadata.Bytes() |
| 675 | 97 | path := config.JujuHomePath(filename) | 82 | if err := ioutil.WriteFile(filename, data, 0666); err != nil { |
| 674 | 98 | if err := ioutil.WriteFile(path, data, 0666); err != nil { | ||
| 676 | 99 | return err | 83 | return err |
| 677 | 100 | } | 84 | } |
| 678 | 101 | return nil | 85 | return nil |
| 679 | 102 | 86 | ||
| 680 | === modified file 'environs/imagemetadata/validation_test.go' | |||
| 681 | --- environs/imagemetadata/validation_test.go 2013-09-24 08:01:52 +0000 | |||
| 682 | +++ environs/imagemetadata/validation_test.go 2013-10-16 02:57:31 +0000 | |||
| 683 | @@ -6,16 +6,14 @@ | |||
| 684 | 6 | import ( | 6 | import ( |
| 685 | 7 | gc "launchpad.net/gocheck" | 7 | gc "launchpad.net/gocheck" |
| 686 | 8 | 8 | ||
| 687 | 9 | "launchpad.net/juju-core/environs/config" | ||
| 688 | 10 | "launchpad.net/juju-core/environs/imagemetadata" | 9 | "launchpad.net/juju-core/environs/imagemetadata" |
| 689 | 11 | "launchpad.net/juju-core/environs/simplestreams" | 10 | "launchpad.net/juju-core/environs/simplestreams" |
| 690 | 12 | coretesting "launchpad.net/juju-core/testing" | ||
| 691 | 13 | "launchpad.net/juju-core/testing/testbase" | 11 | "launchpad.net/juju-core/testing/testbase" |
| 692 | 14 | ) | 12 | ) |
| 693 | 15 | 13 | ||
| 694 | 16 | type ValidateSuite struct { | 14 | type ValidateSuite struct { |
| 695 | 17 | testbase.LoggingSuite | 15 | testbase.LoggingSuite |
| 697 | 18 | home *coretesting.FakeHome | 16 | metadataDir string |
| 698 | 19 | } | 17 | } |
| 699 | 20 | 18 | ||
| 700 | 21 | var _ = gc.Suite(&ValidateSuite{}) | 19 | var _ = gc.Suite(&ValidateSuite{}) |
| 701 | @@ -29,7 +27,7 @@ | |||
| 702 | 29 | Region: region, | 27 | Region: region, |
| 703 | 30 | Endpoint: endpoint, | 28 | Endpoint: endpoint, |
| 704 | 31 | } | 29 | } |
| 706 | 32 | _, err := imagemetadata.MakeBoilerplate("", series, &im, &cloudSpec, false) | 30 | _, err := imagemetadata.GenerateMetadata(series, &im, &cloudSpec, s.metadataDir) |
| 707 | 33 | if err != nil { | 31 | if err != nil { |
| 708 | 34 | return err | 32 | return err |
| 709 | 35 | } | 33 | } |
| 710 | @@ -38,23 +36,17 @@ | |||
| 711 | 38 | 36 | ||
| 712 | 39 | func (s *ValidateSuite) SetUpTest(c *gc.C) { | 37 | func (s *ValidateSuite) SetUpTest(c *gc.C) { |
| 713 | 40 | s.LoggingSuite.SetUpTest(c) | 38 | s.LoggingSuite.SetUpTest(c) |
| 720 | 41 | s.home = coretesting.MakeEmptyFakeHome(c) | 39 | s.metadataDir = c.MkDir() |
| 715 | 42 | } | ||
| 716 | 43 | |||
| 717 | 44 | func (s *ValidateSuite) TearDownTest(c *gc.C) { | ||
| 718 | 45 | s.home.Restore() | ||
| 719 | 46 | s.LoggingSuite.TearDownTest(c) | ||
| 721 | 47 | } | 40 | } |
| 722 | 48 | 41 | ||
| 723 | 49 | func (s *ValidateSuite) TestMatch(c *gc.C) { | 42 | func (s *ValidateSuite) TestMatch(c *gc.C) { |
| 724 | 50 | s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url") | 43 | s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url") |
| 725 | 51 | metadataDir := config.JujuHomePath("") | ||
| 726 | 52 | params := &simplestreams.MetadataLookupParams{ | 44 | params := &simplestreams.MetadataLookupParams{ |
| 727 | 53 | Region: "region-2", | 45 | Region: "region-2", |
| 728 | 54 | Series: "raring", | 46 | Series: "raring", |
| 729 | 55 | Architectures: []string{"amd64"}, | 47 | Architectures: []string{"amd64"}, |
| 730 | 56 | Endpoint: "some-auth-url", | 48 | Endpoint: "some-auth-url", |
| 732 | 57 | Sources: []simplestreams.DataSource{simplestreams.NewURLDataSource("file://"+metadataDir, simplestreams.VerifySSLHostnames)}, | 49 | Sources: []simplestreams.DataSource{simplestreams.NewURLDataSource("file://"+s.metadataDir, simplestreams.VerifySSLHostnames)}, |
| 733 | 58 | } | 50 | } |
| 734 | 59 | imageIds, err := imagemetadata.ValidateImageMetadata(params) | 51 | imageIds, err := imagemetadata.ValidateImageMetadata(params) |
| 735 | 60 | c.Assert(err, gc.IsNil) | 52 | c.Assert(err, gc.IsNil) |
| 736 | @@ -63,13 +55,12 @@ | |||
| 737 | 63 | 55 | ||
| 738 | 64 | func (s *ValidateSuite) TestNoMatch(c *gc.C) { | 56 | func (s *ValidateSuite) TestNoMatch(c *gc.C) { |
| 739 | 65 | s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url") | 57 | s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url") |
| 740 | 66 | metadataDir := config.JujuHomePath("") | ||
| 741 | 67 | params := &simplestreams.MetadataLookupParams{ | 58 | params := &simplestreams.MetadataLookupParams{ |
| 742 | 68 | Region: "region-2", | 59 | Region: "region-2", |
| 743 | 69 | Series: "precise", | 60 | Series: "precise", |
| 744 | 70 | Architectures: []string{"amd64"}, | 61 | Architectures: []string{"amd64"}, |
| 745 | 71 | Endpoint: "some-auth-url", | 62 | Endpoint: "some-auth-url", |
| 747 | 72 | Sources: []simplestreams.DataSource{simplestreams.NewURLDataSource("file://"+metadataDir, simplestreams.VerifySSLHostnames)}, | 63 | Sources: []simplestreams.DataSource{simplestreams.NewURLDataSource("file://"+s.metadataDir, simplestreams.VerifySSLHostnames)}, |
| 748 | 73 | } | 64 | } |
| 749 | 74 | _, err := imagemetadata.ValidateImageMetadata(params) | 65 | _, err := imagemetadata.ValidateImageMetadata(params) |
| 750 | 75 | c.Assert(err, gc.Not(gc.IsNil)) | 66 | c.Assert(err, gc.Not(gc.IsNil)) |
Reviewers: mp+190517_
Message:
Please take a look.
Description:
Improve the image metadata generation command
juju metadata generate-image was originally written
as a developer tool to aid simplestreams development.
It now is useful for setting up private clouds so has
been given a facelift to make it more user friendly.
The key feature is it will now use the current environment
to pick up most of what it needs, and the user just has to
supply the image id and architecture (if something different
to amd64 is required).
https:/
(do not edit description out of merge proposal)
Please review this at https:/
Affected files (+202, -133 lines):
A [revision details]
M cmd/plugins/
M cmd/plugins/
M cmd/plugins/
M environs/