Merge lp:~axwalk/goose/nova-availability-zones into lp:goose

[Andrew Wilkins]

Add support for Availability Zones

- Added ListAvailabilityZones to Nova client
- Added AvailabilityZone field to RunServerOpts
- Added AvailabilityZone field to ServerDetail
- Updated nova test-service to support all of the above

Availability zones are an OpenStack extension,
so I've made it so that ListAvailabilityZones will
ignore any 404 to the os-availability-zone URL.

https://codereview.appspot.com/103900045/

R=gz

Add support for Availability Zones

- Added ListAvailabilityZones to Nova client
- Added AvailabilityZone field to RunServerOpts
- Added AvailabilityZone field to ServerDetail
- Updated nova test-service to support all of the above

Availability zones are an OpenStack extension,
so I've made it so that ListAvailabilityZones will
ignore any 404 to the os-availability-zone URL.

https://codereview.appspot.com/103900045/

[Andrew Wilkins (axwalk)]

Reviewers: mp+222275_code.launchpad.net,

Message:
Please take a look.

Description:
Add support for Availability Zones

- Added ListAvailabilityZones to Nova client
- Added AvailabilityZone field to RunServerOpts
- Added AvailabilityZone field to ServerDetail
- Updated nova test-service to support all of the above

Availability zones are an OpenStack extension,
so I've made it so that ListAvailabilityZones will
ignore any 404 to the os-availability-zone URL.

https://code.launchpad.net/~axwalk/goose/nova-availability-zones/+merge/222275

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/103900045/

Affected files (+260, -64 lines):
   A [revision details]
   M nova/live_test.go
   M nova/local_test.go
   M nova/nova.go
   M testservices/novaservice/service.go
   M testservices/novaservice/service_http.go
   M testservices/novaservice/service_http_test.go

[Dave Cheney (dave-cheney)]

https://codereview.appspot.com/103900045/diff/1/nova/local_test.go
File nova/local_test.go (right):

https://codereview.appspot.com/103900045/diff/1/nova/local_test.go#newcode251
nova/local_test.go:251: c.Assert(err, IsNil)
Are these zones guaranteed to be returned in order? Should this be
jc.SameContents

https://codereview.appspot.com/103900045/diff/1/testservices/novaservice/service.go
File testservices/novaservice/service.go (right):

https://codereview.appspot.com/103900045/diff/1/testservices/novaservice/service.go#newcode826
testservices/novaservice/service.go:826: sort.Sort(azByName(zones))
Please document the order of az's is stored.

https://codereview.appspot.com/103900045/diff/1/testservices/novaservice/service_http_test.go
File testservices/novaservice/service_http_test.go (right):

https://codereview.appspot.com/103900045/diff/1/testservices/novaservice/service_http_test.go#newcode1196
testservices/novaservice/service_http_test.go:1196:
c.Assert(expected.Zones, DeepEquals, zones)
jc.SameContents

https://codereview.appspot.com/103900045/

[lp:~axwalk/goose/nova-availability-zones]

126. By Andrew Wilkins on 2014-06-06

Add comment on ordering of zones

[Andrew Wilkins (axwalk)]

Please take a look.

https://codereview.appspot.com/103900045/diff/1/nova/local_test.go
File nova/local_test.go (right):

https://codereview.appspot.com/103900045/diff/1/nova/local_test.go#newcode251
nova/local_test.go:251: c.Assert(err, IsNil)
On 2014/06/06 04:33:17, dfc wrote:
> Are these zones guaranteed to be returned in order? Should this be
> jc.SameContents

Yes, they are sorted by the server.

https://codereview.appspot.com/103900045/diff/1/testservices/novaservice/service.go
File testservices/novaservice/service.go (right):

https://codereview.appspot.com/103900045/diff/1/testservices/novaservice/service.go#newcode826
testservices/novaservice/service.go:826: sort.Sort(azByName(zones))
On 2014/06/06 04:33:17, dfc wrote:
> Please document the order of az's is stored.

Added to the doc comment of this function. There's no user-facing place
to add a comment.

https://codereview.appspot.com/103900045/diff/1/testservices/novaservice/service_http_test.go
File testservices/novaservice/service_http_test.go (right):

