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(applications) {
return nil, errors.Errorf("expected %d results, got %d", len(applications), resultsLen)
}
return out.Results, nil
}
| |
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,
state.CallContext(st),
)
}
| |
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.NewBlockChecker(st),
authorizer: authorizer,
toolsFinder: common.NewToolsFinder(configGetter, st, urlGetter),
apiUser: apiUser,
isAdmin: isAdmin,
model: m,
callContext: callCtx,
}, nil
}
| |
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, maxWait))
}
for i, arg := range args.Models {
tag, err := names.ParseModelTag(arg.ModelTag)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
if err := destroyModel(tag.Id(), arg.DestroyStorage, arg.Force, arg.MaxWait); err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
}
return results, nil
}
| |
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"))
continue
}
result.Results[i].Error = common.ServerError(
changeModelAccess(m.state, modelTag, m.apiUser, targetUserTag, arg.Action, modelAccess, m.isAdmin))
}
return result, nil
}
| |
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 access")
case params.RevokeModelAccess:
switch access {
case permission.ReadAccess:
// Revoking read access removes all access.
err := st.RemoveUserAccess(targetUserTag, modelTag)
return errors.Annotate(err, "could not revoke model access")
case permission.WriteAccess:
// Revoking write access sets read-only.
modelUser, err := st.UserAccess(targetUserTag, modelTag)
if err != nil {
return errors.Annotate(err, "could not look up model access for user")
}
_, err = st.SetUserAccess(modelUser.UserTag, modelUser.Object, permission.ReadAccess)
return errors.Annotate(err, "could not set model access to read-only")
case permission.AdminAccess:
// Revoking admin access sets read-write.
modelUser, err := st.UserAccess(targetUserTag, modelTag)
if err != nil {
return errors.Annotate(err, "could not look up model access for user")
}
_, err = st.SetUserAccess(modelUser.UserTag, modelUser.Object, permission.WriteAccess)
return errors.Annotate(err, "could not set model access to read-write")
default:
return errors.Errorf("don't know how to revoke %q access", access)
}
default:
return errors.Errorf("unknown action %q", action)
}
}
| |
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("model %v already uses credential %v", modelTag.Id(), credentialTag.Id())
}
return nil
}
results := make([]params.ErrorResult, len(args.Models))
for i, arg := range args.Models {
if err := replaceModelCredential(arg); err != nil {
results[i].Error = common.ServerError(err)
}
}
return params.ErrorResults{results}, nil
}
| |
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)
}
return result, nil
}
| |
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 {
logger.Debugf("desired version is %s, but current version is %s and agent is not a manager node", agentVersion, jujuversion.Current)
results[i].Version = &jujuversion.Current
}
err = nil
}
results[i].Error = common.ServerError(err)
}
return params.VersionResults{Results: results}, nil
}
| |
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 != nil {
return nil, errors.Trace(err)
}
return ecfg, nil
}
| |
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: provider.Version(),
})
if err != nil {
return errors.Annotate(err, "creating hosted model")
}
defer hostedModelState.Close()
if err := model.AutoConfigureContainerNetworking(hostedModelEnv); err != nil {
return errors.Annotate(err, "autoconfiguring container networking")
}
// TODO(wpk) 2017-05-24 Copy subnets/spaces from controller model
if err = hostedModelState.ReloadSpaces(hostedModelEnv); err != nil {
if errors.IsNotSupported(err) {
logger.Debugf("Not performing spaces load on a non-networking environment")
} else {
return errors.Annotate(err, "fetching hosted model spaces")
}
}
return nil
}
| |
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 password
// via the API connection).
logger.Debugf("create new random password for machine %v", m.Id())
newPassword, err := utils.RandomPassword()
if err != nil {
return nil, err
}
if err := m.SetPassword(newPassword); err != nil {
return nil, err
}
if err := m.SetMongoPassword(newPassword); err != nil {
return nil, err
}
c.SetPassword(newPassword)
return m, nil
}
| |
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.SaveCloudServiceArgs{
Id: svcId,
ProviderId: svc.Id,
Addresses: svc.Addresses,
})
logger.Debugf("created cloud service %v for controller", cloudSvc)
return errors.Trace(err)
}
| |
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", dir)
}
kilobytes, err := strconv.Atoi(fields[3])
if err != nil {
return -1, err
}
return float64(kilobytes) / 1024, err
}
| |
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.CharmModifiedVersion, nil
}
| |
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.facade.RawAPICaller(), results.Results[0])
return w, nil
}
| |
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.