← Back to branch summary

~wallyworld/goose/rate-limit-retry-tests

« back to all changes in this revision

Viewing changes to testservices/novaservice/service.go

nova double: list server filters and run server.

Implemented filters by status and name (others not implemented, but
probably also not needed), as well as creating a server (RunServer).

Added a few needed things: serverByName and generateUUID + tests.

With this, the nova double will be up-to-date with the nova client
and functional.

R=fwereade, rog
CC=
https://codereview.appspot.com/7073060

Show diffs side-by-side

added added

removed removed

Lines of Context:
testservices/novaservice/service.go
161
161
        return &server, nil
162
162
}
163
163
 
 
164
// serverByName retrieves the first existing server with the given name.
 
165
func (n *Nova) serverByName(name string) (*nova.ServerDetail, error) {
 
166
        for _, server := range n.servers {
 
167
                if server.Name == name {
 
168
                        return &server, nil
 
169
                }
 
170
        }
 
171
        return nil, fmt.Errorf("no such server named %q", name)
 
172
}
 
173
 
164
174
// serverAsEntity returns the stored ServerDetail as Entity.
165
175
func (n *Nova) serverAsEntity(serverId string) (*nova.Entity, error) {
166
176
        server, err := n.server(serverId)
174
184
        }, nil
175
185
}
176
186
 
 
187
// matchServer returns true if the given server is matched by the
 
188
// given filter, or false otherwise.
 
189
func (n *Nova) matchServer(filter *nova.Filter, server nova.ServerDetail) bool {
 
190
        if filter == nil {
 
191
                return true // empty filter matches everything
 
192
        }
 
193
        values := filter.Values
 
194
        for _, val := range values[nova.FilterStatus] {
 
195
                if server.Status == val {
 
196
                        return true
 
197
                }
 
198
        }
 
199
        for _, val := range values[nova.FilterServer] {
 
200
                if server.Name == val {
 
201
                        return true
 
202
                }
 
203
        }
 
204
        // TODO(dimitern) maybe implement FilterFlavor, FilterImage,
 
205
        // FilterMarker, FilterLimit and FilterChangesSince
 
206
        return false
 
207
}
 
208
 
177
209
// allServers returns a list of all existing servers.
178
 
func (n *Nova) allServers() []nova.ServerDetail {
 
210
// Filtering is supported, see nova.Filter* for more info.
 
211
func (n *Nova) allServers(filter *nova.Filter) []nova.ServerDetail {
179
212
        var servers []nova.ServerDetail
180
213
        for _, server := range n.servers {
181
 
                servers = append(servers, server)
 
214
                if n.matchServer(filter, server) {
 
215
                        servers = append(servers, server)
 
216
                }
182
217
        }
183
218
        return servers
184
219
}
185
220
 
186
221
// allServersAsEntities returns all servers as Entity structs.
187
 
func (n *Nova) allServersAsEntities() []nova.Entity {
 
222
// Filtering is supported, see nova.Filter* for more info.
 
223
func (n *Nova) allServersAsEntities(filter *nova.Filter) []nova.Entity {
188
224
        var entities []nova.Entity
189
225
        for _, server := range n.servers {
190
 
                entities = append(entities, nova.Entity{
191
 
                        Id:    server.Id,
192
 
                        Name:  server.Name,
193
 
                        Links: server.Links,
194
 
                })
 
226
                if n.matchServer(filter, server) {
 
227
                        entities = append(entities, nova.Entity{
 
228
                                Id:    server.Id,
 
229
                                Name:  server.Name,
 
230
                                Links: server.Links,
 
231
                        })
 
232
                }
195
233
        }
196
234
        return entities
197
235
}