https://codereview.appspot.com/103900045/diff/1/testservices/novaservice/service_http_test.go#newcode1196
testservices/novaservice/service_http_test.go:1196:
c.Assert(expected.Zones, DeepEquals, zones)
On 2014/06/06 04:33:17, dfc wrote:
> jc.SameContents

They are sorted by the server. No need to introduce a dependency on
juju/testing/checkers here.

https://codereview.appspot.com/103900045/

[Martin Packman (gz)]

Do any of our openstack clouds actually support this extension? Neither
canonistack nor HP seem to. I'm not totally up to dat on current plans,
but this seemed to be a dead end a year ago, with different mechanisms
talked about as fulfilling the role that weren't availabilty zone based.

https://codereview.appspot.com/103900045/

[Andrew Wilkins (axwalk)]

On 2014/06/07 14:54:10, gz wrote:
> Do any of our openstack clouds actually support this extension?
Neither
> canonistack nor HP seem to. I'm not totally up to dat on current
plans, but this
> seemed to be a dead end a year ago, with different mechanisms talked
about as
> fulfilling the role that weren't availabilty zone based.

HP's US West has 4 availability zones. I've tested this live.

https://codereview.appspot.com/103900045/

[Martin Packman (gz)]

Ah, interesting. I wasn't on their 12.12 deployment (which is being
retired Monday), so must have been added for the 13.5 one.

https://codereview.appspot.com/103900045/

[Martin Packman (gz)]

LGTM.

https://codereview.appspot.com/103900045/diff/20001/nova/local_test.go
File nova/local_test.go (right):

https://codereview.appspot.com/103900045/diff/20001/nova/local_test.go#newcode231
nova/local_test.go:231: s.openstack.Nova.SetAvailabilityZones()
This is pretty magical test server behaviour, but you have a nice big
comment at least.

https://codereview.appspot.com/103900045/diff/20001/nova/nova.go
File nova/nova.go (right):

https://codereview.appspot.com/103900045/diff/20001/nova/nova.go#newcode695
nova/nova.go:695: return nil, nil
I'd prefer we return a specific error that can be checked, but that's
not really a job for this proposal, we need better goose-wide handling
of extensions and errors.

https://codereview.appspot.com/103900045/diff/20001/testservices/novaservice/service_http.go
File testservices/novaservice/service_http.go (right):

https://codereview.appspot.com/103900045/diff/20001/testservices/novaservice/service_http.go#newcode228
testservices/novaservice/service_http.go:228:
errAvailabilityZoneIsNotAvailable = &errorResponse{
Rather than doing this the old way, you should use the new
testservices/errors.go method of creating the error.

https://codereview.appspot.com/103900045/

[lp:~axwalk/goose/nova-availability-zones]

127. By Andrew Wilkins on 2014-06-09

Address review comments

- Return an error if AZ extension is not supported
- Use new testservices/errors

[Andrew Wilkins (axwalk)]

Please take a look.

https://codereview.appspot.com/103900045/diff/20001/nova/nova.go
File nova/nova.go (right):

https://codereview.appspot.com/103900045/diff/20001/nova/nova.go#newcode695
nova/nova.go:695: return nil, nil
On 2014/06/07 17:13:03, gz wrote:
> I'd prefer we return a specific error that can be checked, but that's
not really
> a job for this proposal, we need better goose-wide handling of
extensions and
> errors.

I think you're right, and I'd prefer to get the API right to begin with.
The error type/method of checking may change later, but at least we
should start out with propagating the error.

I've created a error code in goose/errors for "not implemented".

https://codereview.appspot.com/103900045/diff/20001/testservices/novaservice/service_http.go
File testservices/novaservice/service_http.go (right):

https://codereview.appspot.com/103900045/diff/20001/testservices/novaservice/service_http.go#newcode228
testservices/novaservice/service_http.go:228:
errAvailabilityZoneIsNotAvailable = &errorResponse{
On 2014/06/07 17:13:03, gz wrote:
> Rather than doing this the old way, you should use the new
> testservices/errors.go method of creating the error.

Done.

https://codereview.appspot.com/103900045/

=== modified file 'errors/errors.go'
--- errors/errors.go	2013-04-11 06:31:23 +0000
+++ errors/errors.go	2014-06-09 01:36:50 +0000
@@ -15,6 +15,7 @@
 	DuplicateValueError = Code("DuplicateValue")
 	TimeoutError        = Code("Timeout")
 	UnauthorisedError   = Code("Unauthorised")
+	NotImplementedError = Code("NotImplemented")
 )
 
 // Error instances store an optional error cause.
@@ -95,7 +96,14 @@
 	return false
 }
 
