func (s *macOSXVersionSuite) TestOSVersion(c *gc.C) { knownSeries := set.Strings{} for _, series := range macOSXSeries { knownSeries.Add(series) } c.Check(osVersion(), jc.Satisfies, knownSeries.Contains) }
func (*statusContext) processRelations(service *state.Service) (related map[string][]string, subord []string, err error) { // TODO(mue) This way the same relation is read twice (for each service). // Maybe add Relations() to state, read them only once and pass them to each // call of this function. relations, err := service.Relations() if err != nil { return nil, nil, err } var subordSet set.Strings related = make(map[string][]string) for _, relation := range relations { ep, err := relation.Endpoint(service.Name()) if err != nil { return nil, nil, err } relationName := ep.Relation.Name eps, err := relation.RelatedEndpoints(service.Name()) if err != nil { return nil, nil, err } for _, ep := range eps { if ep.Scope == charm.ScopeContainer && !service.IsPrincipal() { subordSet.Add(ep.ServiceName) } related[relationName] = append(related[relationName], ep.ServiceName) } } for relationName, serviceNames := range related { sn := set.NewStrings(serviceNames...) related[relationName] = sn.SortedValues() } return related, subordSet.SortedValues(), nil }
func (stringSetSuite) TestUninitialized(c *gc.C) { var uninitialized set.Strings c.Assert(uninitialized.Size(), gc.Equals, 0) c.Assert(uninitialized.IsEmpty(), gc.Equals, true) // You can get values and sorted values from an unitialized set. AssertValues(c, uninitialized) // All contains checks are false c.Assert(uninitialized.Contains("foo"), gc.Equals, false) // Remove works on an uninitialized Strings uninitialized.Remove("foo") var other set.Strings // Union returns a new set that is empty but initialized. c.Assert(uninitialized.Union(other), gc.DeepEquals, set.NewStrings()) c.Assert(uninitialized.Intersection(other), gc.DeepEquals, set.NewStrings()) c.Assert(uninitialized.Difference(other), gc.DeepEquals, set.NewStrings()) other = set.NewStrings("foo", "bar") c.Assert(uninitialized.Union(other), gc.DeepEquals, other) c.Assert(uninitialized.Intersection(other), gc.DeepEquals, set.NewStrings()) c.Assert(uninitialized.Difference(other), gc.DeepEquals, set.NewStrings()) c.Assert(other.Union(uninitialized), gc.DeepEquals, other) c.Assert(other.Intersection(uninitialized), gc.DeepEquals, set.NewStrings()) c.Assert(other.Difference(uninitialized), gc.DeepEquals, other) // Once something is added, the set becomes initialized. uninitialized.Add("foo") AssertValues(c, uninitialized, "foo") }
// collect calls f on all values in src and returns an alphabetically // ordered list of the returned results without duplicates. func (src List) collect(f func(*Tools) string) []string { var seen set.Strings for _, tools := range src { seen.Add(f(tools)) } return seen.SortedValues() }
// ParseMetadataFromStorage loads ImageMetadata from the specified storage reader. func ParseMetadataFromStorage(c *gc.C, stor storage.StorageReader) []*imagemetadata.ImageMetadata { source := storage.NewStorageSimpleStreamsDataSource("test storage reader", stor, "images") // Find the simplestreams index file. params := simplestreams.ValueParams{ DataType: "image-ids", ValueTemplate: imagemetadata.ImageMetadata{}, } const requireSigned = false indexPath := simplestreams.UnsignedIndex indexRef, err := simplestreams.GetIndexWithFormat( source, indexPath, "index:1.0", requireSigned, simplestreams.CloudSpec{}, params) c.Assert(err, gc.IsNil) c.Assert(indexRef.Indexes, gc.HasLen, 1) imageIndexMetadata := indexRef.Indexes["com.ubuntu.cloud:custom"] c.Assert(imageIndexMetadata, gc.NotNil) // Read the products file contents. r, err := stor.Get(path.Join("images", imageIndexMetadata.ProductsFilePath)) defer r.Close() c.Assert(err, gc.IsNil) data, err := ioutil.ReadAll(r) c.Assert(err, gc.IsNil) // Parse the products file metadata. url, err := source.URL(imageIndexMetadata.ProductsFilePath) c.Assert(err, gc.IsNil) cloudMetadata, err := simplestreams.ParseCloudMetadata(data, "products:1.0", url, imagemetadata.ImageMetadata{}) c.Assert(err, gc.IsNil) // Collate the metadata. imageMetadataMap := make(map[string]*imagemetadata.ImageMetadata) var expectedProductIds set.Strings var imageVersions set.Strings for _, mc := range cloudMetadata.Products { for _, items := range mc.Items { for key, item := range items.Items { imageMetadata := item.(*imagemetadata.ImageMetadata) imageMetadataMap[key] = imageMetadata imageVersions.Add(key) productId := fmt.Sprintf("com.ubuntu.cloud:server:%s:%s", mc.Version, imageMetadata.Arch) expectedProductIds.Add(productId) } } } // Make sure index's product IDs are all represented in the products metadata. sort.Strings(imageIndexMetadata.ProductIds) c.Assert(imageIndexMetadata.ProductIds, gc.DeepEquals, expectedProductIds.SortedValues()) imageMetadata := make([]*imagemetadata.ImageMetadata, len(imageMetadataMap)) for i, key := range imageVersions.SortedValues() { imageMetadata[i] = imageMetadataMap[key] } return imageMetadata }
func (w *minUnitsWatcher) initial() (*set.Strings, error) { serviceNames := new(set.Strings) doc := &minUnitsDoc{} iter := w.st.minUnits.Find(nil).Iter() for iter.Next(doc) { w.known[doc.ServiceName] = doc.Revno serviceNames.Add(doc.ServiceName) } return serviceNames, iter.Err() }
func mergedAddresses(machineAddresses, providerAddresses []address) []instance.Address { merged := make([]instance.Address, len(providerAddresses), len(providerAddresses)+len(machineAddresses)) var providerValues set.Strings for i, address := range providerAddresses { providerValues.Add(address.Value) merged[i] = address.InstanceAddress() } for _, address := range machineAddresses { if !providerValues.Contains(address.Value) { merged = append(merged, address.InstanceAddress()) } } return merged }
// commonServiceInstances returns instances with // services in common with the specified machine. func commonServiceInstances(st *state.State, m *state.Machine) ([]instance.Id, error) { units, err := m.Units() if err != nil { return nil, err } var instanceIdSet set.Strings for _, unit := range units { if !unit.IsPrincipal() { continue } service, err := unit.Service() if err != nil { return nil, err } allUnits, err := service.AllUnits() if err != nil { return nil, err } for _, unit := range allUnits { machineId, err := unit.AssignedMachineId() if state.IsNotAssigned(err) { continue } else if err != nil { return nil, err } machine, err := st.Machine(machineId) if err != nil { return nil, err } instanceId, err := machine.InstanceId() if err == nil { instanceIdSet.Add(string(instanceId)) } else if state.IsNotProvisionedError(err) { continue } else { return nil, err } } } instanceIds := make([]instance.Id, instanceIdSet.Size()) // Sort values to simplify testing. for i, instanceId := range instanceIdSet.SortedValues() { instanceIds[i] = instance.Id(instanceId) } return instanceIds, nil }
func (w *minUnitsWatcher) merge(serviceNames *set.Strings, change watcher.Change) error { serviceName := change.Id.(string) if change.Revno == -1 { delete(w.known, serviceName) serviceNames.Remove(serviceName) return nil } doc := minUnitsDoc{} if err := w.st.minUnits.FindId(serviceName).One(&doc); err != nil { return err } revno, known := w.known[serviceName] w.known[serviceName] = doc.Revno if !known || doc.Revno > revno { serviceNames.Add(serviceName) } return nil }
func (w *lifecycleWatcher) merge(ids *set.Strings, updates map[interface{}]bool) error { // Separate ids into those thought to exist and those known to be removed. changed := []string{} latest := map[string]Life{} for id, exists := range updates { id := id.(string) if exists { changed = append(changed, id) } else { latest[id] = Dead } } // Collect life states from ids thought to exist. Any that don't actually // exist are ignored (we'll hear about them in the next set of updates -- // all that's actually happened in that situation is that the watcher // events have lagged a little behind reality). iter := w.coll.Find(bson.D{{"_id", bson.D{{"$in", changed}}}}).Select(lifeFields).Iter() var doc lifeDoc for iter.Next(&doc) { latest[doc.Id] = doc.Life } if err := iter.Err(); err != nil { return err } // Add to ids any whose life state is known to have changed. for id, newLife := range latest { gone := newLife == Dead oldLife, known := w.life[id] switch { case known && gone: delete(w.life, id) case !known && !gone: w.life[id] = newLife case known && newLife != oldLife: w.life[id] = newLife default: continue } ids.Add(id) } return nil }
// fetchUnitMachineIds returns a set of IDs for machines that // the specified units reside on, and those machines' ancestors. func fetchUnitMachineIds(units map[string]map[string]*state.Unit) (*set.Strings, error) { machineIds := new(set.Strings) for _, svcUnitMap := range units { for _, unit := range svcUnitMap { if !unit.IsPrincipal() { continue } mid, err := unit.AssignedMachineId() if err != nil { return nil, err } for mid != "" { machineIds.Add(mid) mid = state.ParentId(mid) } } } return machineIds, nil }
// ParseMetadataFromStorage loads ToolsMetadata from the specified storage reader. func ParseMetadataFromStorage(c *gc.C, stor storage.StorageReader, expectMirrors bool) []*tools.ToolsMetadata { source := storage.NewStorageSimpleStreamsDataSource("test storage reader", stor, "tools") params := simplestreams.ValueParams{ DataType: tools.ContentDownload, ValueTemplate: tools.ToolsMetadata{}, } const requireSigned = false indexPath := simplestreams.UnsignedIndex indexRef, err := simplestreams.GetIndexWithFormat( source, indexPath, "index:1.0", requireSigned, simplestreams.CloudSpec{}, params) c.Assert(err, gc.IsNil) c.Assert(indexRef.Indexes, gc.HasLen, 1) toolsIndexMetadata := indexRef.Indexes["com.ubuntu.juju:released:tools"] c.Assert(toolsIndexMetadata, gc.NotNil) // Read the products file contents. r, err := stor.Get(path.Join("tools", toolsIndexMetadata.ProductsFilePath)) defer r.Close() c.Assert(err, gc.IsNil) data, err := ioutil.ReadAll(r) c.Assert(err, gc.IsNil) url, err := source.URL(toolsIndexMetadata.ProductsFilePath) c.Assert(err, gc.IsNil) cloudMetadata, err := simplestreams.ParseCloudMetadata(data, "products:1.0", url, tools.ToolsMetadata{}) c.Assert(err, gc.IsNil) toolsMetadataMap := make(map[string]*tools.ToolsMetadata) var expectedProductIds set.Strings var toolsVersions set.Strings for _, mc := range cloudMetadata.Products { for _, items := range mc.Items { for key, item := range items.Items { toolsMetadata := item.(*tools.ToolsMetadata) toolsMetadataMap[key] = toolsMetadata toolsVersions.Add(key) seriesVersion, err := ubuntu.SeriesVersion(toolsMetadata.Release) c.Assert(err, gc.IsNil) productId := fmt.Sprintf("com.ubuntu.juju:%s:%s", seriesVersion, toolsMetadata.Arch) expectedProductIds.Add(productId) } } } // Make sure index's product IDs are all represented in the products metadata. sort.Strings(toolsIndexMetadata.ProductIds) c.Assert(toolsIndexMetadata.ProductIds, gc.DeepEquals, expectedProductIds.SortedValues()) toolsMetadata := make([]*tools.ToolsMetadata, len(toolsMetadataMap)) for i, key := range toolsVersions.SortedValues() { toolsMetadata[i] = toolsMetadataMap[key] } if expectMirrors { r, err = stor.Get(path.Join("tools", simplestreams.UnsignedMirror)) defer r.Close() c.Assert(err, gc.IsNil) data, err = ioutil.ReadAll(r) c.Assert(err, gc.IsNil) c.Assert(string(data), jc.Contains, `"mirrors":`) c.Assert(err, gc.IsNil) } return toolsMetadata }