id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c4000 |
err := st.db().RunTransaction([]txn.Op{op})
if err == txn.ErrAborted {
return errors.NotFoundf("existing permissions")
}
return errors.Trace(err)
} | |
c4001 |
// DateCreated is inserted as UTC, but read out as local time. So we
// convert it back to UTC here.
controllerUser.DateCreated = controllerUser.DateCreated.UTC()
return controllerUser, nil
} | |
c4002 | = errors.NewNotFound(nil, fmt.Sprintf("controller user %q does not exist", user.Id()))
}
if err != nil {
return errors.Trace(err)
}
return nil
} | |
c4003 | c.facade.FacadeCall("Info", args, &result); err != nil {
return nil, errors.Trace(err)
}
return &result, nil
} | |
c4004 |
return params.ApplicationGetResults{}, err
}
results.ApplicationConfig = nil
return results, nil
} | |
c4005 |
return params.ApplicationGetResults{}, err
}
results.ApplicationConfig = nil
return results, nil
} | |
c4006 | {
return permission.UserAccess{}, errors.Annotate(err, "adding model user")
}
target := userAccessTarget{
uuid: m.UUID(),
globalKey: modelGlobalKey,
}
return m.st.addUserAccess(spec, target)
} | |
c4007 | "adding controller user")
}
return st.addUserAccess(spec, userAccessTarget{globalKey: controllerGlobalKey})
} | |
c4008 | user.Id()
return strings.ToLower(username)
} | |
c4009 | permission.UserAccess{}, errors.Annotate(err, "obtaining model permission")
}
return newUserAccess(perm, userDoc, names.NewModelTag(userDoc.ObjectUUID)), nil
} | |
c4010 | permission.UserAccess{}, errors.Annotate(err, "obtaining controller permission")
}
return newUserAccess(perm, userDoc, names.NewControllerTag(userDoc.ObjectUUID)), nil
} | |
c4011 | != nil {
return "", errors.Trace(err)
}
return st.GetOfferAccess(offerUUID, subject)
case names.CloudTagKind:
return st.GetCloudAccess(target.Id(), subject)
default:
return "", errors.NotValidf("%q as a target", target.Kind())
}
} | |
c4012 | userDoc, err = st.modelUser(target.Id(), subject)
if err == nil {
return NewModelUserAccess(st, userDoc)
}
case names.ControllerTagKind:
userDoc, err = st.controllerUser(subject)
if err == nil {
return NewControllerUserAccess(st, userDoc)
}
default:
return permission.UserAccess{}, errors.NotValidf... | |
c4013 | errors.Trace(st.removeControllerUser(subject))
}
return errors.NotValidf("%q as a target", target.Kind())
} | |
c4014 | ids)
}
task.machinesMutex.Lock()
defer task.machinesMutex.Unlock()
for i, result := range machines {
switch {
case result.Err == nil:
task.machines[result.Machine.Id()] = result.Machine
case params.IsCodeNotFoundOrCodeUnauthorized(result.Err):
logger.Debugf("machine %q not found in state", ids[i])
d... | |
c4015 |
}
switch classification {
case Pending:
pending = append(pending, machine)
case Dead:
dead = append(dead, machine)
case Maintain:
maintain = append(maintain, machine)
}
}
logger.Tracef("pending machines: %v", pending)
logger.Tracef("dead machines: %v", dead)
return
} | |
c4016 | nil, err
}
}
// Now remove all those instances that we are stopping already as we
// know about those and don't want to include them in the unknown list.
for _, inst := range stopping {
delete(taskInstances, inst.Id())
}
var unknown []instances.Instance
for _, inst := range taskInstances {
unknown = appen... | |
c4017 | continue
}
inst, found := task.instances[instId]
// If the instance is not found we can't stop it.
if found {
instances = append(instances, inst)
}
}
}
return instances
} | |
c4018 | _, machine := range task.machines {
instId, err := machine.InstanceId()
if err != nil {
continue
}
instanceMachines[instId] = machine.Id()
}
// convert instances IDs to machines IDs to aid distributing
// not yet created instances across availability zones.
task.availabilityZoneMachines = make([]*Avail... | |
c4019 | dgAvailabilityZoneMachines = append(dgAvailabilityZoneMachines, &AvailabilityZoneMachine{
azm.ZoneName,
azm.MachineIds.Intersection(dgSet),
azm.FailedMachineIds,
azm.ExcludedMachineIds,
})
}
return dgAvailabilityZoneMachines
} | |
c4020 | }
break
}
}
} else {
zoneMap := azMachineFilterSort(task.availabilityZoneMachines).FilterZones(cons)
sort.Sort(zoneMap)
for _, zoneMachines := range zoneMap {
if !zoneMachines.FailedMachineIds.Contains(machineId) &&
!zoneMachines.ExcludedMachineIds.Contains(machineId) {
machineZone = zone... | |
c4021 |
for _, zone := range *cons.Zones {
if azm.ZoneName == zone {
filtered = append(filtered, azm)
break
}
}
}
return filtered
} | |
c4022 | := task.startMachine(machine, dg); err != nil {
task.removeMachineFromAZMap(machine)
errMachines[index] = err
}
}(m, machineDistributionGroups[i].MachineIds, i)
}
wg.Wait()
select {
case <-task.catacomb.Dying():
return task.catacomb.ErrDying()
default:
}
var errorStrings []string
for _, err := ... | |
c4023 | task.toolsFinder.FindTools(
*version,
pInfo.Series,
arch,
)
if err != nil {
return environs.StartInstanceParams{}, errors.Annotatef(err, "cannot find agent binaries for machine %q", machine)
}
startInstanceParams, err := task.constructStartInstanceParams(
task.controllerUUID,
machine,
instanceCfg,
... | |
c4024 | if err != nil {
return errors.Trace(err)
}
if len(derivedZones) == 0 {
return nil
}
task.machinesMutex.Lock()
defer task.machinesMutex.Unlock()
useZones := set.NewStrings(derivedZones...)
for _, zoneMachines := range task.availabilityZoneMachines {
if !useZones.Contains(zoneMachines.ZoneName) {
zoneMac... | |
c4025 | return lxdprofile.LXDProfileNames(profileNames)
}
} else {
logger.Tracef("failed to gather profile names, broker didn't conform to LXDProfileNameRetriever")
}
}
return machineProfiles
} | |
c4026 | zoneMachines.FailedMachineIds.Add(machine.Id())
if azRemaining {
break
}
}
if !zoneMachines.FailedMachineIds.Contains(machine.Id()) &&
!zoneMachines.ExcludedMachineIds.Contains(machine.Id()) {
azRemaining = true
}
}
return azRemaining, nil
} | |
c4027 | task.availabilityZoneMachines {
zoneMachines.MachineIds.Remove(machineId)
zoneMachines.FailedMachineIds.Remove(machineId)
}
} | |
c4028 | provider)
if err != nil {
return nil, "", "", AnnotateWithFinalizationError(err, credentialName, args.Cloud.Name)
}
credential, err = provider.FinalizeCredential(
ctx, environs.FinalizeCredentialParams{
Credential: *credential,
CloudEndpoint: cloudEndpoint,
CloudStorageEndpoint: cl... | |
c4029 | if err != nil {
return nil, errors.Trace(err)
}
return ioutil.ReadFile(f)
}
var err error
credential, err = cloud.FinalizeCredential(
*credential, provider.CredentialSchemas(), readFile,
)
if err != nil {
return nil, err
}
return credential, nil
} | |
c4030 |
}
// No credential specified, so use the default for the cloud.
for credentialName = range cloudCredentials.AuthCredentials {
}
}
}
credential, ok := cloudCredentials.AuthCredentials[credentialName]
if !ok {
return nil, "", "", errors.NotFoundf(
"%q credential for cloud %q", credentialName, cloud... | |
c4031 | if len(detected.AuthCredentials) == 0 {
return nil, errors.NotFoundf("credentials for cloud %q", cloudName)
}
if len(detected.AuthCredentials) > 1 {
return nil, ErrMultipleCredentials
}
return detected, nil
} | |
c4032 | if err != nil {
return nil, errors.Annotatef(
err, "registering credentials for provider",
)
}
logger.Tracef("provider registered credentials: %v", found)
if len(found) == 0 {
return nil, errors.NotFoundf("credentials for provider")
}
return found, errors.Trace(err)
}
return nil, nil
} | |
c4033 | mock.recorder = &MockAPICallsMockRecorder{mock}
return mock
} | |
c4034 | := ret[0].(params.ContainerConfig)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c4035 | "ContainerConfig", reflect.TypeOf((*MockAPICalls)(nil).ContainerConfig))
} | |
c4036 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerInterfaceInfo", reflect.TypeOf((*MockAPICalls)(nil).GetContainerInterfaceInfo), arg0)
} | |
c4037 | _ := ret[0].([]*provisioner.LXDProfileResult)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c4038 | := m.ctrl.Call(m, "HostChangesForContainer", arg0)
ret0, _ := ret[0].([]network.DeviceToBridge)
ret1, _ := ret[1].(int)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | |
c4039 | _ := ret[0].([]network.InterfaceInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c4040 | := m.ctrl.Call(m, "ReleaseContainerAddresses", arg0)
ret0, _ := ret[0].(error)
return ret0
} | |
c4041 | := m.ctrl.Call(m, "SetHostMachineNetworkConfig", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | |
c4042 | }
result := &sequenceDoc{}
_, err := query.Apply(inc, result)
if err != nil {
return -1, fmt.Errorf("cannot increment %q sequence number: %v", name, err)
}
return result.Counter, nil
} | |
c4043 | updater := newDbSeqUpdater(sequences, mb.modelUUID(), name)
return updateSeqWithMin(updater, minVal)
} | |
c4044 | result := make(map[string]int)
for _, doc := range docs {
result[doc.Name] = doc.Counter
}
return result, nil
} | |
c4045 | < minVal {
nextVal = minVal + 1
}
ok, err := sequence.set(curVal, nextVal)
if err != nil {
return -1, errors.Annotate(err, "could not set sequence")
}
if ok {
return nextVal - 1, nil
}
// Someone else incremented the sequence at the same time,
// try again.
}
}
return -1, errors... | |
c4046 | now looking at %s", jujuDir)
}
jujudPath := filepath.Join(jujuDir, names.Jujud)
logger.Debugf("jujud path %s", jujudPath)
for _, name := range commands {
// The link operation fails when the target already exists,
// so this is a no-op when the command names already
// exist.
err := symlink.New(jujudPath,... | |
c4047 | errors.New("controller configuration has no ca-cert")
}
if p.CAPrivateKey == "" {
return errors.New("empty ca-private-key")
}
// TODO(axw) validate other things.
return nil
} | |
c4048 | eg
// - 3.75GiB on AWS, Google
// - 3.5GiB on Azure
// - 4GiB on Rackspace etc
var mem uint64 = 3.5 * 1024
cons.Mem = &mem
}
return cons
} | |
c4049 |
doBootstrap := bootstrapIAAS
if jujucloud.CloudIsCAAS(args.Cloud) {
doBootstrap = bootstrapCAAS
}
if err := doBootstrap(ctx, environ, callCtx, args, bootstrapParams); err != nil {
return errors.Trace(err)
}
ctx.Infof("Bootstrap agent now started")
return nil
} | |
c4050 | lookup %v", imageConstraint)
// Get image metadata from all data sources.
// Since order of data source matters, order of image metadata matters too. Append is important here.
var publicImageMetadata []*imagemetadata.ImageMetadata
for _, source := range sources {
sourceMetadata, _, err := imagemetadata.Fetch([]... | |
c4051 | "failed to find %s agent binaries, will attempt to use %s",
jujuversion.Current, newVersion,
)
} else {
bootstrapVersion, toolsList = compatibleVersion, compatibleTools
}
}
logger.Infof("picked bootstrap agent binary version: %s", bootstrapVersion)
return toolsList, nil
} | |
c4052 | err == nil {
err = environ.SetConfig(cfg)
}
if err != nil {
return errors.Errorf("failed to update model configuration: %v", err)
}
}
return nil
} | |
c4053 | if isCompatibleVersion(tools.Version.Number, version) {
compatibleTools = append(compatibleTools, tools)
}
}
return compatibleTools.Newest()
} | |
c4054 | return nil, errors.Annotate(err, "cannot access image metadata")
}
return nil, nil
} else {
logger.Debugf("setting default image metadata source: %s", imageMetadataDir)
}
baseURL := fmt.Sprintf("file://%s", filepath.ToSlash(imageMetadataDir))
publicKey, _ := simplestreams.UserPublicSigningKey()
datasourc... | |
c4055 | source := gui.NewDataSource(dataSourceBaseURL)
allMeta, err := guiFetchMetadata(gui.ReleasedStream, source)
if err != nil {
logProgress(fmt.Sprintf("Unable to fetch Juju GUI info: %s", err))
return nil
}
if len(allMeta) == 0 {
logProgress("No available Juju GUI archives found")
return nil
}
// Metadata i... | |
c4056 | err != nil {
return "", 0, errors.Mask(err)
}
return fmt.Sprintf("%x", h.Sum(nil)), size, nil
} | |
c4057 | listCmd.refreshModels = listCmd.ModelCommandBase.RefreshModels
return modelcmd.Wrap(listCmd)
} | |
c4058 | range relations {
output[one.Name] = RemoteEndpoint{one.Name, one.Interface, string(one.Role)}
}
return output
} | |
c4059 | return ctlr.pool.Get(modelTag.Id())
} | |
c4060 | == nil {
return errors.New("pool is closed")
}
return ctlr.pool.SystemState().Ping()
} | |
c4061 | return nil, errors.Annotatef(err, "controller %q", st.ControllerUUID())
}
return settings.Map(), nil
} | |
c4062 | network.SelectAddressesBySpaceNames(m.Addresses(), spaceName); !ok {
missing = append(missing, id)
}
}
if len(missing) > 0 {
return errors.Errorf("machines with no addresses in this space: %s", strings.Join(missing, ", "))
}
return nil
} | |
c4063 | kind == storage.StorageKindBlock
} | |
c4064 | oracleVolumeType: latencyPool,
})
return []*storage.Config{latencyPool}
} | |
c4065 | {
return errors.NotValidf("branch name %q", GenerationMaster)
}
return nil
} | |
c4066 |
return &imageStorage{
modelUUID,
metadataCollection,
blobDb,
}
} | |
c4067 |
return nil, err
}
oldPath = oldDoc.Path
op.Assert = bson.D{{"path", oldPath}}
if oldPath != path {
op.Update = bson.D{{
"$set", bson.D{
{"size", metadata.Size},
{"sha256", metadata.SHA256},
{"path", path},
},
}}
}
}
return []txn.Op{op}, nil
}
txnRunner := s.... | |
c4068 | metadataDoc.Series,
Arch: metadataDoc.Arch,
Size: metadataDoc.Size,
SHA256: metadataDoc.SHA256,
Created: metadataDoc.Created,
SourceURL: metadataDoc.SourceURL,
}
}
return result, nil
} | |
c4069 | imagemetadataC,
Id: docId(metadata),
Remove: true,
}
return []txn.Op{op}, nil
}
txnRunner := s.txnRunner(session)
err := txnRunner.Run(buildTxn)
// Metadata already removed, we don't care.
if err == mgo.ErrNotFound {
return nil
}
return errors.Annotate(err, "cannot remove image metadata")
} | |
c4070 | metadataDoc.Series,
Arch: metadataDoc.Arch,
Size: metadataDoc.Size,
SHA256: metadataDoc.SHA256,
SourceURL: metadataDoc.SourceURL,
Created: metadataDoc.Created,
}
imageResult := &imageCloser{
image,
session,
}
return metadata, imageResult, nil
} | |
c4071 | {
return fmt.Sprintf("images/%s-%s-%s:%s", kind, series, arch, checksum)
} | |
c4072 | metadata.ModelUUID, metadata.Kind, metadata.Series, metadata.Arch)
} | |
c4073 | return nil, err
}
return charm.ParseURL(surl)
} | |
c4074 | utils.WriteYaml(path, url.String())
} | |
c4075 | defer c.mu.Unlock()
return c.details.LXDProfile
} | |
c4076 | return nil, errors.Trace(err)
}
return firewallrules.NewClient(root), nil
}
return modelcmd.Wrap(cmd)
} | |
c4077 | return nil, ErrControllerClosed
}
c.references++
return c.st, nil
} | |
c4078 | err != nil {
logger.Errorf("error when closing controller: %v", err)
}
}
return nil
} | |
c4079 | fmt.Sprintf("resource#%s#%s-%s", id, subType, subID)
} | |
c4080 | true,
}}
// TODO(perrito666) 2016-05-02 lp:1558657
csRes := charmStoreResource{
Resource: newRes.Resource.Resource,
id: newRes.ID,
applicationID: newRes.ApplicationID,
// Truncate the time to remove monotonic time for Go 1.9+
// to make it easier for tests to compare the time.
lastPolle... | |
c4081 | charmStoreResourceID(res.id)
return charmStoreResource2Doc(fullID, res)
} | |
c4082 | unitResourceID(stored.ID, unitID)
return unitResource2Doc(fullID, unitID, stored)
} | |
c4083 | = pendingResourceID(stored.ID, stored.PendingID)
}
return resource2doc(fullID, stored)
} | |
c4084 | stagedResourceID(stored.ID)
return resource2doc(stagedID, stored)
} | |
c4085 | err := p.base.All(resourcesC, query, &docs); err != nil {
return nil, errors.Trace(err)
}
logger.Tracef("found %d resources", len(docs))
return docs, nil
} | |
c4086 |
if err := p.base.One(resourcesC, id, &doc); err != nil {
return doc, errors.Trace(err)
}
return doc, nil
} | |
c4087 | resID, pendingID)
id := pendingResourceID(resID, pendingID)
var doc resourceDoc
if err := p.base.One(resourcesC, id, &doc); err != nil {
return doc, errors.Trace(err)
}
return doc, nil
} | |
c4088 | res.Path,
Description: res.Description,
Origin: res.Origin.String(),
Revision: res.Revision,
Fingerprint: res.Fingerprint.Bytes(),
Size: res.Size,
Username: res.Username,
Timestamp: res.Timestamp,
StoragePath: stored.storagePath,
}
} | |
c4089 |
stored := storedResource{
Resource: res,
storagePath: doc.StoragePath,
}
return stored, nil
} | |
c4090 | },
Origin: origin,
Revision: doc.Revision,
Fingerprint: fp,
Size: doc.Size,
},
ID: doc.ID,
PendingID: doc.PendingID,
ApplicationID: doc.ApplicationID,
Username: doc.Username,
Timestamp: doc.Timestamp,
}
if err := res.Validate(); err != nil {
return r... | |
c4091 | nil {
return nil
}
if err := ls.stream.Close(); err != nil {
return errors.Trace(err)
}
ls.stream = nil
return nil
} | |
c4092 | }
if config.FacadeFactory == nil {
return errors.NotValidf("nil FacadeFactory")
}
if config.Service == nil {
return errors.NotValidf("nil Service")
}
return nil
} | |
c4093 | logger: config.Logger,
service: config.Service,
upgraderFactory: config.UpgraderFactory,
machineStatus: model.UpgradeSeriesNotStarted,
leadersPinned: false,
}
if err := catacomb.Invoke(catacomb.Plan{
Site: &w.catacomb,
Work: w.loop,
}); err != nil {
return nil, errors.Trace(err)
... | |
c4094 |
w.logger.Infof("machine series upgrade status is %q", w.machineStatus)
switch w.machineStatus {
case model.UpgradeSeriesPrepareStarted:
err = w.handlePrepareStarted()
case model.UpgradeSeriesCompleteStarted:
err = w.handleCompleteStarted()
case model.UpgradeSeriesCompleted:
err = w.handleCompleted()
}
re... | |
c4095 |
unitServices, allConfirmed, err := w.compareUnitAgentServices(w.preparedUnits)
if err != nil {
return errors.Trace(err)
}
if !allConfirmed {
w.logger.Debugf(
"waiting for units to complete series upgrade preparation; known unit agent services: %s",
unitNames(unitServices),
)
return nil
}
return e... | |
c4096 |
}
if err := upgrader.PerformUpgrade(); err != nil {
return errors.Trace(err)
}
return errors.Trace(w.SetMachineStatus(model.UpgradeSeriesPrepareCompleted,
"binaries and service files written"))
} | |
c4097 |
if running {
continue
}
if err := svc.Start(); err != nil {
return errors.Annotatef(err, "starting %q unit agent after series upgrade", unit)
}
}
return errors.Trace(w.StartUnitCompletion("started unit agents after series upgrade"))
} | |
c4098 | err != nil {
return errors.Trace(err)
}
return errors.Trace(w.unpinLeaders())
} | |
c4099 | the warning
// in the log and return out. Unpinning leaders should be safe as that
// should be considered a no-op
if params.IsCodeNotImplemented(err) {
w.logger.Infof("failed to pin machine applications, with legacy lease manager leadership pinning is not implemented")
return nil
}
return errors.Trace... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.