-// New creates a new Error instance with the specified cause.
+func IsNotImplemented(err error) bool {
+	if e, ok := err.(*gooseError); ok {
+		return e.causedBy(NotImplementedError)
+	}
+	return false
+}
+
+// makeErrorf creates a new Error instance with the specified cause.
 func makeErrorf(code Code, cause error, format string, args ...interface{}) Error {
 	return &gooseError{
 		errcode: code,
@@ -104,12 +112,12 @@
 	}
 }
 
-// New creates a new Unspecified Error instance with the specified cause.
+// Newf creates a new Unspecified Error instance with the specified cause.
 func Newf(cause error, format string, args ...interface{}) Error {
 	return makeErrorf(UnspecifiedError, cause, format, args...)
 }
 
-// New creates a new NotFound Error instance with the specified cause.
+// NewNotFoundf creates a new NotFound Error instance with the specified cause.
 func NewNotFoundf(cause error, context interface{}, format string, args ...interface{}) Error {
 	if format == "" {
 		format = fmt.Sprintf("Not found: %s", context)
@@ -117,7 +125,7 @@
 	return makeErrorf(NotFoundError, cause, format, args...)
 }
 
-// New creates a new DuplicateValue Error instance with the specified cause.
+// NewDuplicateValuef creates a new DuplicateValue Error instance with the specified cause.
 func NewDuplicateValuef(cause error, context interface{}, format string, args ...interface{}) Error {
 	if format == "" {
 		format = fmt.Sprintf("Duplicate: %s", context)
@@ -125,7 +133,7 @@
 	return makeErrorf(DuplicateValueError, cause, format, args...)
 }
 
-// New creates a new Timeout Error instance with the specified cause.
+// NewTimeoutf creates a new Timeout Error instance with the specified cause.
 func NewTimeoutf(cause error, context interface{}, format string, args ...interface{}) Error {
 	if format == "" {
 		format = fmt.Sprintf("Timeout: %s", context)
@@ -133,10 +141,18 @@
 	return makeErrorf(TimeoutError, cause, format, args...)
 }
 
-// New creates a new Unauthorised Error instance with the specified cause.
+// NewUnauthorisedf creates a new Unauthorised Error instance with the specified cause.
 func NewUnauthorisedf(cause error, context interface{}, format string, args ...interface{}) Error {
 	if format == "" {
 		format = fmt.Sprintf("Unauthorised: %s", context)
 	}
 	return makeErrorf(UnauthorisedError, cause, format, args...)
 }
+
+// NewNotImplementedf creates a new NotImplemented Error instance with the specified cause.
+func NewNotImplementedf(cause error, context interface{}, format string, args ...interface{}) Error {
+	if format == "" {
+		format = fmt.Sprintf("Not implemented: %s", context)
+	}
+	return makeErrorf(NotImplementedError, cause, format, args...)
+}

=== modified file 'errors/errors_test.go'
--- errors/errors_test.go	2013-03-28 09:06:20 +0000
+++ errors/errors_test.go	2014-06-09 01:36:50 +0000
@@ -55,6 +55,20 @@
 	c.Assert(err.Error(), Equals, "It was unauthorised: context")
 }
 
+func (s *ErrorsSuite) TestCreateSimpleNotImplementedfError(c *C) {
+	context := "context"
+	err := errors.NewNotImplementedf(nil, context, "")
+	c.Assert(errors.IsNotImplemented(err), Equals, true)
+	c.Assert(err.Error(), Equals, "Not implemented: context")
+}
+
+func (s *ErrorsSuite) TestCreateNotImplementedfError(c *C) {
+	context := "context"
+	err := errors.NewNotImplementedf(nil, context, "It was not implemented: %s", context)
+	c.Assert(errors.IsNotImplemented(err), Equals, true)
+	c.Assert(err.Error(), Equals, "It was not implemented: context")
+}
+
 func (s *ErrorsSuite) TestErrorCause(c *C) {
 	rootCause := errors.NewNotFoundf(nil, "some value", "")
 	// Construct a new error, based on a not found root cause.

=== modified file 'nova/live_test.go'
--- nova/live_test.go	2014-01-16 14:53:18 +0000
+++ nova/live_test.go	2014-06-09 01:36:50 +0000
@@ -28,17 +28,18 @@
 }
 
 type LiveTests struct {
-	cred          *identity.Credentials
-	client        client.AuthenticatingClient
-	nova          *nova.Client
-	testServer    *nova.Entity
-	userId        string
-	tenantId      string
-	testImageId   string
-	testFlavor    string
-	testFlavorId  string
-	vendor        string
-	useNumericIds bool
+	cred                 *identity.Credentials
+	client               client.AuthenticatingClient
+	nova                 *nova.Client
+	testServer           *nova.Entity
+	userId               string
+	tenantId             string
+	testImageId          string
+	testFlavor           string
+	testFlavorId         string
+	testAvailabilityZone string
+	vendor               string
+	useNumericIds        bool
 }
 
 func (s *LiveTests) SetUpSuite(c *C) {
@@ -47,7 +48,7 @@
 	var err error
 	s.testFlavorId, err = s.findFlavorId(s.testFlavor)
 	c.Assert(err, IsNil)
-	s.testServer, err = s.createInstance(c, testImageName)
+	s.testServer, err = s.createInstance(testImageName)
 	c.Assert(err, IsNil)
 	s.waitTestServerToStart(c)
 	// These will not be filled in until a client has authorised which will happen creating the instance above.
@@ -88,12 +89,13 @@
 	// noop, called by local test suite.
 }
 
-func (s *LiveTests) createInstance(c *C, name string) (instance *nova.Entity, err error) {
+func (s *LiveTests) createInstance(name string) (instance *nova.Entity, err error) {
 	opts := nova.RunServerOpts{
-		Name:     name,
-		FlavorId: s.testFlavorId,
-		ImageId:  s.testImageId,
-		UserData: nil,
+		Name:             name,
+		FlavorId:         s.testFlavorId,
+		ImageId:          s.testImageId,
+		AvailabilityZone: s.testAvailabilityZone,
+		UserData:         nil,
 	}
 	instance, err = s.nova.RunServer(opts)
 	if err != nil {
@@ -108,6 +110,9 @@
 	c.Check(sr.Name, Equals, testImageName)
 	c.Check(sr.Flavor.Id, Equals, s.testFlavorId)
 	c.Check(sr.Image.Id, Equals, s.testImageId)
+	if s.testAvailabilityZone != "" {
+		c.Check(sr.AvailabilityZone, Equals, s.testAvailabilityZone)
+	}
 }
 
 func (s *LiveTests) TestListFlavors(c *C) {
@@ -163,7 +168,7 @@
 }
 
 func (s *LiveTests) TestListServersWithFilter(c *C) {
-	inst, err := s.createInstance(c, "filtered_server")
+	inst, err := s.createInstance("filtered_server")
 	c.Assert(err, IsNil)
 	defer s.nova.DeleteServer(inst.Id)
 	filter := nova.NewFilter()
@@ -224,7 +229,7 @@
 }
 
 func (s *LiveTests) TestListServersDetailWithFilter(c *C) {
-	inst, err := s.createInstance(c, "filtered_server")
+	inst, err := s.createInstance("filtered_server")
 	c.Assert(err, IsNil)
 	defer s.nova.DeleteServer(inst.Id)
 	filter := nova.NewFilter()
@@ -488,7 +493,7 @@
 		"123barbaz",
 	}
 	for _, name := range serverNames {
-		inst, err := s.createInstance(c, name)
+		inst, err := s.createInstance(name)
 		c.Assert(err, IsNil)
 		defer s.nova.DeleteServer(inst.Id)
 	}
@@ -518,3 +523,15 @@
 		c.Assert(network.Cidr, Matches, `\d{1,3}(\.+\d{1,3}){3}\/\d+`)
 	}
 }
+
+func (s *LiveTests) runServerAvailabilityZone(zone string) (*nova.Entity, error) {
+	old := s.testAvailabilityZone
+	defer func() { s.testAvailabilityZone = old }()
+	s.testAvailabilityZone = zone
+	return s.createInstance(testImageName)
+}
+
+func (s *LiveTests) TestRunServerUnknownAvailabilityZone(c *C) {
+	_, err := s.runServerAvailabilityZone("something_that_will_never_exist")
+	c.Assert(err, ErrorMatches, "(.|\n)*The requested availability zone is not available(.|\n)*")
+}

=== modified file 'nova/local_test.go'
--- nova/local_test.go	2013-11-25 05:52:30 +0000
+++ nova/local_test.go	2014-06-09 01:36:50 +0000
@@ -223,3 +223,48 @@
 	_, err := novaClient.ListServers(nil)
 	c.Assert(errors.IsUnauthorised(err), Equals, true)
 }
+
+func (s *localLiveSuite) TestListAvailabilityZonesUnimplemented(c *C) {
+	// When the test service has no availability zones registered,
+	// the /os-availability-zone API will return 404. We swallow
+	// that error.
+	s.openstack.Nova.SetAvailabilityZones()
+	listedZones, err := s.nova.ListAvailabilityZones()
+	c.Assert(err, ErrorMatches, "the server does not support availability zones(.|\n)*")
+	c.Assert(listedZones, HasLen, 0)
+}
+
+func (s *localLiveSuite) setAvailabilityZones() []nova.AvailabilityZone {
+	zones := []nova.AvailabilityZone{
+		nova.AvailabilityZone{Name: "az1"},
+		nova.AvailabilityZone{
+			Name: "az2", State: nova.AvailabilityZoneState{Available: true},
+		},
+	}
+	s.openstack.Nova.SetAvailabilityZones(zones...)
+	return zones
+}
+
+func (s *localLiveSuite) TestListAvailabilityZones(c *C) {
+	zones := s.setAvailabilityZones()
+	listedZones, err := s.nova.ListAvailabilityZones()
+	c.Assert(err, IsNil)
+	c.Assert(listedZones, DeepEquals, zones)
+}
+
+func (s *localLiveSuite) TestRunServerAvailabilityZone(c *C) {
+	s.setAvailabilityZones()
+	inst, err := s.runServerAvailabilityZone("az2")
+	c.Assert(err, IsNil)
+	defer s.nova.DeleteServer(inst.Id)
+	server, err := s.nova.GetServer(inst.Id)
+	c.Assert(err, IsNil)
+	c.Assert(server.AvailabilityZone, Equals, "az2")
+}
+
+func (s *localLiveSuite) TestRunServerAvailabilityZoneNotAvailable(c *C) {
+	s.setAvailabilityZones()
+	// az1 is known, but not currently available.
+	_, err := s.runServerAvailabilityZone("az1")
+	c.Assert(err, ErrorMatches, "(.|\n)*The requested availability zone is not available(.|\n)*")
+}

=== modified file 'nova/nova.go'
--- nova/nova.go	2014-01-24 16:33:31 +0000
+++ nova/nova.go	2014-06-09 01:36:50 +0000
@@ -22,6 +22,7 @@
 	apiSecurityGroups     = "os-security-groups"
 	apiSecurityGroupRules = "os-security-group-rules"
 	apiFloatingIPs        = "os-floating-ips"
+	apiAvailabilityZone   = "os-availability-zone"
 )
 
 // Server status values.
