id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c5100 | pairs = append(pairs, name+"="+value)
}
return strings.Join(pairs, ";")
} | |
c5101 | Config: a.Agent.CurrentConfig(),
modelUUID: a.modelUUID,
controllerUUID: a.controllerUUID,
}
} | |
c5102 |
}
info.ModelTag = names.NewModelTag(c.modelUUID)
return info, true
} | |
c5103 |
// One of the uniter workers failing should not
// prevent the others from running.
IsFatal: func(error) bool { return false },
// For any failures, try again in 3 seconds.
RestartDelay: 3 * time.Second,
}),
}
if err := catacomb.Invoke(catacomb.Plan{
Site: &op.catacomb,
Work: op.loop,
Init: ... | |
c5104 | _, err := os.Stat(filepath.Join(dir, "environments.yaml"))
return err == nil
} | |
c5105 |
if runtime.GOOS == "windows" {
JujuHomeDir = oldJujuHomeWin()
} else {
JujuHomeDir = oldJujuHomeLinux()
}
}
return JujuHomeDir
} | |
c5106 |
MaxHistoryMB: maxHistoryMB,
}
return s.facade.FacadeCall("Prune", p, nil)
} | |
c5107 | mock.recorder = &MockSummaryMockRecorder{mock}
return mock
} | |
c5108 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Collect", reflect.TypeOf((*MockSummary)(nil).Collect), arg0)
} | |
c5109 | float64) {
m.ctrl.Call(m, "Observe", arg0)
} | |
c5110 | err = l.config.charmdir.Visit(func() error {
return l.do(c)
}, abort)
if err != nil {
fmt.Fprintf(c, "error: %v\n", err.Error())
} else {
fmt.Fprintf(c, "ok\n")
}
return errors.Trace(err)
} | |
c5111 | config.Clock,
}
err := catacomb.Invoke(catacomb.Plan{
Site: &p.catacomb,
Work: p.loop,
})
return p, err
} | |
c5112 | var password string
if !opState.Exists {
if password, err = utils.RandomPassword(); err != nil {
return errors.Trace(err)
}
appPasswords = append(appPasswords, apicaasprovisioner.ApplicationPassword{Name: app, Password: password})
}
config, err := p.makeOperatorConfig(app, password)
if err != nil... | |
c5113 |
config.ControllerPortName,
config.StateName,
},
Start: config.start,
}
} | |
c5114 |
return block.ProcessBlockedError(err, block.BlockChange)
}
result := availabilityInfo{
Added: machineTagsToIds(enableHAResult.Added...),
Removed: machineTagsToIds(enableHAResult.Removed...),
Maintained: machineTagsToIds(enableHAResult.Maintained...),
Promoted: machineTagsToIds(enableHAResult.Pro... | |
c5115 | continue
}
result = append(result, tag.Id())
}
return result
} | |
c5116 | csOpener.NewClient()
if err != nil {
return resource.Opened{}, errors.Trace(err)
}
cache := &charmstoreEntityCache{
st: ro.res,
userID: ro.userID,
unit: ro.unit,
applicationID: ro.unit.ApplicationName(),
}
res, reader, err := charmstore.GetResource(charmstore.GetResourceArgs... | |
c5117 |
}
if config.Destroyer == nil {
return errors.NotValidf("nil Destroyer")
}
return nil
} | |
c5118 | if err != nil {
return nil, errors.Trace(err)
}
u.setCallCtx(common.NewCloudCallContext(config.CredentialAPI, u.catacomb.Dying))
return u, nil
} | |
c5119 |
// just because we migrated a model, so this time needs to be
// long enough to make sure we cover the time taken to migrate
// a reasonable sized model. We don't yet know how long this
// is going to be, but we need something.
// TODO(babbageclunk): Handle this better - maybe a way to
// suppress leadersh... | |
c5120 | return errors.NotValidf("missing ToolsUploader")
}
if c.ResourceDownloader == nil {
return errors.NotValidf("missing ResourceDownloader")
}
if c.ResourceUploader == nil {
return errors.NotValidf("missing ResourceUploader")
}
return nil
} | |
c5121 | {
return errors.Trace(err)
}
if err := uploadResources(config); err != nil {
return errors.Trace(err)
}
return nil
} | |
c5122 | error) {
return NewJSONMetricRecorder(MetricRecorderConfig{
SpoolDir: f.spoolDir,
Metrics: declaredMetrics,
CharmURL: charmURL,
UnitTag: unitTag,
})
} | |
c5123 | newWorker)
manifold.Output = outputFunc
return manifold
} | |
c5124 | &spoolWorker{factory: newFactory(metricsSpoolDir)}
w.tomb.Go(func() error {
<-w.tomb.Dying()
return nil
})
return w, nil
} | |
c5125 | }
return FormattedPayload{
Unit: payload.Unit,
Machine: payload.Machine,
ID: payload.ID,
Type: payload.Type,
Class: payload.Name,
Labels: labels,
// TODO(ericsnow) Explicitly convert to a string?
Status: payload.Status,
}
} | |
c5126 |
mock.StartParams = params
return nil
} | |
c5127 | is not running")
}
mock.started = false
mock.factory.notify(Stopped, mock.name)
return nil
} | |
c5128 | } else if cleanupNeeded {
return errors.New("cleanup needed")
}
// Check the source controller.
controllerBackend, err := backend.ControllerBackend()
if err != nil {
return errors.Trace(err)
}
controllerCtx := precheckContext{controllerBackend, controllerPresence}
if err := controllerCtx.checkController();... | |
c5129 | // Check for conflicts with existing models
modelUUIDs, err := backend.AllModelUUIDs()
if err != nil {
return errors.Annotate(err, "retrieving models")
}
for _, modelUUID := range modelUUIDs {
model, release, err := pool.GetModel(modelUUID)
if err != nil {
return errors.Trace(err)
}
defer release()
... | |
c5130 | errors.Cause(err).(*errMetricsData)
return ok
} | |
c5131 | metric.Key,
Value: metric.Value,
Time: metric.Time,
Labels: metric.Labels,
}
}
return params.MetricBatchParam{
Tag: batch.UnitTag,
Batch: params.MetricBatch{
UUID: batch.UUID,
CharmURL: batch.CharmURL,
Created: batch.Created,
Metrics: metrics,
},
}
} | |
c5132 | spoolDir: config.SpoolDir,
uuid: mbUUID,
charmURL: config.CharmURL,
// TODO(fwereade): 2016-03-17 lp:1558657
created: time.Now().UTC(),
validMetrics: config.Metrics,
unitTag: config.UnitTag,
}
if err := recorder.open(); err != nil {
return nil, errors.Trace(err)
}
return recorder, nil
} | |
c5133 | // Now write the meta file so that JSONMetricReader discovers a finished
// pair of files.
err = m.recordMetaData()
if err != nil {
return errors.Trace(err)
}
return nil
} | |
c5134 | return errors.Trace(err)
}
m.lock.Lock()
defer m.lock.Unlock()
return errors.Trace(m.enc.Encode(jujuc.Metric{
Key: key,
Value: value,
Time: created,
Labels: labels,
}))
} | |
c5135 | string) bool {
_, ok := m.validMetrics[key]
return ok
} | |
c5136 | "failed to open spool directory %q", spoolDir)
}
return &JSONMetricReader{
dir: spoolDir,
}, nil
} | |
c5137 |
}
batch.Metrics, err = decodeMetrics(filepath.Join(r.dir, batch.UUID))
if err != nil {
return errors.Trace(err)
}
if len(batch.Metrics) > 0 {
batches = append(batches, batch)
}
return nil
}
if err := filepath.Walk(r.dir, walker); err != nil {
return nil, errors.Trace(err)
}
return batches, ni... | |
c5138 |
err := os.Remove(metaFile)
if err != nil && !os.IsNotExist(err) {
return errors.Trace(err)
}
err = os.Remove(dataFile)
if err != nil {
return errors.Trace(err)
}
return nil
} | |
c5139 | applicationID,
CharmID: chID,
CharmStoreMacaroon: csMac,
Resources: resources,
})
} | |
c5140 | region, op.Name)
} else {
call = rc.GlobalOperations.Get(projectID, op.Name)
}
operation, err := doOpCall(call)
if err != nil {
return nil, errors.Annotatef(err, "request for GCE operation %q failed", op.Name)
}
return operation, nil
} | |
c5141 |
machines, err := op.Do()
if err != nil {
return nil, errors.Annotatef(err, "listing machine types for project %q and zone %q", projectID, zone)
}
return machines, nil
} | |
c5142 | {
return errors.NotValidf("missing prometheus registerer")
}
if c.Cleanup == nil {
return errors.NotValidf("missing cleanup func")
}
return nil
} | |
c5143 | err := catacomb.Invoke(catacomb.Plan{
Site: &w.catacomb,
Work: w.loop,
Init: []worker.Worker{w.controller},
}); err != nil {
return nil, errors.Trace(err)
}
return w, nil
} | |
c5144 | return errors.Annotatef(err, "failed to open model %q", modelUUID)
}
defer func() {
model.Release()
}()
if err := runner(model.State); err != nil {
return errors.Annotatef(err, "model UUID %q", modelUUID)
}
}
return nil
} | |
c5145 | d {
field := &d[i]
if field.Name == name {
return field.Value, true
}
}
return nil, false
} | |
c5146 | d[i] = newField
return nil
}
}
return errors.NotFoundf("field %q", name)
} | |
c5147 |
ops = append(ops, txn.Op{
C: permissionsC,
Id: id,
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{{"access", "add-model"}}}},
})
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
return st.runRawTransaction(ops)
} | |
c5148 | return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, controllerUsersC, "_id", "user", "createdby")
if err != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, modelUsersC, "_id", "user", "createdby")
if err != nil {
return err
}
ops = append(ops,... | |
c5149 |
ops = append(ops, txn.Op{
C: migrationsC,
Id: id,
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{{"attempt", attempt}}}},
})
}
if err := iter.Close(); err != nil {
return errors.Annotate(err, "iterating migrations")
}
return errors.Trace(st.runRawTransaction(ops))
} | |
c5150 | ok := doc["life"].(int); !ok {
upgradesLogger.Errorf("invalid life for charm: %s", id)
continue
} else if life == int(Dead) {
deadIds = append(deadIds, id)
}
}
sequences, closer := st.db().GetRawCollection(sequenceC)
defer closer()
for modelUUID, modelRevs := range maxRevs {
for baseURL, maxRevisi... | |
c5151 | credential)
if err != nil {
return errors.Trace(err)
}
return st.db().RunTransaction(append(cloudOps, credOps...))
} | |
c5152 | C: settingsC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Settings}},
})
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | |
c5153 | doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Settings}},
})
}
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | |
c5154 | maybeUpdateSettings(doc.Settings, controller.MaxTxnLogSize, fmt.Sprintf("%vM", controller.DefaultMaxTxnLogCollectionMB)) || settingsChanged
if settingsChanged {
ops = append(ops, txn.Op{
C: controllersC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Setting... | |
c5155 |
var ops []txn.Op
var doc settingsDoc
for iter.Next(&doc) {
settingsChanged, err := change(&doc)
if err != nil {
return errors.Trace(err)
}
if settingsChanged {
ops = append(ops, txn.Op{
C: settingsC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"setting... | |
c5156 | maybeUpdateSettings(doc.Settings, config.MaxStatusHistorySize, config.DefaultStatusHistorySize) || settingsChanged
return settingsChanged, nil
})
if err != nil {
return errors.Trace(err)
}
return nil
} | |
c5157 | maybeUpdateSettings(doc.Settings, config.MaxActionResultsSize, config.DefaultActionResultsSize) || settingsChanged
return settingsChanged, nil
})
if err != nil {
return errors.Trace(err)
}
return nil
} | |
c5158 | config.UpdateStatusHookInterval, config.DefaultUpdateStatusHookInterval)
return settingsChanged, nil
})
if err != nil {
return errors.Trace(err)
}
return nil
} | |
c5159 | in which case we'd get a duplicate
// id error (this is OK).
if !mgo.IsDup(err) {
return errors.Annotate(err, "failed to insert log record")
}
}
doc = nil
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
// drop the old collection
if err := oldLogs.DropCollection(); err != nil... | |
c5160 |
return errors.Trace(coll.DropCollection())
}
session := st.MongoSession()
renameCommand := bson.D{
{"renameCollection", "juju.audit.log"},
{"to", "juju.old-audit.log"},
}
return errors.Trace(session.Run(renameCommand, nil))
} | |
c5161 | bulk.Unordered()
bulk.RemoveAll(bson.D{{"source", bson.D{{"$ne", "custom"}}}})
_, err := bulk.Run()
return errors.Annotate(err, "deleting cloud image metadata records")
} | |
c5162 | := settings.Get(controller.JujuHASpace); ok {
upgradesLogger.Debugf("not copying mongo-space-name %q to juju-ha-space - already set to %q",
mongoSpace, haSpace)
} else {
settings.Set(controller.JujuHASpace, mongoSpace)
if _, err = settings.Write(); err != nil {
return errors.Annotate(err, "writing c... | |
c5163 | appConfID := fmt.Sprintf("%s:%s", app.ModelUUID, applicationConfigKey(app.Name))
if !allIDs.Contains(appConfID) {
newOp := createSettingsOp(settingsC, appConfID, emptySettings)
// createSettingsOp assumes you're using a model-specific state, which will auto-inject the ModelUUID
// since we're doing this glo... | |
c5164 |
err := controllerColl.UpdateId(modelGlobalKey, bson.M{"$unset": bson.M{"votingmachineids": 1}})
if err != nil {
return errors.Annotate(err, "removing votingmachineids")
}
return nil
} | |
c5165 | }
_, currentCount, err := countCloudModelRefOp(st, c.Name)
if err != nil {
return errors.Trace(err)
}
if n != currentCount {
op, err := nsRefcounts.CreateOrIncRefOp(refCountColl, cloudModelRefCountKey(c.Name), n-currentCount)
if err != nil {
return errors.Trace(err)
}
updateOps = append(upd... | |
c5166 | return false, nil
}
}
doc.Settings[config.ContainerImageStreamKey] = "released"
return true, nil
})
if err != nil {
return errors.Trace(err)
}
return nil
} | |
c5167 | replicaset.CurrentMembers(pool.SystemState().MongoSession())
} | |
c5168 | int64 `bson:"start"`
Duration time.Duration `bson:"duration"`
}
for iter.Next(&doc) {
startTime := time.Unix(0, doc.Start)
globalExpiry := startTime.Add(doc.Duration)
remaining := globalExpiry.Sub(globalTime)
localExpiry := localTime.Add(remaining)
key := corelease.Key{
Namespace: doc.Namesp... | |
c5169 | doc.DocId,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"access": "login"}},
})
ops = append(ops,
createPermissionOp(cloudGlobalKey(controllerInfo.CloudName), doc.SubjectGlobalKey, permission.AddModelAccess))
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) ... | |
c5170 | if found {
// If the config option's already been set don't change
// it.
return false, nil
}
doc.Settings["enable-disk-uuid"] = false
return true, nil
}))
} | |
c5171 | var doc settingsDoc
for iter.Next(&doc) {
ops = append(ops, txn.Op{
C: globalSettingsC,
Id: doc.DocID,
Remove: true,
Assert: txn.DocExists,
})
doc.DocID = key
ops = append(ops, txn.Op{
C: globalSettingsC,
Id: key,
Insert: doc,
Assert: txn.DocMissing,
})
}
if err :... | |
c5172 | } else if err != mgo.ErrNotFound {
return errors.Trace(err)
}
rawDoc := statusDoc{
ModelUUID: machine.ModelUUID,
Status: status.Idle,
Updated: updatedTime,
}
ops = append(ops, txn.Op{
C: statusesC,
Id: key,
Assert: txn.DocMissing,
Insert: rawDoc,
})
}
if err := machi... | |
c5173 | localID := applicationDeviceConstraintsKey(application.Name, application.CharmURL)
key := ensureModelUUID(application.ModelUUID, localID)
// We only need to migrate applications that don't have a device
// constraints document. So we need to first check if there is one, before
// creating a txn.Op for the mi... | |
c5174 | that's fine.
if isMgoNamespaceNotFound(err) {
return nil
}
return errors.Annotate(err, "failed to drop instanceCharmProfileData collection")
}
return nil
} | |
c5175 | {
s.MethodCall(s, "CreateVolumes", ctx, params)
if s.CreateVolumesFunc != nil {
return s.CreateVolumesFunc(ctx, params)
}
return nil, errors.NotImplementedf("CreateVolumes")
} | |
c5176 | {
s.MethodCall(s, "ListVolumes", ctx)
if s.ListVolumesFunc != nil {
return s.ListVolumesFunc(ctx)
}
return nil, nil
} | |
c5177 | != nil {
return s.DescribeVolumesFunc(ctx, volIds)
}
return nil, errors.NotImplementedf("DescribeVolumes")
} | |
c5178 |
return s.DestroyVolumesFunc(ctx, volIds)
}
return nil, errors.NotImplementedf("DestroyVolumes")
} | |
c5179 |
return s.ReleaseVolumesFunc(ctx, volIds)
}
return nil, errors.NotImplementedf("ReleaseVolumes")
} | |
c5180 | s.ValidateVolumeParamsFunc != nil {
return s.ValidateVolumeParamsFunc(params)
}
return nil
} | |
c5181 | s.AttachVolumesFunc != nil {
return s.AttachVolumesFunc(ctx, params)
}
return nil, errors.NotImplementedf("AttachVolumes")
} | |
c5182 | != nil {
return s.DetachVolumesFunc(ctx, params)
}
return nil, errors.NotImplementedf("DetachVolumes")
} | |
c5183 | st,
resources: resources,
getCanWatch: getCanWatch,
}
} | |
c5184 |
continue
}
err = ErrPerm
watcherId := ""
if canWatch(tag) {
watcherId, err = a.watchEntity(tag)
}
result.Results[i].NotifyWatcherId = watcherId
result.Results[i].Error = ServerError(err)
}
return result, nil
} | |
c5185 | %v\n", result.Started)
fmt.Fprintf(ctx.Stdout, "finished: %v\n", result.Finished)
fmt.Fprintf(ctx.Stdout, "notes: %q\n", result.Notes)
fmt.Fprintf(ctx.Stdout, "model ID: %q\n", result.Model)
fmt.Fprintf(ctx.Stdout, "machine ID: %q\n", result.Machine)
fmt.Fprintf(ctx.Stdout, "creat... | |
c5186 | return errors.NotValidf("nil GenerateSSHKey")
}
if cfg.ServicePrincipalCreator == nil {
return errors.NotValidf("nil ServicePrincipalCreator")
}
if cfg.AzureCLI == nil {
return errors.NotValidf("nil AzureCLI")
}
return nil
} | |
c5187 | environProviderCredentials: environProviderCredentials{
servicePrincipalCreator: config.ServicePrincipalCreator,
azureCLI: config.AzureCLI,
},
config: config,
}, nil
} | |
c5188 | := base.NewFacadeCaller(
caller,
leadershipFacade,
)
return NewLeadershipPinningAPIFromFacade(facadeCaller)
} | |
c5189 | entityTags := make([]names.Tag, len(entities))
for i, e := range entities {
tag, err := names.ParseTag(e)
if err != nil {
return nil, errors.Trace(err)
}
entityTags[i] = tag
}
pinned[app] = entityTags
}
return pinned, nil
} | |
c5190 | err := a.pinMachineAppsOps("PinMachineApplications")
return res, errors.Trace(err)
} | |
c5191 | make(map[string]error, len(callResults))
for _, res := range callResults {
var appErr error
if res.Error != nil {
appErr = res.Error
}
result[res.ApplicationName] = appErr
}
return result, nil
} | |
c5192 | return &uniterResolver{
config: cfg,
retryHookTimerStarted: false,
}
} | |
c5193 | }
return opFactory.NewResolvedUpgrade(localState.CharmURL)
}
if remoteState.ForceCharmUpgrade && charmModified(localState, remoteState) {
return opFactory.NewRevertUpgrade(remoteState.CharmURL)
}
return nil, resolver.ErrWaiting
} | |
c5194 | error) {
return nil, resolver.ErrNoOperation
} | |
c5195 | f.allowGuests(false, abort)
} | |
c5196 | return ErrAborted
case f.guestTickets <- guestTicket{visit, result}:
return <-result
}
} | |
c5197 | ErrShutdown
case f.guardTickets <- guardTicket{allowGuests, abort, result}:
return <-result
}
} | |
c5198 | about abuse but
// (2) remain comprehensible and functional in the face of aborted
// Lockdowns.
if ticket.allowGuests {
guestTickets = f.guestTickets
} else {
guestTickets = nil
}
go ticket.complete(active.Wait)
}
}
} | |
c5199 | nil, errors.Trace(err)
}
return NewCertificate(cert, key), nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.