id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c3300 | }
var results params.ErrorResults
err := c.facade.FacadeCall("UnsetApplicationsConfig", args, &results)
if err != nil {
return errors.Trace(err)
}
return results.OneError()
} | |
c3301 | unit)
}
entities[i].Tag = names.NewUnitTag(unit).String()
}
args.Tags = params.Entities{Entities: entities}
}
results := new(params.ErrorResults)
err := c.facade.FacadeCall("ResolveUnitErrors", args, results)
if err != nil {
return errors.Trace(err)
}
return errors.Trace(results.Combine())
} | |
c3302 | i, one := range applications {
all[i] = params.Entity{Tag: one.String()}
}
in := params.Entities{Entities: all}
var out params.ApplicationInfoResults
err := c.facade.FacadeCall("ApplicationsInfo", in, &out)
if err != nil {
return nil, errors.Trace(err)
}
if resultsLen := len(out.Results); resultsLen != len(... | |
c3303 |
configGetter := stateenvirons.EnvironConfigGetter{State: st, Model: model}
ctrlModel, err := ctlrSt.Model()
if err != nil {
return nil, err
}
return NewModelManagerAPI(
common.NewModelManagerBackend(model, pool),
common.NewModelManagerBackend(ctrlModel, pool),
configGetter,
caas.New,
auth,
model,... | |
c3304 |
return nil, err
}
return &ModelManagerAPIV6{v7}, nil
} | |
c3305 |
return nil, err
}
return &ModelManagerAPIV4{v5}, nil
} | |
c3306 |
if err != nil {
return nil, errors.Trace(err)
}
urlGetter := common.NewToolsURLGetter(st.ModelUUID(), st)
return &ModelManagerAPI{
ModelStatusAPI: common.NewModelStatusAPI(st, authorizer, apiUser),
state: st,
ctlrState: ctlrSt,
getBroker: getBroker,
check: common.NewBlockChe... | |
c3307 | with 'local'. We must compare against
// the Canonical value of the user tag.
if m.apiUser == user {
return nil
}
return common.ErrPerm
} | |
c3308 | if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].Result = dumped
}
return results
} | |
c3309 | range args.Entities {
v4Args.Models[i] = params.DestroyModelParams{
ModelTag: arg.Tag,
DestroyStorage: &destroyStorage,
}
}
return m.ModelManagerAPI.DestroyModels(v4Args)
} | |
c3310 | errors.Trace(err)
}
if !m.isAdmin {
hasAdmin, err := m.authorizer.HasPermission(permission.AdminAccess, model.ModelTag())
if err != nil {
return errors.Trace(err)
}
if !hasAdmin {
return errors.Trace(common.ErrPerm)
}
}
return errors.Trace(common.DestroyModel(st, destroyStorage, force, ... | |
c3311 | range args.Entities {
modelInfo, err := getModelInfo(arg)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].Result = &modelInfo
}
return results, nil
} | |
c3312 | := canModifyController || canModifyModel
if !canModify {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
targetUserTag, err := names.ParseUserTag(arg.UserTag)
if err != nil {
result.Results[i].Error = common.ServerError(errors.Annotate(err, "could not modify model access"))
... | |
c3313 | return errors.Errorf("user already has %q access or greater", access)
}
if _, err = st.SetUserAccess(modelUser.UserTag, modelUser.Object, access); err != nil {
return errors.Annotate(err, "could not set model access for user")
}
return nil
}
return errors.Annotate(err, "could not grant model acc... | |
c3314 | if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
result.Results[i] = m.modelDefaults(cloudTag.Id())
}
return result, nil
} | |
c3315 | result, common.ErrPerm
}
return m.modelDefaults(m.model.Cloud()), nil
} | |
c3316 | for i, arg := range args.Config {
results.Results[i].Error = common.ServerError(
m.setModelDefaults(arg),
)
}
return results, nil
} | |
c3317 | err != nil {
results.Results[i].Error = common.ServerError(
errors.Trace(err))
continue
}
rspec = spec
}
results.Results[i].Error = common.ServerError(
m.ctlrState.UpdateModelConfigDefaultValues(nil, arg.Keys, rspec),
)
}
return results, nil
} | |
c3318 | if err != nil {
return nil, errors.Trace(err)
}
rspec, err := environs.NewCloudRegionSpec(cTag.Id(), r)
if err != nil {
return nil, errors.Trace(err)
}
return rspec, nil
} | |
c3319 | nil {
return errors.Trace(err)
}
model, releaser, err := m.state.GetModel(modelTag.Id())
if err != nil {
return errors.Trace(err)
}
defer releaser()
updated, err := model.SetCloudCredential(credentialTag)
if err != nil {
return errors.Trace(err)
}
if !updated {
return errors.Errorf("mode... | |
c3320 | 1 {
return params.StatusResult{}, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return params.StatusResult{}, result.Error
}
return result, nil
} | |
c3321 | }
err := u.st.facade.FacadeCall("AddMetrics", args, &result)
if err != nil {
return errors.Annotate(err, "unable to add metric")
}
return result.OneError()
} | |
c3322 | results := new(params.ErrorResults)
err := u.st.facade.FacadeCall("AddMetricBatches", p, results)
if err != nil {
return nil, errors.Annotate(err, "failed to send metric batches")
}
for i, result := range results.Results {
batchResults[batches[i].UUID] = result.Error
}
return batchResults, nil
} | |
c3323 | common.Watch(u.st.facade, "Watch", u.tag)
} | |
c3324 | Refresh() immediately to get the up-to-date
// life and other needed locally cached fields.
err := application.Refresh()
if err != nil {
return nil, err
}
return application, nil
} | |
c3325 | err != nil {
panic(err)
}
return application
} | |
c3326 | []params.Entity{{Tag: u.tag.String()}},
}
err := u.st.facade.FacadeCall("DestroyAllSubordinates", args, &result)
if err != nil {
return err
}
return result.OneError()
} | |
c3327 | != 1 {
return false, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return false, result.Error
}
return result.Result, nil
} | |
c3328 | Tag: u.tag.String(),
Protocol: protocol,
FromPort: fromPort,
ToPort: toPort,
}},
}
err := u.st.facade.FacadeCall("ClosePorts", args, &result)
if err != nil {
return err
}
return result.OneError()
} | |
c3329 | != 1 {
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
w := apiwatcher.NewStringsWatcher(u.st.facade.RawAPICaller(), result)
return w, nil
} | |
c3330 | {
return "", errors.Errorf("expected 1 result, got %d", len(res))
}
return res[0], nil
} | |
c3331 |
return u.st.SetUpgradeSeriesUnitStatus(status, reason)
} | |
c3332 |
}
err = u.st.facade.FacadeCall("RequestReboot", args, &result)
if err != nil {
return err
}
return result.OneError()
} | |
c3333 | {
tag, err := names.ParseRelationTag(result.RelationTag)
if err != nil {
return nil, err
}
statusResult = append(statusResult, RelationStatus{
Tag: tag,
InScope: result.InScope,
Suspended: result.Suspended,
})
}
return statusResult, nil
} | |
c3334 | u.st.WatchUnitStorageAttachments(u.tag)
} | |
c3335 | Constraints: one,
})
}
}
args := params.StoragesAddParams{Storages: all}
var results params.ErrorResults
err := u.st.facade.FacadeCall("AddUnitStorage", args, &results)
if err != nil {
return err
}
return results.Combine()
} | |
c3336 | != nil {
return errors.Trace(err)
}
meta.SetID(id)
stored, err := stor.Metadata(id)
if err != nil {
return errors.Trace(err)
}
meta.SetStored(stored.Stored())
return nil
} | |
c3337 | Backups {
b := backups{
storage: stor,
}
return &b
} | |
c3338 | {
return "", errors.Annotate(err, "while storing backup archive")
}
return meta.ID(), nil
} | |
c3339 |
meta, ok := rawmeta.(*Metadata)
if !ok {
return nil, nil, errors.New("did not get a backups.Metadata value from storage")
}
return meta, archiveFile, nil
} | |
c3340 | {
msg := "expected backups.Metadata value from storage for %q, got %T"
return nil, errors.Errorf(msg, meta.ID(), meta)
}
result[i] = m
}
return result, nil
} | |
c3341 | errors.Trace(b.storage.Remove(id))
} | |
c3342 | &lumberjack.Logger{
Filename: logPath,
MaxSize: 300, // MB
MaxBackups: 2,
Compress: true,
}, nil
} | |
c3343 |
if err != nil {
return errors.Trace(err)
}
f.Close()
err = utils.ChownPath(path, "syslog")
return errors.Trace(err)
} | |
c3344 | base.NewFacadeCaller(caller, "MigrationMaster"),
newWatcher: newWatcher,
httpClientFactory: caller.HTTPClient,
}
} | |
c3345 | != nil {
return nil, result.Error
}
return c.newWatcher(c.caller.RawAPICaller(), result), nil
} | |
c3346 |
}
return c.caller.FacadeCall("SetPhase", args, nil)
} | |
c3347 |
Message: message,
}
return c.caller.FacadeCall("SetStatusMessage", args, nil)
} | |
c3348 | info.UUID,
Name: info.Name,
Owner: owner,
AgentVersion: info.AgentVersion,
ControllerAgentVersion: info.ControllerAgentVersion,
}, nil
} | |
c3349 | toolsInfo.URI
}
resources, err := convertResources(serialized.Resources)
if err != nil {
return empty, errors.Trace(err)
}
return migration.SerializedModel{
Bytes: serialized.Bytes,
Charms: serialized.Charms,
Tools: tools,
Resources: resources,
}, nil
} | |
c3350 | if err := httpClient.Get(uri, &resp); err != nil {
return nil, errors.Annotate(err, "unable to retrieve resource")
}
return resp.Body, nil
} | |
c3351 | common.StreamDebugLog(c.caller.RawAPICaller(), common.DebugLogParams{
Replay: true,
NoTail: true,
StartTime: start,
})
} | |
c3352 | {
case names.MachineTag, names.ApplicationTag:
return NewUpgraderAPI(st, resources, auth)
case names.UnitTag:
return NewUnitUpgraderAPI(st, resources, auth)
}
// Not a machine or unit.
return nil, common.ErrPerm
} | |
c3353 | ToolsGetter: common.NewToolsGetter(st, configGetter, st, urlGetter, getCanReadWrite),
ToolsSetter: common.NewToolsSetter(st, getCanReadWrite),
st: st,
m: model,
resources: resources,
authorizer: authorizer,
}, nil
} | |
c3354 | event
// in the Watch response. But NotifyWatchers
// have no state to transmit.
if _, ok := <-watch.Changes(); ok {
result.Results[i].NotifyWatcherId = u.resources.Register(watch)
err = nil
} else {
err = watcher.EnsureErr(watch)
}
}
result.Results[i].Error = common.ServerError(err)
}
... | |
c3355 | version.
//
// This ensures that state machine agents will upgrade
// first - once they have restarted and are running the
// new version other agents will start to see the new
// agent version.
if !isNewerVersion || u.entityIsManager(tag) {
results[i].Version = &agentVersion
} else {
logg... | |
c3356 | err := cfg.ValidateUnknownAttrs(configFields, configDefaults)
if err != nil {
return nil, errors.Trace(err)
}
validCfg, err := cfg.Apply(validated)
if err != nil {
return nil, errors.Trace(err)
}
// Build the config.
ecfg := newConfig(validCfg)
// Do final validation.
if err := ecfg.validate(); err != n... | |
c3357 | c.attrs[field].(string) == "" {
return errors.Errorf("%s: must not be empty", field)
}
}
return nil
} | |
c3358 | {
if attrs[field] != c.attrs[field] {
return errors.Errorf("%s: cannot change from %v to %v", field, c.attrs[field], attrs[field])
}
}
// Apply the updates.
c.Config = cfg
c.attrs = cfg.UnknownAttrs()
return nil
} | |
c3359 | info.Addrs {
_, err := network.ParseHostPort(addr)
if err != nil {
return errors.NotValidf("controller api address %q", addr)
}
}
return nil
} | |
c3360 | NewAPI(
&backendShim{ctx.State()},
precheckBackend,
migration.PoolShim(ctx.StatePool()),
ctx.Resources(),
ctx.Auth(),
ctx.Presence(),
)
} | |
c3361 | return "", errors.Trace(err)
}
return model.Name(), nil
} | |
c3362 | return names.UserTag{}, errors.Trace(err)
}
return model.Owner(), nil
} | |
c3363 | errors.Trace(err)
}
vers, ok := cfg.AgentVersion()
if !ok {
return version.Zero, errors.New("no agent version")
}
return vers, nil
} | |
c3364 | hostedModelConfig,
Constraints: args.ModelConstraints,
CloudName: args.ControllerCloud.Name,
CloudRegion: args.ControllerCloudRegion,
CloudCredential: cloudCredentialTag,
StorageProviderRegistry: args.StorageProviderRegistry,
EnvironVersion: provide... | |
c3365 | return nil, errors.Trace(err)
}
if err := mongo.Login(session, mongo.AdminUser, password); err != nil {
session.Close()
return nil, errors.Trace(err)
}
return session, nil
} | |
c3366 | {
return nil, errors.Annotate(err, "cannot create bootstrap machine in state")
}
if m.Id() != agent.BootstrapMachineId {
return nil, errors.Errorf("bootstrap machine expected id 0, got %q", m.Id())
}
// Read the machine agent's password and change it to
// a new password (other agents will change their passwo... | |
c3367 | this should never happen because we have already checked in k8s controller bootstrap stacker.
return errors.NotProvisionedf("k8s controller service %q address", svc.Id)
}
svcId := controllerUUID
logger.Infof("creating cloud service for k8s controller %q", svcId)
cloudSvc, err := st.SaveCloudService(state.SaveClo... | |
c3368 | return bytes, errors.Trace(err)
default:
return nil, errors.Errorf("cannot encode userdata for OS %q", os)
}
} | |
c3369 | prefix := filepath.Join(dir, "local.")
return preallocFiles(prefix, sizes...)
} | |
c3370 |
return smallOplogSizeMB, nil
}
avail, err := availSpace(dir)
if err != nil {
return -1, err
}
if avail < smallOplogBoundary {
return smallOplogSizeMB, nil
} else {
return regularOplogSizeMB, nil
}
} | |
c3371 |
if len(lines) < 2 {
logger.Errorf("unexpected output: %q", out)
return -1, fmt.Errorf("could not determine available space on %q", dir)
}
fields := strings.Fields(lines[1])
if len(fields) < 4 {
logger.Errorf("unexpected output: %q", out)
return -1, fmt.Errorf("could not determine available space on %q", di... | |
c3372 | logger.Debugf("cleaning up after preallocation failure: %v", err)
for _, filename := range createdFiles {
if err := os.Remove(filename); err != nil {
logger.Errorf("failed to remove %q: %v", filename, err)
}
}
}
return err
} | |
c3373 | sizes []int
remainder := totalSize % maxChunkSize
if remainder > 0 {
aligned := remainder + preallocAlign - 1
aligned = aligned - (aligned % preallocAlign)
sizes = []int{aligned}
}
for i := 0; i < totalSize/maxChunkSize; i++ {
sizes = append(sizes, maxChunkSize)
}
return sizes
} | |
c3374 |
defer f.Close()
for written := 0; written < size; {
n := len(zeroes)
if n > (size - written) {
n = size - written
}
n, err := f.Write(zeroes[:n])
if err != nil {
return true, fmt.Errorf("failed to write to mongo prealloc file %q: %v", filename, err)
}
written += n
}
return true, nil
} | |
c3375 | {
mock := &MockExtensionsV1beta1Interface{ctrl: ctrl}
mock.recorder = &MockExtensionsV1beta1InterfaceMockRecorder{mock}
return mock
} | |
c3376 | reflect.TypeOf((*MockExtensionsV1beta1Interface)(nil).DaemonSets), arg0)
} | |
c3377 | {
ret := m.ctrl.Call(m, "Ingresses", arg0)
ret0, _ := ret[0].(v1beta10.IngressInterface)
return ret0
} | |
c3378 | {
ret := m.ctrl.Call(m, "PodSecurityPolicies")
ret0, _ := ret[0].(v1beta10.PodSecurityPolicyInterface)
return ret0
} | |
c3379 | reflect.TypeOf((*MockExtensionsV1beta1Interface)(nil).PodSecurityPolicies))
} | |
c3380 | {
ret := m.ctrl.Call(m, "Scales", arg0)
ret0, _ := ret[0].(v1beta10.ScaleInterface)
return ret0
} | |
c3381 | ctrl}
mock.recorder = &MockIngressInterfaceMockRecorder{mock}
return mock
} | |
c3382 | "UpdateStatus", reflect.TypeOf((*MockIngressInterface)(nil).UpdateStatus), arg0)
} | |
c3383 | return &Client{ClientFacade: clientFacade, facade: facadeCaller}
} | |
c3384 | machineManagerFacade)
return ConstructClient(frontend, backend)
} | |
c3385 | len(results.Machines) != len(machineParams) {
return nil, errors.Errorf("expected %d result, got %d", len(machineParams), len(results.Machines))
}
return results.Machines, err
} | |
c3386 | := params.ErrorResult{}
if err := client.facade.FacadeCall("UpgradeSeriesPrepare", args, &result); err != nil {
return errors.Trace(err)
}
err := result.Error
if err != nil {
return common.RestoreError(err)
}
return nil
} | |
c3387 | := new(params.ErrorResult)
err := client.facade.FacadeCall("UpgradeSeriesComplete", args, result)
if err != nil {
return errors.Trace(err)
}
if result.Error != nil {
return result.Error
}
return nil
} | |
c3388 | if err != nil {
return nil, errors.Trace(err)
}
if len(results.Results) != 1 {
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
return result.Result, nil
} | |
c3389 | facadeCaller,
APIAddresser: common.NewAPIAddresser(facadeCaller),
}
} | |
c3390 | Status: status.String(),
Info: info,
Data: data,
}},
}
if err := c.facade.FacadeCall("SetStatus", args, &result); err != nil {
return errors.Trace(err)
}
return result.OneError()
} | |
c3391 | %d", n)
}
if err := results.Results[0].Error; err != nil {
return nil, false, "", 0, errors.Trace(err)
}
result := results.Results[0].Result
curl, err := charm.ParseURL(result.URL)
if err != nil {
return nil, false, "", 0, errors.Trace(err)
}
return curl, result.ForceUpgrade, result.SHA256, result.CharmMod... | |
c3392 | err := c.facade.FacadeCall("WatchUnits", args, &results); err != nil {
return nil, err
}
if n := len(results.Results); n != 1 {
return nil, errors.Errorf("expected 1 result, got %d", n)
}
if err := results.Results[0].Error; err != nil {
return nil, errors.Trace(err)
}
w := apiwatcher.NewStringsWatcher(c.fa... | |
c3393 |
}
err := c.facade.FacadeCall("Remove", args, &result)
if err != nil {
return err
}
return result.OneError()
} | |
c3394 | Tools: ¶ms.Version{v},
}},
}
err := c.facade.FacadeCall("SetTools", args, &results)
if err != nil {
return errors.Trace(err)
}
return results.OneError()
} | |
c3395 | {
return names.NewVolumeTag(v.doc.Name)
} | |
c3396 |
return names.StorageTag{}, errors.NewNotAssigned(nil, msg)
}
return names.NewStorageTag(v.doc.StorageId), nil
} | |
c3397 | errors.NotProvisionedf("volume %q", v.doc.Name)
}
return *v.doc.Info, nil
} | |
c3398 | return VolumeParams{}, false
}
return *v.doc.Params, true
} | |
c3399 | {
return names.NewMachineTag(v.doc.Machine)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.