@@ -245,6 +246,8 @@
 	Updated string
 
 	UserId string `json:"user_id"`
+
+	AvailabilityZone string `json:"OS-EXT-AZ:availability_zone"`
 }
 
 // ListServersDetail lists all details for available servers.
@@ -307,12 +310,13 @@
 
 // RunServerOpts defines required and optional arguments for RunServer().
 type RunServerOpts struct {
-	Name               string              `json:"name"`            // Required
-	FlavorId           string              `json:"flavorRef"`       // Required
-	ImageId            string              `json:"imageRef"`        // Required
-	UserData           []byte              `json:"user_data"`       // Optional
-	SecurityGroupNames []SecurityGroupName `json:"security_groups"` // Optional
-	Networks           []ServerNetworks    `json:"networks"`        // Optional
+	Name               string              `json:"name"`                        // Required
+	FlavorId           string              `json:"flavorRef"`                   // Required
+	ImageId            string              `json:"imageRef"`                    // Required
+	UserData           []byte              `json:"user_data"`                   // Optional
+	SecurityGroupNames []SecurityGroupName `json:"security_groups"`             // Optional
+	Networks           []ServerNetworks    `json:"networks"`                    // Optional
+	AvailabilityZone   string              `json:"availability_zone,omitempty"` // Optional
 }
 
 // RunServer creates a new server, based on the given RunServerOpts.
