_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q3300
|
UnsetApplicationConfig
|
train
|
func (c *Client) UnsetApplicationConfig(branchName, application string, options []string) error {
if c.BestAPIVersion() < 6 {
return errors.NotSupportedf("UnsetApplicationConfig not supported by this version of Juju")
}
args := params.ApplicationConfigUnsetArgs{
Args: []params.ApplicationUnset{{
ApplicationName: application,
BranchName: branchName,
Options: options,
}},
}
var results params.ErrorResults
err := c.facade.FacadeCall("UnsetApplicationsConfig", args, &results)
if err != nil {
return errors.Trace(err)
}
return results.OneError()
}
|
go
|
{
"resource": ""
}
|
q3301
|
ResolveUnitErrors
|
train
|
func (c *Client) ResolveUnitErrors(units []string, all, retry bool) error {
if len(units) > 0 && all {
return errors.NotSupportedf("specifying units with all=true")
}
if len(units) != set.NewStrings(units...).Size() {
return errors.New("duplicate unit specified")
}
args := params.UnitsResolved{
All: all,
Retry: retry,
}
if !all {
entities := make([]params.Entity, len(units))
for i, unit := range units {
if !names.IsValidUnit(unit) {
return errors.NotValidf("unit name %q", 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())
}
|
go
|
{
"resource": ""
}
|
q3302
|
ApplicationsInfo
|
train
|
func (c *Client) ApplicationsInfo(applications []names.ApplicationTag) ([]params.ApplicationInfoResult, error) {
if apiVersion := c.BestAPIVersion(); apiVersion < 9 {
return nil, errors.NotSupportedf("ApplicationsInfo for Application facade v%v", apiVersion)
}
all := make([]params.Entity, len(applications))
for 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
}
|
go
|
{
"resource": ""
}
|
q3303
|
NewFacadeV7
|
train
|
func NewFacadeV7(ctx facade.Context) (*ModelManagerAPI, error) {
st := ctx.State()
pool := ctx.StatePool()
ctlrSt := pool.SystemState()
auth := ctx.Auth()
var err error
model, err := st.Model()
if err != nil {
return nil, errors.Trace(err)
}
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),
)
}
|
go
|
{
"resource": ""
}
|
q3304
|
NewFacadeV6
|
train
|
func NewFacadeV6(ctx facade.Context) (*ModelManagerAPIV6, error) {
v7, err := NewFacadeV7(ctx)
if err != nil {
return nil, err
}
return &ModelManagerAPIV6{v7}, nil
}
|
go
|
{
"resource": ""
}
|
q3305
|
NewFacadeV4
|
train
|
func NewFacadeV4(ctx facade.Context) (*ModelManagerAPIV4, error) {
v5, err := NewFacadeV5(ctx)
if err != nil {
return nil, err
}
return &ModelManagerAPIV4{v5}, nil
}
|
go
|
{
"resource": ""
}
|
q3306
|
NewModelManagerAPI
|
train
|
func NewModelManagerAPI(
st common.ModelManagerBackend,
ctlrSt common.ModelManagerBackend,
configGetter environs.EnvironConfigGetter,
getBroker newCaasBrokerFunc,
authorizer facade.Authorizer,
m common.Model,
callCtx context.ProviderCallContext,
) (*ModelManagerAPI, error) {
if !authorizer.AuthClient() {
return nil, common.ErrPerm
}
// Since we know this is a user tag (because AuthClient is true),
// we just do the type assertion to the UserTag.
apiUser, _ := authorizer.GetAuthTag().(names.UserTag)
// Pretty much all of the user manager methods have special casing for admin
// users, so look once when we start and remember if the user is an admin.
isAdmin, err := authorizer.HasPermission(permission.SuperuserAccess, st.ControllerTag())
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
}
|
go
|
{
"resource": ""
}
|
q3307
|
authCheck
|
train
|
func (m *ModelManagerAPI) authCheck(user names.UserTag) error {
if m.isAdmin {
logger.Tracef("%q is a controller admin", m.apiUser.Id())
return nil
}
// We can't just compare the UserTags themselves as the provider part
// may be unset, and gets replaced with 'local'. We must compare against
// the Canonical value of the user tag.
if m.apiUser == user {
return nil
}
return common.ErrPerm
}
|
go
|
{
"resource": ""
}
|
q3308
|
DumpModelsDB
|
train
|
func (m *ModelManagerAPI) DumpModelsDB(args params.Entities) params.MapResults {
results := params.MapResults{
Results: make([]params.MapResult, len(args.Entities)),
}
for i, entity := range args.Entities {
dumped, err := m.dumpModelDB(entity)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].Result = dumped
}
return results
}
|
go
|
{
"resource": ""
}
|
q3309
|
DestroyModels
|
train
|
func (m *ModelManagerAPIV3) DestroyModels(args params.Entities) (params.ErrorResults, error) {
// v3 DestroyModels is implemented in terms of v4:
// storage is unconditionally destroyed, as was the
// old behaviour.
destroyStorage := true
v4Args := params.DestroyModelsParams{
Models: make([]params.DestroyModelParams, len(args.Entities)),
}
for i, arg := range args.Entities {
v4Args.Models[i] = params.DestroyModelParams{
ModelTag: arg.Tag,
DestroyStorage: &destroyStorage,
}
}
return m.ModelManagerAPI.DestroyModels(v4Args)
}
|
go
|
{
"resource": ""
}
|
q3310
|
DestroyModels
|
train
|
func (m *ModelManagerAPI) DestroyModels(args params.DestroyModelsParams) (params.ErrorResults, error) {
results := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Models)),
}
destroyModel := func(modelUUID string, destroyStorage, force *bool, maxWait *time.Duration) error {
st, releaseSt, err := m.state.GetBackend(modelUUID)
if err != nil {
return errors.Trace(err)
}
defer releaseSt()
model, err := st.Model()
if err != nil {
return 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
}
|
go
|
{
"resource": ""
}
|
q3311
|
ModelInfo
|
train
|
func (m *ModelManagerAPI) ModelInfo(args params.Entities) (params.ModelInfoResults, error) {
results := params.ModelInfoResults{
Results: make([]params.ModelInfoResult, len(args.Entities)),
}
getModelInfo := func(arg params.Entity) (params.ModelInfo, error) {
tag, err := names.ParseModelTag(arg.Tag)
if err != nil {
return params.ModelInfo{}, errors.Trace(err)
}
return m.getModelInfo(tag)
}
for i, arg := 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
}
|
go
|
{
"resource": ""
}
|
q3312
|
ModifyModelAccess
|
train
|
func (m *ModelManagerAPI) ModifyModelAccess(args params.ModifyModelAccessRequest) (result params.ErrorResults, _ error) {
result = params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Changes)),
}
canModifyController, err := m.authorizer.HasPermission(permission.SuperuserAccess, m.state.ControllerTag())
if err != nil {
return result, errors.Trace(err)
}
if len(args.Changes) == 0 {
return result, nil
}
for i, arg := range args.Changes {
modelAccess := permission.Access(arg.Access)
if err := permission.ValidateModelAccess(modelAccess); err != nil {
err = errors.Annotate(err, "could not modify model access")
result.Results[i].Error = common.ServerError(err)
continue
}
modelTag, err := names.ParseModelTag(arg.ModelTag)
if err != nil {
result.Results[i].Error = common.ServerError(errors.Annotate(err, "could not modify model access"))
continue
}
canModifyModel, err := m.authorizer.HasPermission(permission.AdminAccess, modelTag)
if err != nil {
return result, errors.Trace(err)
}
canModify := 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
}
|
go
|
{
"resource": ""
}
|
q3313
|
changeModelAccess
|
train
|
func changeModelAccess(accessor common.ModelManagerBackend, modelTag names.ModelTag, apiUser, targetUserTag names.UserTag, action params.ModelAction, access permission.Access, userIsAdmin bool) error {
st, release, err := accessor.GetBackend(modelTag.Id())
if err != nil {
return errors.Annotate(err, "could not lookup model")
}
defer release()
if err := userAuthorizedToChangeAccess(st, userIsAdmin, apiUser); err != nil {
return errors.Trace(err)
}
model, err := st.Model()
if err != nil {
return errors.Trace(err)
}
switch action {
case params.GrantModelAccess:
_, err = model.AddUser(state.UserAccessSpec{User: targetUserTag, CreatedBy: apiUser, Access: access})
if errors.IsAlreadyExists(err) {
modelUser, err := st.UserAccess(targetUserTag, modelTag)
if errors.IsNotFound(err) {
// Conflicts with prior check, must be inconsistent state.
err = txn.ErrExcessiveContention
}
if err != nil {
return errors.Annotate(err, "could not look up model access for user")
}
// Only set access if greater access is being granted.
if modelUser.Access.EqualOrGreaterModelAccessThan(access) {
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)
}
}
|
go
|
{
"resource": ""
}
|
q3314
|
ModelDefaultsForClouds
|
train
|
func (m *ModelManagerAPI) ModelDefaultsForClouds(args params.Entities) (params.ModelDefaultsResults, error) {
result := params.ModelDefaultsResults{}
if !m.isAdmin {
return result, common.ErrPerm
}
result.Results = make([]params.ModelDefaultsResult, len(args.Entities))
for i, entity := range args.Entities {
cloudTag, err := names.ParseCloudTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
result.Results[i] = m.modelDefaults(cloudTag.Id())
}
return result, nil
}
|
go
|
{
"resource": ""
}
|
q3315
|
ModelDefaults
|
train
|
func (m *ModelManagerAPIV5) ModelDefaults() (params.ModelDefaultsResult, error) {
result := params.ModelDefaultsResult{}
if !m.isAdmin {
return result, common.ErrPerm
}
return m.modelDefaults(m.model.Cloud()), nil
}
|
go
|
{
"resource": ""
}
|
q3316
|
SetModelDefaults
|
train
|
func (m *ModelManagerAPI) SetModelDefaults(args params.SetModelDefaults) (params.ErrorResults, error) {
results := params.ErrorResults{Results: make([]params.ErrorResult, len(args.Config))}
if err := m.check.ChangeAllowed(); err != nil {
return results, errors.Trace(err)
}
for i, arg := range args.Config {
results.Results[i].Error = common.ServerError(
m.setModelDefaults(arg),
)
}
return results, nil
}
|
go
|
{
"resource": ""
}
|
q3317
|
UnsetModelDefaults
|
train
|
func (m *ModelManagerAPI) UnsetModelDefaults(args params.UnsetModelDefaults) (params.ErrorResults, error) {
results := params.ErrorResults{Results: make([]params.ErrorResult, len(args.Keys))}
if !m.isAdmin {
return results, common.ErrPerm
}
if err := m.check.ChangeAllowed(); err != nil {
return results, errors.Trace(err)
}
for i, arg := range args.Keys {
var rspec *environs.CloudRegionSpec
if arg.CloudTag != "" {
spec, err := m.makeRegionSpec(arg.CloudTag, arg.CloudRegion)
if 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
}
|
go
|
{
"resource": ""
}
|
q3318
|
makeRegionSpec
|
train
|
func (m *ModelManagerAPI) makeRegionSpec(cloudTag, r string) (*environs.CloudRegionSpec, error) {
cTag, err := names.ParseCloudTag(cloudTag)
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
}
|
go
|
{
"resource": ""
}
|
q3319
|
ChangeModelCredential
|
train
|
func (m *ModelManagerAPI) ChangeModelCredential(args params.ChangeModelCredentialsParams) (params.ErrorResults, error) {
if err := m.check.ChangeAllowed(); err != nil {
return params.ErrorResults{}, errors.Trace(err)
}
controllerAdmin, err := m.authorizer.HasPermission(permission.SuperuserAccess, m.state.ControllerTag())
if err != nil {
return params.ErrorResults{}, errors.Trace(err)
}
// Only controller or model admin can change cloud credential on a model.
checkModelAccess := func(tag names.ModelTag) error {
if controllerAdmin {
return nil
}
modelAdmin, err := m.authorizer.HasPermission(permission.AdminAccess, tag)
if err != nil {
return errors.Trace(err)
}
if modelAdmin {
return nil
}
return common.ErrPerm
}
replaceModelCredential := func(arg params.ChangeModelCredentialParams) error {
modelTag, err := names.ParseModelTag(arg.ModelTag)
if err != nil {
return errors.Trace(err)
}
if err := checkModelAccess(modelTag); err != nil {
return errors.Trace(err)
}
credentialTag, err := names.ParseCloudCredentialTag(arg.CloudCredentialTag)
if err != 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
}
|
go
|
{
"resource": ""
}
|
q3320
|
UnitStatus
|
train
|
func (u *Unit) UnitStatus() (params.StatusResult, error) {
var results params.StatusResults
args := params.Entities{
Entities: []params.Entity{
{Tag: u.tag.String()},
},
}
err := u.st.facade.FacadeCall("UnitStatus", args, &results)
if err != nil {
return params.StatusResult{}, errors.Trace(err)
}
if len(results.Results) != 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
}
|
go
|
{
"resource": ""
}
|
q3321
|
AddMetrics
|
train
|
func (u *Unit) AddMetrics(metrics []params.Metric) error {
var result params.ErrorResults
args := params.MetricsParams{
Metrics: []params.MetricsParam{{
Tag: u.tag.String(),
Metrics: metrics,
}},
}
err := u.st.facade.FacadeCall("AddMetrics", args, &result)
if err != nil {
return errors.Annotate(err, "unable to add metric")
}
return result.OneError()
}
|
go
|
{
"resource": ""
}
|
q3322
|
AddMetricBatches
|
train
|
func (u *Unit) AddMetricBatches(batches []params.MetricBatch) (map[string]error, error) {
p := params.MetricBatchParams{
Batches: make([]params.MetricBatchParam, len(batches)),
}
batchResults := make(map[string]error, len(batches))
for i, batch := range batches {
p.Batches[i].Tag = u.tag.String()
p.Batches[i].Batch = batch
batchResults[batch.UUID] = nil
}
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
}
|
go
|
{
"resource": ""
}
|
q3323
|
Watch
|
train
|
func (u *Unit) Watch() (watcher.NotifyWatcher, error) {
return common.Watch(u.st.facade, "Watch", u.tag)
}
|
go
|
{
"resource": ""
}
|
q3324
|
Application
|
train
|
func (u *Unit) Application() (*Application, error) {
application := &Application{
st: u.st,
tag: u.ApplicationTag(),
}
// Call 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
}
|
go
|
{
"resource": ""
}
|
q3325
|
ApplicationName
|
train
|
func (u *Unit) ApplicationName() string {
application, err := names.UnitApplication(u.Name())
if err != nil {
panic(err)
}
return application
}
|
go
|
{
"resource": ""
}
|
q3326
|
DestroyAllSubordinates
|
train
|
func (u *Unit) DestroyAllSubordinates() error {
var result params.ErrorResults
args := params.Entities{
Entities: []params.Entity{{Tag: u.tag.String()}},
}
err := u.st.facade.FacadeCall("DestroyAllSubordinates", args, &result)
if err != nil {
return err
}
return result.OneError()
}
|
go
|
{
"resource": ""
}
|
q3327
|
HasSubordinates
|
train
|
func (u *Unit) HasSubordinates() (bool, error) {
var results params.BoolResults
args := params.Entities{
Entities: []params.Entity{{Tag: u.tag.String()}},
}
err := u.st.facade.FacadeCall("HasSubordinates", args, &results)
if err != nil {
return false, err
}
if len(results.Results) != 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
}
|
go
|
{
"resource": ""
}
|
q3328
|
ClosePorts
|
train
|
func (u *Unit) ClosePorts(protocol string, fromPort, toPort int) error {
var result params.ErrorResults
args := params.EntitiesPortRanges{
Entities: []params.EntityPortRange{{
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()
}
|
go
|
{
"resource": ""
}
|
q3329
|
WatchActionNotifications
|
train
|
func (u *Unit) WatchActionNotifications() (watcher.StringsWatcher, error) {
var results params.StringsWatchResults
args := params.Entities{
Entities: []params.Entity{{Tag: u.tag.String()}},
}
err := u.st.facade.FacadeCall("WatchActionNotifications", args, &results)
if err != nil {
return nil, 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
}
w := apiwatcher.NewStringsWatcher(u.st.facade.RawAPICaller(), result)
return w, nil
}
|
go
|
{
"resource": ""
}
|
q3330
|
UpgradeSeriesStatus
|
train
|
func (u *Unit) UpgradeSeriesStatus() (model.UpgradeSeriesStatus, error) {
res, err := u.st.UpgradeSeriesUnitStatus()
if err != nil {
return "", errors.Trace(err)
}
if len(res) != 1 {
return "", errors.Errorf("expected 1 result, got %d", len(res))
}
return res[0], nil
}
|
go
|
{
"resource": ""
}
|
q3331
|
SetUpgradeSeriesStatus
|
train
|
func (u *Unit) SetUpgradeSeriesStatus(status model.UpgradeSeriesStatus, reason string) error {
return u.st.SetUpgradeSeriesUnitStatus(status, reason)
}
|
go
|
{
"resource": ""
}
|
q3332
|
RequestReboot
|
train
|
func (u *Unit) RequestReboot() error {
machineId, err := u.AssignedMachine()
if err != nil {
return err
}
var result params.ErrorResults
args := params.Entities{
Entities: []params.Entity{{Tag: machineId.String()}},
}
err = u.st.facade.FacadeCall("RequestReboot", args, &result)
if err != nil {
return err
}
return result.OneError()
}
|
go
|
{
"resource": ""
}
|
q3333
|
RelationsStatus
|
train
|
func (u *Unit) RelationsStatus() ([]RelationStatus, error) {
args := params.Entities{
Entities: []params.Entity{{Tag: u.tag.String()}},
}
var results params.RelationUnitStatusResults
err := u.st.facade.FacadeCall("RelationsStatus", args, &results)
if err != nil {
return nil, 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
}
var statusResult []RelationStatus
for _, result := range result.RelationResults {
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
}
|
go
|
{
"resource": ""
}
|
q3334
|
WatchStorage
|
train
|
func (u *Unit) WatchStorage() (watcher.StringsWatcher, error) {
return u.st.WatchUnitStorageAttachments(u.tag)
}
|
go
|
{
"resource": ""
}
|
q3335
|
AddStorage
|
train
|
func (u *Unit) AddStorage(constraints map[string][]params.StorageConstraints) error {
if u.st.facade.BestAPIVersion() < 2 {
return errors.NotImplementedf("AddStorage() (need V2+)")
}
all := make([]params.StorageAddParams, 0, len(constraints))
for storage, cons := range constraints {
for _, one := range cons {
all = append(all, params.StorageAddParams{
UnitTag: u.Tag().String(),
StorageName: storage,
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()
}
|
go
|
{
"resource": ""
}
|
q3336
|
StoreArchive
|
train
|
func StoreArchive(stor filestorage.FileStorage, meta *Metadata, file io.Reader) error {
id, err := stor.Add(meta, file)
if err != 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
}
|
go
|
{
"resource": ""
}
|
q3337
|
NewBackups
|
train
|
func NewBackups(stor filestorage.FileStorage) Backups {
b := backups{
storage: stor,
}
return &b
}
|
go
|
{
"resource": ""
}
|
q3338
|
Add
|
train
|
func (b *backups) Add(archive io.Reader, meta *Metadata) (string, error) {
// Store the archive.
err := storeArchive(b.storage, meta, archive)
if err != nil {
return "", errors.Annotate(err, "while storing backup archive")
}
return meta.ID(), nil
}
|
go
|
{
"resource": ""
}
|
q3339
|
Get
|
train
|
func (b *backups) Get(id string) (*Metadata, io.ReadCloser, error) {
if strings.Contains(id, TempFilename) {
return b.getArchiveFromFilename(id)
}
rawmeta, archiveFile, err := b.storage.Get(id)
if err != nil {
return nil, nil, errors.Trace(err)
}
meta, ok := rawmeta.(*Metadata)
if !ok {
return nil, nil, errors.New("did not get a backups.Metadata value from storage")
}
return meta, archiveFile, nil
}
|
go
|
{
"resource": ""
}
|
q3340
|
List
|
train
|
func (b *backups) List() ([]*Metadata, error) {
metaList, err := b.storage.List()
if err != nil {
return nil, errors.Trace(err)
}
result := make([]*Metadata, len(metaList))
for i, meta := range metaList {
m, ok := meta.(*Metadata)
if !ok {
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
}
|
go
|
{
"resource": ""
}
|
q3341
|
Remove
|
train
|
func (b *backups) Remove(id string) error {
return errors.Trace(b.storage.Remove(id))
}
|
go
|
{
"resource": ""
}
|
q3342
|
NewFileWriter
|
train
|
func NewFileWriter(logPath string) (io.WriteCloser, error) {
if err := primeLogFile(logPath); err != nil {
// This isn't a fatal error so log and continue if priming fails.
logger.Warningf("Unable to prime %s (proceeding anyway): %v", logPath, err)
}
return &lumberjack.Logger{
Filename: logPath,
MaxSize: 300, // MB
MaxBackups: 2,
Compress: true,
}, nil
}
|
go
|
{
"resource": ""
}
|
q3343
|
primeLogFile
|
train
|
func primeLogFile(path string) error {
f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0600)
if err != nil {
return errors.Trace(err)
}
f.Close()
err = utils.ChownPath(path, "syslog")
return errors.Trace(err)
}
|
go
|
{
"resource": ""
}
|
q3344
|
NewClient
|
train
|
func NewClient(caller base.APICaller, newWatcher NewWatcherFunc) *Client {
return &Client{
caller: base.NewFacadeCaller(caller, "MigrationMaster"),
newWatcher: newWatcher,
httpClientFactory: caller.HTTPClient,
}
}
|
go
|
{
"resource": ""
}
|
q3345
|
Watch
|
train
|
func (c *Client) Watch() (watcher.NotifyWatcher, error) {
var result params.NotifyWatchResult
err := c.caller.FacadeCall("Watch", nil, &result)
if err != nil {
return nil, errors.Trace(err)
}
if result.Error != nil {
return nil, result.Error
}
return c.newWatcher(c.caller.RawAPICaller(), result), nil
}
|
go
|
{
"resource": ""
}
|
q3346
|
SetPhase
|
train
|
func (c *Client) SetPhase(phase migration.Phase) error {
args := params.SetMigrationPhaseArgs{
Phase: phase.String(),
}
return c.caller.FacadeCall("SetPhase", args, nil)
}
|
go
|
{
"resource": ""
}
|
q3347
|
SetStatusMessage
|
train
|
func (c *Client) SetStatusMessage(message string) error {
args := params.SetMigrationStatusMessageArgs{
Message: message,
}
return c.caller.FacadeCall("SetStatusMessage", args, nil)
}
|
go
|
{
"resource": ""
}
|
q3348
|
ModelInfo
|
train
|
func (c *Client) ModelInfo() (migration.ModelInfo, error) {
var info params.MigrationModelInfo
err := c.caller.FacadeCall("ModelInfo", nil, &info)
if err != nil {
return migration.ModelInfo{}, errors.Trace(err)
}
owner, err := names.ParseUserTag(info.OwnerTag)
if err != nil {
return migration.ModelInfo{}, errors.Trace(err)
}
return migration.ModelInfo{
UUID: info.UUID,
Name: info.Name,
Owner: owner,
AgentVersion: info.AgentVersion,
ControllerAgentVersion: info.ControllerAgentVersion,
}, nil
}
|
go
|
{
"resource": ""
}
|
q3349
|
Export
|
train
|
func (c *Client) Export() (migration.SerializedModel, error) {
var empty migration.SerializedModel
var serialized params.SerializedModel
err := c.caller.FacadeCall("Export", nil, &serialized)
if err != nil {
return empty, errors.Trace(err)
}
// Convert tools info to output map.
tools := make(map[version.Binary]string)
for _, toolsInfo := range serialized.Tools {
v, err := version.ParseBinary(toolsInfo.Version)
if err != nil {
return migration.SerializedModel{}, errors.Annotate(err, "error parsing agent binary version")
}
tools[v] = 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
}
|
go
|
{
"resource": ""
}
|
q3350
|
OpenResource
|
train
|
func (c *Client) OpenResource(application, name string) (io.ReadCloser, error) {
httpClient, err := c.httpClientFactory()
if err != nil {
return nil, errors.Annotate(err, "unable to create HTTP client")
}
uri := fmt.Sprintf("/applications/%s/resources/%s", application, name)
var resp *http.Response
if err := httpClient.Get(uri, &resp); err != nil {
return nil, errors.Annotate(err, "unable to retrieve resource")
}
return resp.Body, nil
}
|
go
|
{
"resource": ""
}
|
q3351
|
StreamModelLog
|
train
|
func (c *Client) StreamModelLog(start time.Time) (<-chan common.LogMessage, error) {
return common.StreamDebugLog(c.caller.RawAPICaller(), common.DebugLogParams{
Replay: true,
NoTail: true,
StartTime: start,
})
}
|
go
|
{
"resource": ""
}
|
q3352
|
NewUpgraderFacade
|
train
|
func NewUpgraderFacade(st *state.State, resources facade.Resources, auth facade.Authorizer) (Upgrader, error) {
// The type of upgrader we return depends on who is asking.
// Machines get an UpgraderAPI, units get a UnitUpgraderAPI.
// This is tested in the api/upgrader package since there
// are currently no direct srvRoot tests.
// TODO(dfc) this is redundant
tag, err := names.ParseTag(auth.GetAuthTag().String())
if err != nil {
return nil, common.ErrPerm
}
switch tag.(type) {
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
}
|
go
|
{
"resource": ""
}
|
q3353
|
NewUpgraderAPI
|
train
|
func NewUpgraderAPI(
st *state.State,
resources facade.Resources,
authorizer facade.Authorizer,
) (*UpgraderAPI, error) {
if !authorizer.AuthMachineAgent() && !authorizer.AuthApplicationAgent() {
return nil, common.ErrPerm
}
getCanReadWrite := func() (common.AuthFunc, error) {
return authorizer.AuthOwner, nil
}
model, err := st.Model()
if err != nil {
return nil, err
}
urlGetter := common.NewToolsURLGetter(model.UUID(), st)
configGetter := stateenvirons.EnvironConfigGetter{State: st, Model: model}
return &UpgraderAPI{
ToolsGetter: common.NewToolsGetter(st, configGetter, st, urlGetter, getCanReadWrite),
ToolsSetter: common.NewToolsSetter(st, getCanReadWrite),
st: st,
m: model,
resources: resources,
authorizer: authorizer,
}, nil
}
|
go
|
{
"resource": ""
}
|
q3354
|
WatchAPIVersion
|
train
|
func (u *UpgraderAPI) WatchAPIVersion(args params.Entities) (params.NotifyWatchResults, error) {
result := params.NotifyWatchResults{
Results: make([]params.NotifyWatchResult, len(args.Entities)),
}
for i, agent := range args.Entities {
tag, err := names.ParseTag(agent.Tag)
if err != nil {
return params.NotifyWatchResults{}, errors.Trace(err)
}
err = common.ErrPerm
if u.authorizer.AuthOwner(tag) {
watch := u.m.WatchForModelConfigChanges()
// Consume the initial event. Technically, API
// calls to Watch 'transmit' the initial 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
}
|
go
|
{
"resource": ""
}
|
q3355
|
DesiredVersion
|
train
|
func (u *UpgraderAPI) DesiredVersion(args params.Entities) (params.VersionResults, error) {
results := make([]params.VersionResult, len(args.Entities))
if len(args.Entities) == 0 {
return params.VersionResults{}, nil
}
agentVersion, _, err := u.getGlobalAgentVersion()
if err != nil {
return params.VersionResults{}, common.ServerError(err)
}
// Is the desired version greater than the current API server version?
isNewerVersion := agentVersion.Compare(jujuversion.Current) > 0
for i, entity := range args.Entities {
tag, err := names.ParseTag(entity.Tag)
if err != nil {
results[i].Error = common.ServerError(err)
continue
}
err = common.ErrPerm
if u.authorizer.AuthOwner(tag) {
// Only return the globally desired agent version if the
// asking entity is a machine agent with JobManageModel or
// if this API server is running the globally desired agent
// version. Otherwise report this API server's current
// agent 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
}
|
go
|
{
"resource": ""
}
|
q3356
|
newValidConfig
|
train
|
func newValidConfig(cfg *config.Config) (*environConfig, error) {
// Ensure that the provided config is valid.
if err := config.Validate(cfg, nil); err != nil {
return nil, errors.Trace(err)
}
// Apply the defaults and coerce/validate the custom config attrs.
validated, 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
}
|
go
|
{
"resource": ""
}
|
q3357
|
validate
|
train
|
func (c environConfig) validate() error {
// All fields must be populated, even with just the default.
for _, field := range configRequiredFields {
if c.attrs[field].(string) == "" {
return errors.Errorf("%s: must not be empty", field)
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q3358
|
update
|
train
|
func (c *environConfig) update(cfg *config.Config) error {
// Validate the updates. newValidConfig does not modify the "known"
// config attributes so it is safe to call Validate here first.
if err := config.Validate(cfg, c.Config); err != nil {
return errors.Trace(err)
}
updates, err := newValidConfig(cfg)
if err != nil {
return errors.Trace(err)
}
// Check that no immutable fields have changed.
attrs := updates.UnknownAttrs()
for _, field := range configImmutableFields {
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
}
|
go
|
{
"resource": ""
}
|
q3359
|
Validate
|
train
|
func (info *ControllerInfo) Validate() error {
if !names.IsValidController(info.ControllerTag.Id()) {
return errors.NotValidf("ControllerTag")
}
if len(info.Addrs) < 1 {
return errors.NotValidf("empty controller api addresses")
}
for _, addr := range info.Addrs {
_, err := network.ParseHostPort(addr)
if err != nil {
return errors.NotValidf("controller api address %q", addr)
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q3360
|
NewFacade
|
train
|
func NewFacade(ctx facade.Context) (*API, error) {
controllerState := ctx.StatePool().SystemState()
precheckBackend, err := migration.PrecheckShim(ctx.State(), controllerState)
if err != nil {
return nil, errors.Annotate(err, "creating precheck backend")
}
return NewAPI(
&backendShim{ctx.State()},
precheckBackend,
migration.PoolShim(ctx.StatePool()),
ctx.Resources(),
ctx.Auth(),
ctx.Presence(),
)
}
|
go
|
{
"resource": ""
}
|
q3361
|
ModelName
|
train
|
func (s *backendShim) ModelName() (string, error) {
model, err := s.Model()
if err != nil {
return "", errors.Trace(err)
}
return model.Name(), nil
}
|
go
|
{
"resource": ""
}
|
q3362
|
ModelOwner
|
train
|
func (s *backendShim) ModelOwner() (names.UserTag, error) {
model, err := s.Model()
if err != nil {
return names.UserTag{}, errors.Trace(err)
}
return model.Owner(), nil
}
|
go
|
{
"resource": ""
}
|
q3363
|
AgentVersion
|
train
|
func (s *backendShim) AgentVersion() (version.Number, error) {
m, err := s.Model()
if err != nil {
return version.Zero, errors.Trace(err)
}
cfg, err := m.ModelConfig()
if err != nil {
return version.Zero, errors.Trace(err)
}
vers, ok := cfg.AgentVersion()
if !ok {
return version.Zero, errors.New("no agent version")
}
return vers, nil
}
|
go
|
{
"resource": ""
}
|
q3364
|
ensureHostedModel
|
train
|
func ensureHostedModel(
isCAAS bool,
cloudSpec environs.CloudSpec,
provider environs.EnvironProvider,
args InitializeStateParams,
st *state.State,
ctrl *state.Controller,
adminUser names.UserTag,
cloudCredentialTag names.CloudCredentialTag,
) error {
if len(args.HostedModelConfig) == 0 {
logger.Debugf("no hosted model configured")
return nil
}
// Create the initial hosted model, with the model config passed to
// bootstrap, which contains the UUID, name for the hosted model,
// and any user supplied config. We also copy the authorized-keys
// from the controller model.
attrs := make(map[string]interface{})
for k, v := range args.HostedModelConfig {
attrs[k] = v
}
attrs[config.AuthorizedKeysKey] = args.ControllerModelConfig.AuthorizedKeys()
creator := modelmanager.ModelConfigCreator{Provider: args.Provider}
hostedModelConfig, err := creator.NewModelConfig(
cloudSpec, args.ControllerModelConfig, attrs,
)
if err != nil {
return errors.Annotate(err, "creating hosted model config")
}
controllerUUID := args.ControllerConfig.ControllerUUID()
hostedModelEnv, err := getEnviron(controllerUUID, cloudSpec, hostedModelConfig, provider)
if err != nil {
return errors.Annotate(err, "opening hosted model environment")
}
if err := hostedModelEnv.Create(
state.CallContext(st),
environs.CreateParams{
ControllerUUID: controllerUUID,
}); err != nil {
return errors.Annotate(err, "creating hosted model environment")
}
ctrlModel, err := st.Model()
if err != nil {
return errors.Trace(err)
}
model, hostedModelState, err := ctrl.NewModel(state.ModelArgs{
Type: ctrlModel.Type(),
Owner: adminUser,
Config: 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
}
|
go
|
{
"resource": ""
}
|
q3365
|
initMongo
|
train
|
func initMongo(info mongo.Info, dialOpts mongo.DialOpts, password string) (*mgo.Session, error) {
session, err := mongo.DialWithInfo(mongo.MongoInfo{Info: info}, dialOpts)
if err != nil {
return nil, errors.Trace(err)
}
if err := mongo.SetAdminMongoPassword(session, mongo.AdminUser, password); err != nil {
session.Close()
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
}
|
go
|
{
"resource": ""
}
|
q3366
|
initBootstrapMachine
|
train
|
func initBootstrapMachine(
c agent.ConfigSetter,
st *state.State,
args InitializeStateParams,
) (*state.Machine, error) {
model, err := st.Model()
if err != nil {
return nil, errors.Trace(err)
}
logger.Infof("initialising bootstrap machine for %q model with config: %+v", model.Type(), args)
jobs := make([]state.MachineJob, len(args.BootstrapMachineJobs))
for i, job := range args.BootstrapMachineJobs {
machineJob, err := machineJobFromParams(job)
if err != nil {
return nil, errors.Errorf("invalid bootstrap machine job %q: %v", job, err)
}
jobs[i] = machineJob
}
var hardware instance.HardwareCharacteristics
if args.BootstrapMachineHardwareCharacteristics != nil {
hardware = *args.BootstrapMachineHardwareCharacteristics
}
hostSeries, err := series.HostSeries()
if err != nil {
return nil, errors.Trace(err)
}
m, err := st.AddOneMachine(state.MachineTemplate{
Addresses: args.BootstrapMachineAddresses,
Series: hostSeries,
Nonce: agent.BootstrapNonce,
Constraints: args.BootstrapMachineConstraints,
InstanceId: args.BootstrapMachineInstanceId,
HardwareCharacteristics: hardware,
Jobs: jobs,
})
if err != nil {
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
}
|
go
|
{
"resource": ""
}
|
q3367
|
initControllerCloudService
|
train
|
func initControllerCloudService(
cloudSpec environs.CloudSpec,
provider environs.EnvironProvider,
st *state.State,
args InitializeStateParams,
) error {
controllerUUID := args.ControllerConfig.ControllerUUID()
env, err := getEnviron(controllerUUID, cloudSpec, args.ControllerModelConfig, provider)
if err != nil {
return errors.Annotate(err, "getting environ")
}
broker, ok := env.(caas.ServiceGetterSetter)
if !ok {
// this should never happen.
return errors.Errorf("environ %T does not implement ServiceGetterSetter interface", env)
}
svc, err := broker.GetService(k8sprovider.JujuControllerStackName, true)
if err != nil {
return errors.Trace(err)
}
if len(svc.Addresses) == 0 {
// 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)
}
|
go
|
{
"resource": ""
}
|
q3368
|
Render
|
train
|
func (lxdRenderer) Render(cfg cloudinit.CloudConfig, os jujuos.OSType) ([]byte, error) {
switch os {
case jujuos.Ubuntu, jujuos.CentOS, jujuos.OpenSUSE:
bytes, err := renderers.RenderYAML(cfg)
return bytes, errors.Trace(err)
default:
return nil, errors.Errorf("cannot encode userdata for OS %q", os)
}
}
|
go
|
{
"resource": ""
}
|
q3369
|
preallocOplog
|
train
|
func preallocOplog(dir string, oplogSizeMB int) error {
// preallocFiles expects sizes in bytes.
sizes := preallocFileSizes(oplogSizeMB * 1024 * 1024)
prefix := filepath.Join(dir, "local.")
return preallocFiles(prefix, sizes...)
}
|
go
|
{
"resource": ""
}
|
q3370
|
defaultOplogSize
|
train
|
func defaultOplogSize(dir string) (int, error) {
if hostWordSize == 32 {
// "For 32-bit systems, MongoDB allocates about 48 megabytes
// of space to the oplog."
return 48, nil
}
// "For 64-bit OS X systems, MongoDB allocates 183 megabytes of
// space to the oplog."
if runtimeGOOS == "darwin" {
return 183, nil
}
// FIXME calculate disk size on Windows like on Linux below.
if runtimeGOOS == "windows" {
return smallOplogSizeMB, nil
}
avail, err := availSpace(dir)
if err != nil {
return -1, err
}
if avail < smallOplogBoundary {
return smallOplogSizeMB, nil
} else {
return regularOplogSizeMB, nil
}
}
|
go
|
{
"resource": ""
}
|
q3371
|
fsAvailSpace
|
train
|
func fsAvailSpace(dir string) (avail float64, err error) {
var stderr bytes.Buffer
cmd := exec.Command("df", dir)
cmd.Stderr = &stderr
out, err := cmd.Output()
if err != nil {
err := fmt.Errorf("df failed: %v", err)
if stderr.Len() > 0 {
err = fmt.Errorf("%s (%q)", err, stderr.String())
}
return -1, err
}
lines := strings.Split(strings.TrimSpace(string(out)), "\n")
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
}
|
go
|
{
"resource": ""
}
|
q3372
|
preallocFiles
|
train
|
func preallocFiles(prefix string, sizes ...int) error {
var err error
var createdFiles []string
for i, size := range sizes {
var created bool
filename := fmt.Sprintf("%s%d", prefix, i)
created, err = preallocFile(filename, size)
if created {
createdFiles = append(createdFiles, filename)
}
if err != nil {
break
}
}
if err != nil {
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
}
|
go
|
{
"resource": ""
}
|
q3373
|
preallocFileSizes
|
train
|
func preallocFileSizes(totalSize int) []int {
// Divide the total size into 512MB chunks, and
// then round up the remaining chunk to a multiple
// of 4096 bytes.
const maxChunkSize = 512 * 1024 * 1024
var 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
}
|
go
|
{
"resource": ""
}
|
q3374
|
doPreallocFile
|
train
|
func doPreallocFile(filename string, size int) (created bool, err error) {
if size%preallocAlign != 0 {
return false, fmt.Errorf("specified size %v for file %q is not a multiple of %d", size, filename, preallocAlign)
}
f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0700)
if os.IsExist(err) {
// already exists, don't overwrite
return false, nil
}
if err != nil {
return false, fmt.Errorf("failed to open mongo prealloc file %q: %v", filename, err)
}
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
}
|
go
|
{
"resource": ""
}
|
q3375
|
NewMockExtensionsV1beta1Interface
|
train
|
func NewMockExtensionsV1beta1Interface(ctrl *gomock.Controller) *MockExtensionsV1beta1Interface {
mock := &MockExtensionsV1beta1Interface{ctrl: ctrl}
mock.recorder = &MockExtensionsV1beta1InterfaceMockRecorder{mock}
return mock
}
|
go
|
{
"resource": ""
}
|
q3376
|
DaemonSets
|
train
|
func (mr *MockExtensionsV1beta1InterfaceMockRecorder) DaemonSets(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DaemonSets", reflect.TypeOf((*MockExtensionsV1beta1Interface)(nil).DaemonSets), arg0)
}
|
go
|
{
"resource": ""
}
|
q3377
|
Ingresses
|
train
|
func (m *MockExtensionsV1beta1Interface) Ingresses(arg0 string) v1beta10.IngressInterface {
ret := m.ctrl.Call(m, "Ingresses", arg0)
ret0, _ := ret[0].(v1beta10.IngressInterface)
return ret0
}
|
go
|
{
"resource": ""
}
|
q3378
|
PodSecurityPolicies
|
train
|
func (m *MockExtensionsV1beta1Interface) PodSecurityPolicies() v1beta10.PodSecurityPolicyInterface {
ret := m.ctrl.Call(m, "PodSecurityPolicies")
ret0, _ := ret[0].(v1beta10.PodSecurityPolicyInterface)
return ret0
}
|
go
|
{
"resource": ""
}
|
q3379
|
PodSecurityPolicies
|
train
|
func (mr *MockExtensionsV1beta1InterfaceMockRecorder) PodSecurityPolicies() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PodSecurityPolicies", reflect.TypeOf((*MockExtensionsV1beta1Interface)(nil).PodSecurityPolicies))
}
|
go
|
{
"resource": ""
}
|
q3380
|
Scales
|
train
|
func (m *MockExtensionsV1beta1Interface) Scales(arg0 string) v1beta10.ScaleInterface {
ret := m.ctrl.Call(m, "Scales", arg0)
ret0, _ := ret[0].(v1beta10.ScaleInterface)
return ret0
}
|
go
|
{
"resource": ""
}
|
q3381
|
NewMockIngressInterface
|
train
|
func NewMockIngressInterface(ctrl *gomock.Controller) *MockIngressInterface {
mock := &MockIngressInterface{ctrl: ctrl}
mock.recorder = &MockIngressInterfaceMockRecorder{mock}
return mock
}
|
go
|
{
"resource": ""
}
|
q3382
|
UpdateStatus
|
train
|
func (mr *MockIngressInterfaceMockRecorder) UpdateStatus(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStatus", reflect.TypeOf((*MockIngressInterface)(nil).UpdateStatus), arg0)
}
|
go
|
{
"resource": ""
}
|
q3383
|
ConstructClient
|
train
|
func ConstructClient(clientFacade base.ClientFacade, facadeCaller base.FacadeCaller) *Client {
return &Client{ClientFacade: clientFacade, facade: facadeCaller}
}
|
go
|
{
"resource": ""
}
|
q3384
|
NewClient
|
train
|
func NewClient(st base.APICallCloser) *Client {
frontend, backend := base.NewClientFacade(st, machineManagerFacade)
return ConstructClient(frontend, backend)
}
|
go
|
{
"resource": ""
}
|
q3385
|
AddMachines
|
train
|
func (client *Client) AddMachines(machineParams []params.AddMachineParams) ([]params.AddMachinesResult, error) {
args := params.AddMachines{
MachineParams: machineParams,
}
results := new(params.AddMachinesResults)
err := client.facade.FacadeCall("AddMachines", args, results)
if len(results.Machines) != len(machineParams) {
return nil, errors.Errorf("expected %d result, got %d", len(machineParams), len(results.Machines))
}
return results.Machines, err
}
|
go
|
{
"resource": ""
}
|
q3386
|
UpgradeSeriesPrepare
|
train
|
func (client *Client) UpgradeSeriesPrepare(machineName, series string, force bool) error {
if client.BestAPIVersion() < 5 {
return errors.NotSupportedf("upgrade-series prepare")
}
args := params.UpdateSeriesArg{
Entity: params.Entity{
Tag: names.NewMachineTag(machineName).String()},
Series: series,
Force: force,
}
result := 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
}
|
go
|
{
"resource": ""
}
|
q3387
|
UpgradeSeriesComplete
|
train
|
func (client *Client) UpgradeSeriesComplete(machineName string) error {
if client.BestAPIVersion() < 5 {
return errors.NotSupportedf("UpgradeSeriesComplete")
}
args := params.UpdateSeriesArg{
Entity: params.Entity{Tag: names.NewMachineTag(machineName).String()},
}
result := 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
}
|
go
|
{
"resource": ""
}
|
q3388
|
GetUpgradeSeriesMessages
|
train
|
func (client *Client) GetUpgradeSeriesMessages(machineName, watcherId string) ([]string, error) {
if client.BestAPIVersion() < 5 {
return nil, errors.NotSupportedf("GetUpgradeSeriesMessages")
}
var results params.StringsResults
args := params.UpgradeSeriesNotificationParams{
Params: []params.UpgradeSeriesNotificationParam{
{
Entity: params.Entity{Tag: names.NewMachineTag(machineName).String()},
WatcherId: watcherId,
},
},
}
err := client.facade.FacadeCall("GetUpgradeSeriesMessages", args, &results)
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
}
|
go
|
{
"resource": ""
}
|
q3389
|
NewClient
|
train
|
func NewClient(caller base.APICaller) *Client {
facadeCaller := base.NewFacadeCaller(caller, "CAASOperator")
return &Client{
facade: facadeCaller,
APIAddresser: common.NewAPIAddresser(facadeCaller),
}
}
|
go
|
{
"resource": ""
}
|
q3390
|
SetStatus
|
train
|
func (c *Client) SetStatus(
application string,
status status.Status,
info string,
data map[string]interface{},
) error {
tag, err := c.appTag(application)
if err != nil {
return errors.Trace(err)
}
var result params.ErrorResults
args := params.SetStatus{
Entities: []params.EntityStatusArgs{{
Tag: tag.String(),
Status: status.String(),
Info: info,
Data: data,
}},
}
if err := c.facade.FacadeCall("SetStatus", args, &result); err != nil {
return errors.Trace(err)
}
return result.OneError()
}
|
go
|
{
"resource": ""
}
|
q3391
|
Charm
|
train
|
func (c *Client) Charm(application string) (_ *charm.URL, forceUpgrade bool, sha256 string, vers int, _ error) {
tag, err := c.appTag(application)
if err != nil {
return nil, false, "", 0, errors.Trace(err)
}
var results params.ApplicationCharmResults
args := params.Entities{
Entities: []params.Entity{{Tag: tag.String()}},
}
if err := c.facade.FacadeCall("Charm", args, &results); err != nil {
return nil, false, "", 0, errors.Trace(err)
}
if n := len(results.Results); n != 1 {
return nil, false, "", 0, errors.Errorf("expected 1 result, got %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
}
|
go
|
{
"resource": ""
}
|
q3392
|
WatchUnits
|
train
|
func (c *Client) WatchUnits(application string) (watcher.StringsWatcher, error) {
applicationTag, err := applicationTag(application)
if err != nil {
return nil, errors.Trace(err)
}
args := entities(applicationTag)
var results params.StringsWatchResults
if 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
}
|
go
|
{
"resource": ""
}
|
q3393
|
RemoveUnit
|
train
|
func (c *Client) RemoveUnit(unitName string) error {
if !names.IsValidUnit(unitName) {
return errors.NotValidf("unit name %q", unitName)
}
var result params.ErrorResults
args := params.Entities{
Entities: []params.Entity{{Tag: names.NewUnitTag(unitName).String()}},
}
err := c.facade.FacadeCall("Remove", args, &result)
if err != nil {
return err
}
return result.OneError()
}
|
go
|
{
"resource": ""
}
|
q3394
|
SetVersion
|
train
|
func (c *Client) SetVersion(appName string, v version.Binary) error {
if !names.IsValidApplication(appName) {
return errors.NotValidf("application name %q", appName)
}
var results params.ErrorResults
args := params.EntitiesVersion{
AgentTools: []params.EntityVersion{{
Tag: names.NewApplicationTag(appName).String(),
Tools: ¶ms.Version{v},
}},
}
err := c.facade.FacadeCall("SetTools", args, &results)
if err != nil {
return errors.Trace(err)
}
return results.OneError()
}
|
go
|
{
"resource": ""
}
|
q3395
|
VolumeTag
|
train
|
func (v *volume) VolumeTag() names.VolumeTag {
return names.NewVolumeTag(v.doc.Name)
}
|
go
|
{
"resource": ""
}
|
q3396
|
StorageInstance
|
train
|
func (v *volume) StorageInstance() (names.StorageTag, error) {
if v.doc.StorageId == "" {
msg := fmt.Sprintf("volume %q is not assigned to any storage instance", v.Tag().Id())
return names.StorageTag{}, errors.NewNotAssigned(nil, msg)
}
return names.NewStorageTag(v.doc.StorageId), nil
}
|
go
|
{
"resource": ""
}
|
q3397
|
Info
|
train
|
func (v *volume) Info() (VolumeInfo, error) {
if v.doc.Info == nil {
return VolumeInfo{}, errors.NotProvisionedf("volume %q", v.doc.Name)
}
return *v.doc.Info, nil
}
|
go
|
{
"resource": ""
}
|
q3398
|
Params
|
train
|
func (v *volume) Params() (VolumeParams, bool) {
if v.doc.Params == nil {
return VolumeParams{}, false
}
return *v.doc.Params, true
}
|
go
|
{
"resource": ""
}
|
q3399
|
Machine
|
train
|
func (v *volumeAttachmentPlan) Machine() names.MachineTag {
return names.NewMachineTag(v.doc.Machine)
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.