func (*suite) TestParseMajorMinor(c *gc.C) {
parseMajorMinorTests := []struct {
v string
err string
expectMajor int
expectMinor int
}{{
v: "1.2",
expectMajor: 1,
expectMinor: 2,
}, {
v: "1",
expectMajor: 1,
expectMinor: -1,
}, {
v: "1.2.3",
err: "invalid major.minor version number 1.2.3",
}, {
v: "blah",
err: `invalid major version number blah: strconv.ParseInt: parsing "blah": invalid syntax`,
}}
for i, test := range parseMajorMinorTests {
c.Logf("test %d", i)
major, minor, err := version.ParseMajorMinor(test.v)
if test.err != "" {
c.Check(err, gc.ErrorMatches, test.err)
} else {
c.Check(err, jc.ErrorIsNil)
c.Check(major, gc.Equals, test.expectMajor)
c.Check(minor, gc.Equals, test.expectMinor)
}
}
}
func (c *syncToolsCommand) Init(args []string) error {
if c.destination != "" {
// Override localDir with destination as localDir now replaces destination
c.localDir = c.destination
logger.Warningf("Use of the --destination flag is deprecated in 1.18. Please use --local-dir instead.")
}
if c.versionStr != "" {
var err error
if c.majorVersion, c.minorVersion, err = version.ParseMajorMinor(c.versionStr); err != nil {
return err
}
}
if c.dev {
c.stream = envtools.TestingStream
}
return cmd.CheckEmpty(args)
}
func identityClientVersion(authURL string) (int, error) {
url, err := url.Parse(authURL)
if err != nil {
return -1, err
} else if url.Path == "" {
return -1, err
}
// The last part of the path should be the version #.
// Example: https://keystone.foo:443/v3/
logger.Debugf("authURL: %s", authURL)
versionNumStr := url.Path[2:]
if versionNumStr[len(versionNumStr)-1] == '/' {
versionNumStr = versionNumStr[:len(versionNumStr)-1]
}
major, _, err := version.ParseMajorMinor(versionNumStr)
return major, err
}
func (c *validateToolsMetadataCommand) Init(args []string) error {
if c.providerType != "" {
if c.region == "" {
return fmt.Errorf("region required if provider type is specified")
}
if c.metadataDir == "" {
return fmt.Errorf("metadata directory required if provider type is specified")
}
}
if c.exactVersion == "current" {
c.exactVersion = jujuversion.Current.String()
}
if c.partVersion != "" {
var err error
if c.major, c.minor, err = version.ParseMajorMinor(c.partVersion); err != nil {
return err
}
}
return cmd.CheckEmpty(args)
}
// NewController creates an authenticated client to the MAAS API, and checks
// the capabilities of the server.
//
// If the APIKey is not valid, a NotValid error is returned.
// If the credentials are incorrect, a PermissionError is returned.
func NewController(args ControllerArgs) (Controller, error) {
// For now we don't need to test multiple versions. It is expected that at
// some time in the future, we will try the most up to date version and then
// work our way backwards.
for _, apiVersion := range supportedAPIVersions {
major, minor, err := version.ParseMajorMinor(apiVersion)
// We should not get an error here. See the test.
if err != nil {
return nil, errors.Errorf("bad version defined in supported versions: %q", apiVersion)
}
client, err := NewAuthenticatedClient(args.BaseURL, args.APIKey, apiVersion)
if err != nil {
// If the credentials aren't valid, return now.
if errors.IsNotValid(err) {
return nil, errors.Trace(err)
}
// Any other error attempting to create the authenticated client
// is an unexpected error and return now.
return nil, NewUnexpectedError(err)
}
controllerVersion := version.Number{
Major: major,
Minor: minor,
}
controller := &controller{client: client}
// The controllerVersion returned from the function will include any patch version.
controller.capabilities, controller.apiVersion, err = controller.readAPIVersion(controllerVersion)
if err != nil {
logger.Debugf("read version failed: %#v", err)
continue
}
if err := controller.checkCreds(); err != nil {
return nil, errors.Trace(err)
}
return controller, nil
}
return nil, NewUnsupportedVersionError("controller at %s does not support any of %s", args.BaseURL, supportedAPIVersions)
}
func (*versionSuite) TestSupportedVersions(c *gc.C) {
for _, apiVersion := range supportedAPIVersions {
_, _, err := version.ParseMajorMinor(apiVersion)
c.Check(err, jc.ErrorIsNil)
}
}