@@ -666,3 +670,38 @@
 	}
 	return err
 }
+
+// AvailabilityZone identifies an availability zone, and describes its state.
+type AvailabilityZone struct {
+	Name  string                `json:"zoneName"`
+	State AvailabilityZoneState `json:"zoneState"`
+}
+
+// AvailabilityZoneState describes an availability zone's state.
+type AvailabilityZoneState struct {
+	Available bool
+}
+
+// ListAvailabilityZones lists all availability zones.
+//
+// Availability zones are an OpenStack extension; if the server does not
+// support them, then an error satisfying errors.IsNotImplemented will be
+// returned.
+func (c *Client) ListAvailabilityZones() ([]AvailabilityZone, error) {
+	var resp struct {
+		AvailabilityZoneInfo []AvailabilityZone
+	}
+	requestData := goosehttp.RequestData{RespValue: &resp}
+	err := c.client.SendRequest(client.GET, "compute", apiAvailabilityZone, &requestData)
+	if errors.IsNotFound(err) {
+		// Availability zones are an extension, so don't
+		// return an error if the API does not exist.
+		return nil, errors.NewNotImplementedf(
+			err, nil, "the server does not support availability zones",
+		)
+	}
+	if err != nil {
+		return nil, errors.Newf(err, "failed to get list of availability zones")
+	}
+	return resp.AvailabilityZoneInfo, nil
+}

