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("%q as a target", target.Kind())
}
return permission.UserAccess{}, errors.Trace(err)
}
| |
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])
delete(task.machines, ids[i])
default:
return errors.Annotatef(result.Err, "failed to get machine %v", ids[i])
}
}
return nil
}
| |
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 = append(unknown, inst)
}
return unknown, nil
}
| |
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([]*AvailabilityZoneMachine, len(availabilityZoneInstances))
for i, instances := range availabilityZoneInstances {
machineIds := set.NewStrings()
for _, instanceId := range instances.Instances {
if id, ok := instanceMachines[instanceId]; ok {
machineIds.Add(id)
}
}
task.availabilityZoneMachines[i] = &AvailabilityZoneMachine{
ZoneName: instances.ZoneName,
MachineIds: machineIds,
FailedMachineIds: set.NewStrings(),
ExcludedMachineIds: set.NewStrings(),
}
}
return nil
}
| |
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 = zoneMachines.ZoneName
zoneMachines.MachineIds.Add(machineId)
break
}
}
}
if machineZone == "" {
return machineZone, errors.NotFoundf("suitable availability zone for machine %v", machineId)
}
return machineZone, nil
}
| |
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 := range errMachines {
if err != nil {
errorStrings = append(errorStrings, err.Error())
}
}
if errorStrings != nil {
return errors.New(strings.Join(errorStrings, "\n"))
}
return nil
}
| |
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,
pInfo,
possibleTools,
)
if err != nil {
return environs.StartInstanceParams{}, errors.Annotatef(err, "cannot construct params for machine %q", machine)
}
return startInstanceParams, nil
}
| |
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) {
zoneMachines.ExcludedMachineIds.Add(machineId)
}
}
return nil
}
| |
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: cloudStorageEndpoint,
CloudIdentityEndpoint: cloudIdentityEndpoint,
},
)
if err != nil {
return nil, "", "", AnnotateWithFinalizationError(err, credentialName, args.Cloud.Name)
}
return credential, credentialName, regionName, nil
}
| |
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, cloudName,
)
}
return &credential, credentialName, cloudCredentials.DefaultRegion, nil
}
| |
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.New("too much contention while updating sequence")
}
| |
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, filepath.Join(dir, name))
if err != nil && !os.IsExist(err) {
return err
}
}
return nil
}
| |
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([]simplestreams.DataSource{source}, imageConstraint)
if err != nil {
logger.Debugf("ignoring image metadata in %s: %v", source.Description(), err)
// Just keep looking...
continue
}
logger.Debugf("found %d image metadata in %s", len(sourceMetadata), source.Description())
publicImageMetadata = append(publicImageMetadata, sourceMetadata...)
}
logger.Debugf("found %d image metadata from all image data sources", len(publicImageMetadata))
if len(publicImageMetadata) == 0 {
return nil, errors.New("no image metadata found")
}
return publicImageMetadata, nil
}
| |
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()
datasource := simplestreams.NewURLSignedDataSource("bootstrap metadata", baseURL, publicKey, utils.NoVerifySSLHostnames, simplestreams.CUSTOM_CLOUD_DATA, false)
// Read the image metadata, as we'll want to upload it to the environment.
imageConstraint := imagemetadata.NewImageConstraint(simplestreams.LookupParams{})
existingMetadata, _, err := imagemetadata.Fetch([]simplestreams.DataSource{datasource}, imageConstraint)
if err != nil && !errors.IsNotFound(err) {
return nil, errors.Annotate(err, "cannot read image metadata")
}
// Add an image metadata datasource for constraint validation, etc.
environs.RegisterUserImageDataSourceFunc("bootstrap metadata", func(environs.Environ) (simplestreams.DataSource, error) {
return datasource, nil
})
logger.Infof("custom image metadata added to search path")
return existingMetadata, nil
}
| |
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 info are returned in descending version order.
logProgress(fmt.Sprintf("Fetching Juju GUI %s", allMeta[0].Version))
return &coretools.GUIArchive{
Version: allMeta[0].Version,
URL: allMeta[0].FullPath,
SHA256: allMeta[0].SHA256,
Size: allMeta[0].Size,
}
}
| |
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.txnRunner(session)
err := txnRunner.Run(buildTxn)
if err != nil {
return errors.Annotate(err, "cannot store image metadata")
}
if oldPath != "" && oldPath != path {
// Attempt to remove the old path. Failure is non-fatal.
err := managedStorage.RemoveForBucket(s.modelUUID, oldPath)
if err != nil {
logger.Errorf("failed to remove old image blob: %v", err)
} else {
logger.Debugf("removed old image blob")
}
}
return nil
}
| |
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.
lastPolled: time.Now().Truncate(1).UTC(),
}
if exists {
ops = append(ops, newUpdateResourceOps(newRes)...)
return append(ops, newUpdateCharmStoreResourceOps(csRes)...)
} else {
ops = append(ops, newInsertResourceOps(newRes)...)
return append(ops, newInsertCharmStoreResourceOps(csRes)...)
}
}
| |
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 res, errors.Annotate(err, "got invalid data from DB")
}
return res, nil
}
| |
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)
}
return w, nil
}
| |
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()
}
return errors.Trace(err)
}
| |
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 errors.Trace(w.transitionPrepareComplete(unitServices))
}
| |
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(err)
}
var lastErr error
for app, err := range results {
if err == nil {
w.logger.Infof("unpin leader for application %q", app)
continue
}
w.logger.Errorf("failed to pin leader for application %q: %s", app, err.Error())
lastErr = err
}
if lastErr == nil {
w.leadersPinned = true
return nil
}
return errors.Trace(lastErr)
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.