// getMirrorReference returns the reference to the metadata file containing mirrors for the specified content and cloud.
func (mirrorRefs *MirrorRefs) getMirrorReference(datatype, contentId string, cloud CloudSpec) (*MirrorReference, error) {
candidates := mirrorRefs.extractMirrorRefs(contentId)
if len(candidates) == 0 {
return nil, errors.NotFoundf("mirror data for %q", contentId)
}
// Restrict by cloud spec and datatype.
hasRightCloud := func(mirrorRef *MirrorReference) bool {
return mirrorRef.hasCloud(cloud) && mirrorRef.DataType == datatype
}
matchingCandidates := candidates.filter(hasRightCloud)
if len(matchingCandidates) == 0 {
// No cloud specific mirrors found so look for a non cloud specific mirror.
for _, candidate := range candidates {
if len(candidate.Clouds) == 0 {
logger.Debugf("using default candidate for content id %q are %v", contentId, candidate)
return &candidate, nil
}
}
return nil, errors.NotFoundf("index file with cloud %v", cloud)
}
logger.Debugf("candidate matches for content id %q are %v", contentId, candidates)
// Pick arbitrary match.
return &matchingCandidates[0], nil
}
// removeSettings removes the Settings for key.
func removeSettings(st *State, key string) error {
err := st.settings.RemoveId(key)
if err == mgo.ErrNotFound {
return errors.NotFoundf("settings")
}
return nil
}
func (e *Environment) refresh(query *mgo.Query) error {
err := query.One(&e.doc)
if err == mgo.ErrNotFound {
return errors.NotFoundf("environment")
}
return err
}
// AgentTools returns the tools that the agent is currently running.
// It returns an error that satisfies errors.IsNotFound if the tools
// have not yet been set.
func (m *Machine) AgentTools() (*tools.Tools, error) {
if m.doc.Tools == nil {
return nil, errors.NotFoundf("agent tools for machine %v", m)
}
tools := *m.doc.Tools
return &tools, nil
}
// AgentTools returns the tools that the agent is currently running.
// It an error that satisfies errors.IsNotFound if the tools have not
// yet been set.
func (u *Unit) AgentTools() (*tools.Tools, error) {
if u.doc.Tools == nil {
return nil, errors.NotFoundf("agent tools for unit %q", u)
}
tools := *u.doc.Tools
return &tools, nil
}
func (s *BootstrapSuite) runAllowRetriesTest(c *gc.C, test bootstrapRetryTest) {
toolsVersions := envtesting.VAll
if test.version != "" {
useVersion := strings.Replace(test.version, "%LTS%", config.LatestLtsSeries(), 1)
testVersion := version.MustParseBinary(useVersion)
s.PatchValue(&version.Current, testVersion)
if test.addVersionToSource {
toolsVersions = append([]version.Binary{}, toolsVersions...)
toolsVersions = append(toolsVersions, testVersion)
}
}
_, fake := makeEmptyFakeHome(c)
defer fake.Restore()
sourceDir := createToolsSource(c, toolsVersions)
s.PatchValue(&envtools.DefaultBaseURL, sourceDir)
var findToolsRetryValues []bool
mockFindTools := func(cloudInst environs.ConfigGetter, majorVersion, minorVersion int,
filter coretools.Filter, allowRetry bool) (list coretools.List, err error) {
findToolsRetryValues = append(findToolsRetryValues, allowRetry)
return nil, errors.NotFoundf("tools")
}
restore := envtools.TestingPatchBootstrapFindTools(mockFindTools)
defer restore()
_, errc := runCommand(nullContext(c), new(BootstrapCommand), test.args...)
err := <-errc
c.Check(findToolsRetryValues, gc.DeepEquals, test.expectedAllowRetry)
stripped := strings.Replace(err.Error(), "\n", "", -1)
c.Check(stripped, gc.Matches, test.err)
}
// settingsDecRefOps returns a list of operations that decrement the
// ref count of the service settings identified by serviceName and
// curl. If the ref count is set to zero, the appropriate setting and
// ref count documents will both be deleted.
func settingsDecRefOps(st *State, serviceName string, curl *charm.URL) ([]txn.Op, error) {
key := serviceSettingsKey(serviceName, curl)
var doc settingsRefsDoc
if err := st.settingsrefs.FindId(key).One(&doc); err == mgo.ErrNotFound {
return nil, errors.NotFoundf("service %q settings for charm %q", serviceName, curl)
} else if err != nil {
return nil, err
}
if doc.RefCount == 1 {
return []txn.Op{{
C: st.settingsrefs.Name,
Id: key,
Assert: bson.D{{"refcount", 1}},
Remove: true,
}, {
C: st.settings.Name,
Id: key,
Remove: true,
}}, nil
}
return []txn.Op{{
C: st.settingsrefs.Name,
Id: key,
Assert: bson.D{{"refcount", bson.D{{"$gt", 1}}}},
Update: bson.D{{"$inc", bson.D{{"refcount", -1}}}},
}}, nil
}
// getUser fetches information about the user with the
// given name into the provided userDoc.
func (st *State) getUser(name string, udoc *userDoc) error {
err := st.users.Find(bson.D{{"_id", name}}).One(udoc)
if err == mgo.ErrNotFound {
err = errors.NotFoundf("user %q", name)
}
return err
}
func readConstraints(st *State, id string) (constraints.Value, error) {
doc := constraintsDoc{}
if err := st.constraints.FindId(id).One(&doc); err == mgo.ErrNotFound {
return constraints.Value{}, errors.NotFoundf("constraints")
} else if err != nil {
return constraints.Value{}, err
}
return doc.value(), nil
}
// ReadInfo implements Storage.ReadInfo.
func (m *memStore) ReadInfo(envName string) (EnvironInfo, error) {
m.mu.Lock()
defer m.mu.Unlock()
info := m.envs[envName]
if info != nil {
return info.clone(), nil
}
return nil, errors.NotFoundf("environment %q", envName)
}
func (st *fakeState) Machine(id string) (stateMachine, error) {
if err := errorFor("State.Machine", id); err != nil {
return nil, err
}
if m := st.machine(id); m != nil {
return m, nil
}
return nil, errors.NotFoundf("machine %s", id)
}
// Refresh refreshes the contents of the relation from the underlying
// state. It returns an error that satisfies errors.IsNotFound if the
// relation has been removed.
func (r *Relation) Refresh() error {
doc := relationDoc{}
err := r.st.relations.FindId(r.doc.Key).One(&doc)
if err == mgo.ErrNotFound {
return errors.NotFoundf("relation %v", r)
}
if err != nil {
return fmt.Errorf("cannot refresh relation %v: %v", r, err)
}
if r.doc.Id != doc.Id {
// The relation has been destroyed and recreated. This is *not* the
// same relation; if we pretend it is, we run the risk of violating
// the lifecycle-only-advances guarantee.
return errors.NotFoundf("relation %v", r)
}
r.doc = doc
return nil
}
func (s *ConfigValidatorSuite) TestUpdateEnvironConfigFailsOnConfigValidateError(c *gc.C) {
var configValidatorErr error
s.policy.getConfigValidator = func(string) (state.ConfigValidator, error) {
configValidatorErr = errors.NotFoundf("")
return &s.configValidator, configValidatorErr
}
err := s.updateEnvironConfig(c)
c.Assert(err, gc.ErrorMatches, " not found")
}
// Refresh refreshes the contents of the Unit from the underlying
// state. It an error that satisfies errors.IsNotFound if the unit has
// been removed.
func (u *Unit) Refresh() error {
err := u.st.units.FindId(u.doc.Name).One(&u.doc)
if err == mgo.ErrNotFound {
return errors.NotFoundf("unit %q", u)
}
if err != nil {
return fmt.Errorf("cannot refresh unit %q: %v", u, err)
}
return nil
}
// constraints is a helper function to return a unit's deployment constraints.
func (u *Unit) constraints() (*constraints.Value, error) {
cons, err := readConstraints(u.st, u.globalKey())
if errors.IsNotFound(err) {
// Lack of constraints indicates lack of unit.
return nil, errors.NotFoundf("unit")
} else if err != nil {
return nil, err
}
return &cons, nil
}
func (st *fakeState) FindEntity(tag string) (state.Entity, error) {
entity, ok := st.entities[tag]
if !ok {
return nil, errors.NotFoundf("entity %q", tag)
}
if err := entity.error(); err != nil {
return nil, err
}
return entity, nil
}
// Refresh refreshes the contents of the Service from the underlying
// state. It returns an error that satisfies errors.IsNotFound if the
// service has been removed.
func (s *Service) Refresh() error {
err := s.st.services.FindId(s.doc.Name).One(&s.doc)
if err == mgo.ErrNotFound {
return errors.NotFoundf("service %q", s)
}
if err != nil {
return fmt.Errorf("cannot refresh service %q: %v", s, err)
}
return nil
}
func (s *aggregateSuite) TestPartialErrResponse(c *gc.C) {
testGetter := new(testInstanceGetter)
testGetter.err = environs.ErrPartialInstances
testGetter.results = []instance.Instance{nil}
aggregator := newAggregator(testGetter)
_, err := aggregator.instanceInfo("foo")
c.Assert(err, gc.DeepEquals, errors.NotFoundf("instance foo"))
}
// Network returns the network with the given name.
func (st *State) Network(name string) (*Network, error) {
doc := &networkDoc{}
err := st.networks.FindId(name).One(doc)
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("network %q", name)
}
if err != nil {
return nil, fmt.Errorf("cannot get network %q: %v", name, err)
}
return newNetwork(st, doc), nil
}
// Get is specified in the StorageReader interface.
func (storage *azureStorage) Get(name string) (io.ReadCloser, error) {
context, err := storage.getStorageContext()
if err != nil {
return nil, err
}
reader, err := context.GetBlob(storage.getContainer(), name)
if gwacl.IsNotFoundError(err) {
return nil, errors.NotFoundf("file %q not found", name)
}
return reader, err
}
// Relation returns the existing relation with the given id.
func (st *State) Relation(id int) (*Relation, error) {
doc := relationDoc{}
err := st.relations.Find(bson.D{{"id", id}}).One(&doc)
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("relation %d", id)
}
if err != nil {
return nil, fmt.Errorf("cannot get relation %d: %v", id, err)
}
return newRelation(st, &doc), nil
}
// Fetch is defined in simplestreams.DataSource.
func (h *urlDataSource) Fetch(path string) (io.ReadCloser, string, error) {
dataURL := urlJoin(h.baseURL, path)
client := utils.GetHTTPClient(h.hostnameVerification)
// dataURL can be http:// or file://
resp, err := client.Get(dataURL)
if err != nil {
logger.Debugf("Got error requesting %q: %v", dataURL, err)
return nil, dataURL, errors.NotFoundf("invalid URL %q", dataURL)
}
if resp.StatusCode == http.StatusNotFound {
return nil, dataURL, errors.NotFoundf("cannot find URL %q", dataURL)
}
if resp.StatusCode == http.StatusUnauthorized {
return nil, dataURL, errors.Unauthorizedf("unauthorised access to URL %q", dataURL)
}
if resp.StatusCode != http.StatusOK {
return nil, dataURL, fmt.Errorf("cannot access URL %q, %q", dataURL, resp.Status)
}
return resp.Body, dataURL, nil
}
// StateServingInfo returns information for running a state server machine
func (st *State) StateServingInfo() (params.StateServingInfo, error) {
var info params.StateServingInfo
err := st.stateServers.Find(bson.D{{"_id", stateServingInfoKey}}).One(&info)
if err != nil {
return info, err
}
if info.StatePort == 0 {
return params.StateServingInfo{}, errors.NotFoundf("state serving info")
}
return info, nil
}
// newUnitName returns the next unit name.
func (s *Service) newUnitName() (string, error) {
change := mgo.Change{Update: bson.D{{"$inc", bson.D{{"unitseq", 1}}}}}
result := serviceDoc{}
if _, err := s.st.services.Find(bson.D{{"_id", s.doc.Name}}).Apply(change, &result); err == mgo.ErrNotFound {
return "", errors.NotFoundf("service %q", s)
} else if err != nil {
return "", fmt.Errorf("cannot increment unit sequence: %v", err)
}
name := s.doc.Name + "/" + strconv.Itoa(result.UnitSeq)
return name, nil
}
func getInstanceData(st *State, id string) (instanceData, error) {
var instData instanceData
err := st.instanceData.FindId(id).One(&instData)
if err == mgo.ErrNotFound {
return instanceData{}, errors.NotFoundf("instance data for machine %v", id)
}
if err != nil {
return instanceData{}, fmt.Errorf("cannot get instance data for machine %v: %v", id, err)
}
return instData, nil
}
// Containers returns the container ids belonging to a parent machine.
// TODO(wallyworld): move this method to a service
func (m *Machine) Containers() ([]string, error) {
var mc machineContainers
err := m.st.containerRefs.FindId(m.Id()).One(&mc)
if err == nil {
return mc.Children, nil
}
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("container info for machine %v", m.Id())
}
return nil, err
}
// KeyRelation returns the existing relation with the given key (which can
// be derived unambiguously from the relation's endpoints).
func (st *State) KeyRelation(key string) (*Relation, error) {
doc := relationDoc{}
err := st.relations.Find(bson.D{{"_id", key}}).One(&doc)
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("relation %q", key)
}
if err != nil {
return nil, fmt.Errorf("cannot get relation %q: %v", key, err)
}
return newRelation(st, &doc), nil
}
// getStatus retrieves the status document associated with the given
// globalKey and copies it to outStatusDoc, which needs to be created
// by the caller before.
func getStatus(st *State, globalKey string) (statusDoc, error) {
var doc statusDoc
err := st.statuses.FindId(globalKey).One(&doc)
if err == mgo.ErrNotFound {
return statusDoc{}, errors.NotFoundf("status")
}
if err != nil {
return statusDoc{}, fmt.Errorf("cannot get status %q: %v", globalKey, err)
}
return doc, nil
}
// GetProductsPath returns the path to the metadata file containing products for the specified constraint.
// Exported for testing.
func (indexRef *IndexReference) GetProductsPath(cons LookupConstraint) (string, error) {
if indexRef.MirroredProductsPath != "" {
return indexRef.MirroredProductsPath, nil
}
prodIds, err := cons.Ids()
if err != nil {
return "", err
}
candidates := indexRef.extractIndexes()
// Restrict to image-ids entries.
dataTypeMatches := func(metadata *IndexMetadata) bool {
return metadata.DataType == indexRef.valueParams.DataType
}
candidates = candidates.filter(dataTypeMatches)
if len(candidates) == 0 {
return "", errors.NotFoundf("index file missing %q data", indexRef.valueParams.DataType)
}
// Restrict by cloud spec, if required.
if cons.Params().CloudSpec != EmptyCloudSpec {
hasRightCloud := func(metadata *IndexMetadata) bool {
return metadata.hasCloud(cons.Params().CloudSpec)
}
candidates = candidates.filter(hasRightCloud)
if len(candidates) == 0 {
return "", errors.NotFoundf("index file has no data for cloud %v", cons.Params().CloudSpec)
}
}
// Restrict by product IDs.
hasProduct := func(metadata *IndexMetadata) bool {
return metadata.hasProduct(prodIds)
}
candidates = candidates.filter(hasProduct)
if len(candidates) == 0 {
return "", newNoMatchingProductsError("index file has no data for product name(s) %q", prodIds)
}
logger.Debugf("candidate matches for products %q are %v", prodIds, candidates)
// Pick arbitrary match.
return candidates[0].ProductsFilePath, nil
}
// Refresh refreshes the contents of the machine from the underlying
// state. It returns an error that satisfies errors.IsNotFound if the
// machine has been removed.
func (m *Machine) Refresh() error {
doc := machineDoc{}
err := m.st.machines.FindId(m.doc.Id).One(&doc)
if err == mgo.ErrNotFound {
return errors.NotFoundf("machine %v", m)
}
if err != nil {
return fmt.Errorf("cannot refresh machine %v: %v", m, err)
}
m.doc = doc
return nil
}