=== modified file 'testservices/errors.go'
--- testservices/errors.go	2014-05-02 01:12:04 +0000
+++ testservices/errors.go	2014-06-09 01:36:50 +0000
@@ -68,6 +68,10 @@
 	return serverErrorf(413, "Retry limit exceeded")
 }
 
+func NewAvailabilityZoneIsNotAvailableError() *ServerError {
+	return serverErrorf(400, "The requested availability zone is not available")
+}
+
 func NewAddFlavorError(id string) *ServerError {
 	return serverErrorf(409, "A flavor with id %q already exists", id)
 }

=== modified file 'testservices/novaservice/service.go'
--- testservices/novaservice/service.go	2014-05-02 01:12:04 +0000
+++ testservices/novaservice/service.go	2014-06-09 01:36:50 +0000
@@ -9,6 +9,7 @@
 	"launchpad.net/goose/testservices/identityservice"
 	"net/url"
 	"regexp"
+	"sort"
 	"strings"
 )
 
@@ -19,18 +20,19 @@
 // contains the service double's internal state.
 type Nova struct {
 	testservices.ServiceInstance
-	flavors      map[string]nova.FlavorDetail
-	servers      map[string]nova.ServerDetail
-	groups       map[string]nova.SecurityGroup
-	rules        map[string]nova.SecurityGroupRule
-	floatingIPs  map[string]nova.FloatingIP
-	networks     map[string]nova.Network
-	serverGroups map[string][]string
-	serverIPs    map[string][]string
-	nextServerId int
-	nextGroupId  int
-	nextRuleId   int
-	nextIPId     int
+	flavors           map[string]nova.FlavorDetail
+	servers           map[string]nova.ServerDetail
+	groups            map[string]nova.SecurityGroup
+	rules             map[string]nova.SecurityGroupRule
+	floatingIPs       map[string]nova.FloatingIP
+	networks          map[string]nova.Network
+	serverGroups      map[string][]string
+	serverIPs         map[string][]string
+	availabilityZones map[string]nova.AvailabilityZone
+	nextServerId      int
+	nextGroupId       int
+	nextRuleId        int
+	nextIPId          int
 }
 
 func errorJSONEncode(err error) (int, string) {
@@ -86,14 +88,15 @@
 		{Id: "999", Name: "default", Description: "default group"},
 	}
 	novaService := &Nova{
-		flavors:      make(map[string]nova.FlavorDetail),
-		servers:      make(map[string]nova.ServerDetail),
-		groups:       make(map[string]nova.SecurityGroup),
-		rules:        make(map[string]nova.SecurityGroupRule),
-		floatingIPs:  make(map[string]nova.FloatingIP),
-		networks:     make(map[string]nova.Network),
-		serverGroups: make(map[string][]string),
-		serverIPs:    make(map[string][]string),
+		flavors:           make(map[string]nova.FlavorDetail),
+		servers:           make(map[string]nova.ServerDetail),
+		groups:            make(map[string]nova.SecurityGroup),
+		rules:             make(map[string]nova.SecurityGroupRule),
+		floatingIPs:       make(map[string]nova.FloatingIP),
+		networks:          make(map[string]nova.Network),
+		serverGroups:      make(map[string][]string),
+		serverIPs:         make(map[string][]string),
+		availabilityZones: make(map[string]nova.AvailabilityZone),
 		ServiceInstance: testservices.ServiceInstance{
 			IdentityService: identityService,
 			Scheme:          URL.Scheme,
@@ -130,6 +133,21 @@
 	return novaService
 }
 
+// SetAvailabilityZones sets the availability zones for setting
+// availability zones.
+//
+// Note: this is implemented as a public method rather than as
+// an HTTP API for two reasons: availability zones are created
+// indirectly via "host aggregates", which are a cloud-provider
+// concept that we have not implemented, and because we want to
+// be able to synthesize zone state changes.
+func (n *Nova) SetAvailabilityZones(zones ...nova.AvailabilityZone) {
+	n.availabilityZones = make(map[string]nova.AvailabilityZone)
+	for _, z := range zones {
+		n.availabilityZones[z.Name] = z
+	}
+}
+
 // buildFlavorLinks populates the Links field of the passed
 // FlavorDetail as needed by OpenStack HTTP API. Call this
 // before addFlavor().
@@ -799,3 +817,27 @@
 	}
 	return networks
 }
+
+// allAvailabilityZones returns a list of all existing availability zones,
+// sorted by name.
+func (n *Nova) allAvailabilityZones() (zones []nova.AvailabilityZone) {
+	for _, zone := range n.availabilityZones {
+		zones = append(zones, zone)
+	}
+	sort.Sort(azByName(zones))
+	return zones
+}
+
+type azByName []nova.AvailabilityZone
+
+func (a azByName) Len() int {
+	return len(a)
+}
+
+func (a azByName) Less(i, j int) bool {
+	return a[i].Name < a[j].Name
+}
+
+func (a azByName) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}

=== modified file 'testservices/novaservice/service_http.go'
--- testservices/novaservice/service_http.go	2014-05-16 06:14:14 +0000
+++ testservices/novaservice/service_http.go	2014-06-09 01:36:50 +0000
@@ -536,12 +536,13 @@
 func (n *Nova) handleRunServer(body []byte, w http.ResponseWriter, r *http.Request) error {
 	var req struct {
 		Server struct {
-			FlavorRef      string
-			ImageRef       string
-			Name           string
-			Metadata       map[string]string
-			SecurityGroups []map[string]string `json:"security_groups"`
-			Networks       []map[string]string
+			FlavorRef        string
+			ImageRef         string
+			Name             string
+			Metadata         map[string]string
+			SecurityGroups   []map[string]string `json:"security_groups"`
+			Networks         []map[string]string
+			AvailabilityZone string `json:"availability_zone"`
 		}
 	}
 	if err := json.Unmarshal(body, &req); err != nil {
@@ -556,6 +557,11 @@
 	if req.Server.FlavorRef == "" {
 		return errBadRequestSrvFlavor
 	}
+	if az := req.Server.AvailabilityZone; az != "" {
+		if !n.availabilityZones[az].State.Available {
+			return testservices.AvailabilityZoneIsNotAvailable
+		}
+	}
 	n.nextServerId++
 	id := strconv.Itoa(n.nextServerId)
 	uuid, err := newUUID()
@@ -590,18 +596,19 @@
 	timestr := time.Now().Format(time.RFC3339)
 	userInfo, _ := userInfo(n.IdentityService, r)
 	server := nova.ServerDetail{
-		Id:        id,
-		UUID:      uuid,
-		Name:      req.Server.Name,
-		TenantId:  n.TenantId,
-		UserId:    userInfo.Id,
-		HostId:    "1",
-		Image:     image,
-		Flavor:    flavorEnt,
-		Status:    nova.StatusActive,
-		Created:   timestr,
-		Updated:   timestr,
-		Addresses: make(map[string][]nova.IPAddress),
+		Id:               id,
+		UUID:             uuid,
+		Name:             req.Server.Name,
+		TenantId:         n.TenantId,
+		UserId:           userInfo.Id,
+		HostId:           "1",
+		Image:            image,
+		Flavor:           flavorEnt,
+		Status:           nova.StatusActive,
+		Created:          timestr,
+		Updated:          timestr,
+		Addresses:        make(map[string][]nova.IPAddress),
+		AvailabilityZone: req.Server.AvailabilityZone,
 	}
 	nextServer := len(n.allServers(nil)) + 1
 	n.buildServerLinks(&server)
@@ -1019,6 +1026,27 @@
 	return fmt.Errorf("unknown request method %q for %s", r.Method, r.URL.Path)
 }
 
+// handleAvailabilityZones handles the os-availability-zone HTTP API.
+func (n *Nova) handleAvailabilityZones(w http.ResponseWriter, r *http.Request) error {
+	switch r.Method {
+	case "GET":
+		if ipId := path.Base(r.URL.Path); ipId != "os-availability-zone" {
+			return errNotFoundJSON
+		}
+		zones := n.allAvailabilityZones()
+		if len(zones) == 0 {
+			// If there are no availability zones defined, act as
+			// if we don't support the availability zones extension.
+			return errNotFoundJSON
+		}
+		resp := struct {
+			Zones []nova.AvailabilityZone `json:"availabilityZoneInfo"`
+		}{zones}
+		return sendJSON(http.StatusOK, resp, w, r)
+	}
+	return fmt.Errorf("unknown request method %q for %s", r.Method, r.URL.Path)
+}
+
 // setupHTTP attaches all the needed handlers to provide the HTTP API.
 func (n *Nova) SetupHTTP(mux *http.ServeMux) {
 	handlers := map[string]http.Handler{
@@ -1033,6 +1061,7 @@
 		"/$v/$t/os-security-group-rules": n.handler((*Nova).handleSecurityGroupRules),
 		"/$v/$t/os-floating-ips":         n.handler((*Nova).handleFloatingIPs),
 		"/$v/$t/os-networks":             n.handler((*Nova).handleNetworks),
+		"/$v/$t/os-availability-zone":    n.handler((*Nova).handleAvailabilityZones),
 	}
 	for path, h := range handlers {
 		path = strings.Replace(path, "$v", n.VersionPath, 1)

=== modified file 'testservices/novaservice/service_http_test.go'
--- testservices/novaservice/service_http_test.go	2014-05-02 01:12:04 +0000
+++ testservices/novaservice/service_http_test.go	2014-06-09 01:36:50 +0000
@@ -1175,6 +1175,27 @@
 	c.Assert(s.service.hasServerFloatingIP(server.Id, fip.IP), Equals, false)
 }
 
+func (s *NovaHTTPSuite) TestListAvailabilityZones(c *C) {
+	resp, err := s.jsonRequest("GET", "/os-availability-zone", nil, nil)
+	c.Assert(err, IsNil)
+	assertBody(c, resp, errNotFoundJSON)
+
+	zones := []nova.AvailabilityZone{
+		nova.AvailabilityZone{Name: "az1"},
+		nova.AvailabilityZone{
+			Name: "az2", State: nova.AvailabilityZoneState{Available: true},
+		},
+	}
+	s.service.SetAvailabilityZones(zones...)
+	resp, err = s.jsonRequest("GET", "/os-availability-zone", nil, nil)
+	c.Assert(err, IsNil)
+	var expected struct {
+		Zones []nova.AvailabilityZone `json:"availabilityZoneInfo"`
+	}
+	assertJSON(c, resp, &expected)
+	c.Assert(expected.Zones, DeepEquals, zones)
+}
+
 func (s *NovaHTTPSSuite) SetUpSuite(c *C) {
 	s.HTTPSuite.SetUpSuite(c)
 	identityDouble := identityservice.NewUserPass()

=== modified file 'testservices/service.go'
--- testservices/service.go	2014-04-30 19:30:20 +0000
+++ testservices/service.go	2014-06-09 01:36:50 +0000
@@ -32,3 +32,7 @@
 
 // IPLimitExceeded corresponds to "HTTP 413 Maximum number of floating ips exceeded"
 var IPLimitExceeded = NewIPLimitExceededError()
+
+// AvailabilityZoneIsNotAvailable corresponds to
+// "HTTP 400 The requested availability zone is not available"
+var AvailabilityZoneIsNotAvailable = NewAvailabilityZoneIsNotAvailableError()