_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q3700
|
ApplicationsScale
|
train
|
func (f *Facade) ApplicationsScale(args params.Entities) (params.IntResults, error) {
results := params.IntResults{
Results: make([]params.IntResult, len(args.Entities)),
}
for i, arg := range args.Entities {
scale, err := f.applicationScale(arg.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].Result = scale
}
logger.Debugf("provisioning info result: %#v", results)
return results, nil
}
|
go
|
{
"resource": ""
}
|
q3701
|
ProvisioningInfo
|
train
|
func (f *Facade) ProvisioningInfo(args params.Entities) (params.KubernetesProvisioningInfoResults, error) {
model, err := f.state.Model()
if err != nil {
return params.KubernetesProvisioningInfoResults{}, errors.Trace(err)
}
results := params.KubernetesProvisioningInfoResults{
Results: make([]params.KubernetesProvisioningInfoResult, len(args.Entities)),
}
for i, arg := range args.Entities {
info, err := f.provisioningInfo(model, arg.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].Result = info
}
return results, nil
}
|
go
|
{
"resource": ""
}
|
q3702
|
applicationFilesystemParams
|
train
|
func (f *Facade) applicationFilesystemParams(
app Application,
controllerConfig controller.Config,
modelConfig *config.Config,
) ([]params.KubernetesFilesystemParams, error) {
storage, err := app.StorageConstraints()
if err != nil {
return nil, errors.Trace(err)
}
ch, _, err := app.Charm()
if err != nil {
return nil, errors.Trace(err)
}
var allFilesystemParams []params.KubernetesFilesystemParams
for name, cons := range storage {
fsParams, err := filesystemParams(
app, cons, name,
controllerConfig.ControllerUUID(),
modelConfig,
f.storagePoolManager, f.registry,
)
if err != nil {
return nil, errors.Annotatef(err, "getting filesystem %q parameters", name)
}
for i := 0; i < int(cons.Count); i++ {
charmStorage := ch.Meta().Storage[name]
id := fmt.Sprintf("%s/%v", name, i)
tag := names.NewStorageTag(id)
location, err := state.FilesystemMountPoint(charmStorage, tag, "kubernetes")
if err != nil {
return nil, errors.Trace(err)
}
filesystemAttachmentParams := params.KubernetesFilesystemAttachmentParams{
Provider: fsParams.Provider,
MountPoint: location,
ReadOnly: charmStorage.ReadOnly,
}
fsParams.Attachment = &filesystemAttachmentParams
allFilesystemParams = append(allFilesystemParams, fsParams)
}
}
return allFilesystemParams, nil
}
|
go
|
{
"resource": ""
}
|
q3703
|
ApplicationsConfig
|
train
|
func (f *Facade) ApplicationsConfig(args params.Entities) (params.ApplicationGetConfigResults, error) {
results := params.ApplicationGetConfigResults{
Results: make([]params.ConfigResult, len(args.Entities)),
}
for i, arg := range args.Entities {
result, err := f.getApplicationConfig(arg.Tag)
results.Results[i].Config = result
results.Results[i].Error = common.ServerError(err)
}
return results, nil
}
|
go
|
{
"resource": ""
}
|
q3704
|
UpdateApplicationsUnits
|
train
|
func (a *Facade) UpdateApplicationsUnits(args params.UpdateApplicationUnitArgs) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Args)),
}
if len(args.Args) == 0 {
return result, nil
}
for i, appUpdate := range args.Args {
appTag, err := names.ParseApplicationTag(appUpdate.ApplicationTag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
app, err := a.state.Application(appTag.Id())
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
appStatus := appUpdate.Status
if appStatus.Status != "" && appStatus.Status != status.Unknown {
now := a.clock.Now()
err = app.SetStatus(status.StatusInfo{
Status: appStatus.Status,
Message: appStatus.Info,
Data: appStatus.Data,
Since: &now,
})
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
}
err = a.updateUnitsFromCloud(app, appUpdate.Scale, appUpdate.Units)
if err != nil {
// Mask any not found errors as the worker (caller) treats them specially
// and they are not relevant here.
result.Results[i].Error = common.ServerError(errors.Mask(err))
}
}
return result, nil
}
|
go
|
{
"resource": ""
}
|
q3705
|
updateStatus
|
train
|
func (a *Facade) updateStatus(params params.ApplicationUnitParams) (
agentStatus *status.StatusInfo,
cloudContainerStatus *status.StatusInfo,
) {
var containerStatus status.Status
switch status.Status(params.Status) {
case status.Unknown:
// The container runtime can spam us with unimportant
// status updates, so ignore any irrelevant ones.
return nil, nil
case status.Allocating:
// The container runtime has decided to restart the pod.
agentStatus = &status.StatusInfo{
Status: status.Allocating,
Message: params.Info,
}
containerStatus = status.Waiting
case status.Running:
// A pod has finished starting so the workload is now active.
agentStatus = &status.StatusInfo{
Status: status.Idle,
}
containerStatus = status.Running
case status.Error:
agentStatus = &status.StatusInfo{
Status: status.Error,
Message: params.Info,
Data: params.Data,
}
containerStatus = status.Error
case status.Blocked:
containerStatus = status.Blocked
agentStatus = &status.StatusInfo{
Status: status.Idle,
}
}
cloudContainerStatus = &status.StatusInfo{
Status: containerStatus,
Message: params.Info,
Data: params.Data,
}
return agentStatus, cloudContainerStatus
}
|
go
|
{
"resource": ""
}
|
q3706
|
UpdateApplicationsService
|
train
|
func (a *Facade) UpdateApplicationsService(args params.UpdateApplicationServiceArgs) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Args)),
}
if len(args.Args) == 0 {
return result, nil
}
for i, appUpdate := range args.Args {
appTag, err := names.ParseApplicationTag(appUpdate.ApplicationTag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
app, err := a.state.Application(appTag.Id())
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
if err := app.UpdateCloudService(appUpdate.ProviderId, params.NetworkAddresses(appUpdate.Addresses...)); err != nil {
result.Results[i].Error = common.ServerError(err)
}
}
return result, nil
}
|
go
|
{
"resource": ""
}
|
q3707
|
SetOperatorStatus
|
train
|
func (a *Facade) SetOperatorStatus(args params.SetStatus) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
for i, arg := range args.Entities {
appTag, err := names.ParseApplicationTag(arg.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
app, err := a.state.Application(appTag.Id())
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
now := a.clock.Now()
s := status.StatusInfo{
Status: status.Status(arg.Status),
Message: arg.Info,
Data: arg.Data,
Since: &now,
}
if err := app.SetOperatorStatus(s); err != nil {
result.Results[i].Error = common.ServerError(err)
}
}
return result, nil
}
|
go
|
{
"resource": ""
}
|
q3708
|
Component
|
train
|
func (c payloadsHookContext) Component(name string) (context.Component, error) {
found, err := c.Context.Component(name)
if err != nil {
return nil, errors.Trace(err)
}
compCtx, ok := found.(context.Component)
if !ok && found != nil {
return nil, errors.Errorf("wrong component context type registered: %T", found)
}
return compCtx, nil
}
|
go
|
{
"resource": ""
}
|
q3709
|
Validate
|
train
|
func (info *TargetInfo) Validate() error {
if !names.IsValidModel(info.ControllerTag.Id()) {
return errors.NotValidf("ControllerTag")
}
if len(info.Addrs) < 1 {
return errors.NotValidf("empty Addrs")
}
for _, addr := range info.Addrs {
_, err := network.ParseHostPort(addr)
if err != nil {
return errors.NotValidf("%q in Addrs", addr)
}
}
if info.AuthTag.Id() == "" {
return errors.NotValidf("empty AuthTag")
}
if info.Password == "" && len(info.Macaroons) == 0 {
return errors.NotValidf("missing Password & Macaroons")
}
return nil
}
|
go
|
{
"resource": ""
}
|
q3710
|
IndexStoragePath
|
train
|
func IndexStoragePath() string {
return path.Join(storage.BaseImagesPath, simplestreams.UnsignedIndex(currentStreamsVersion, IndexFileVersion))
}
|
go
|
{
"resource": ""
}
|
q3711
|
readMetadata
|
train
|
func readMetadata(metadataStore storage.Storage) ([]*ImageMetadata, error) {
// Read any existing metadata so we can merge the new tools metadata with what's there.
dataSource := storage.NewStorageSimpleStreamsDataSource("existing metadata", metadataStore, storage.BaseImagesPath, simplestreams.EXISTING_CLOUD_DATA, false)
imageConstraint := NewImageConstraint(simplestreams.LookupParams{})
existingMetadata, _, err := Fetch([]simplestreams.DataSource{dataSource}, imageConstraint)
if err != nil && !errors.IsNotFound(err) {
return nil, err
}
return existingMetadata, nil
}
|
go
|
{
"resource": ""
}
|
q3712
|
mapKey
|
train
|
func mapKey(im *ImageMetadata) string {
return fmt.Sprintf("%s-%s-%s-%s", im.productId(), im.RegionName, im.VirtType, im.Storage)
}
|
go
|
{
"resource": ""
}
|
q3713
|
mergeMetadata
|
train
|
func mergeMetadata(seriesVersion string, cloudSpec *simplestreams.CloudSpec, newMetadata,
existingMetadata []*ImageMetadata) ([]*ImageMetadata, []simplestreams.CloudSpec) {
regions := make(map[string]bool)
var allCloudSpecs = []simplestreams.CloudSpec{}
// Each metadata item defines its own cloud specification.
// However, when we combine metadata items in the file, we do not want to
// repeat common cloud specifications in index definition.
// Since region name and endpoint have 1:1 correspondence,
// only one distinct cloud specification for each region
// is being collected.
addDistinctCloudSpec := func(im *ImageMetadata) {
if _, ok := regions[im.RegionName]; !ok {
regions[im.RegionName] = true
aCloudSpec := simplestreams.CloudSpec{
Region: im.RegionName,
Endpoint: im.Endpoint,
}
allCloudSpecs = append(allCloudSpecs, aCloudSpec)
}
}
var toWrite = make([]*ImageMetadata, len(newMetadata))
imageIds := make(map[string]bool)
for i, im := range newMetadata {
newRecord := *im
newRecord.Version = seriesVersion
newRecord.RegionName = cloudSpec.Region
newRecord.Endpoint = cloudSpec.Endpoint
toWrite[i] = &newRecord
imageIds[mapKey(&newRecord)] = true
addDistinctCloudSpec(&newRecord)
}
for _, im := range existingMetadata {
if _, ok := imageIds[mapKey(im)]; !ok {
toWrite = append(toWrite, im)
addDistinctCloudSpec(im)
}
}
return toWrite, allCloudSpecs
}
|
go
|
{
"resource": ""
}
|
q3714
|
writeMetadata
|
train
|
func writeMetadata(metadata []*ImageMetadata, cloudSpec []simplestreams.CloudSpec,
metadataStore storage.Storage) error {
// TODO(perrito666) 2016-05-02 lp:1558657
index, products, err := MarshalImageMetadataJSON(metadata, cloudSpec, time.Now())
if err != nil {
return err
}
metadataInfo := []MetadataFile{
{IndexStoragePath(), index},
{ProductMetadataStoragePath(), products},
}
for _, md := range metadataInfo {
err = metadataStore.Put(md.Path, bytes.NewReader(md.Data), int64(len(md.Data)))
if err != nil {
return err
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q3715
|
queueRemoval
|
train
|
func (p *Pruner) queueRemoval(seq int64) {
p.toRemove = append(p.toRemove, docIDInt64(p.modelUUID, seq))
}
|
go
|
{
"resource": ""
}
|
q3716
|
flushRemovals
|
train
|
func (p *Pruner) flushRemovals() error {
if len(p.toRemove) == 0 {
return nil
}
matched, err := p.beingsC.RemoveAll(bson.M{"_id": bson.M{"$in": p.toRemove}})
if err != nil {
return err
}
p.toRemove = p.toRemove[:0]
if matched.Removed > 0 {
p.removedCount += uint64(matched.Removed)
}
return err
}
|
go
|
{
"resource": ""
}
|
q3717
|
NewPruner
|
train
|
func NewPruner(modelUUID string, beings *mgo.Collection, pings *mgo.Collection, delta time.Duration) *Pruner {
return &Pruner{
modelUUID: modelUUID,
beingsC: beings,
maxQueue: 1000,
pingsC: pings,
delta: delta,
}
}
|
go
|
{
"resource": ""
}
|
q3718
|
NewFacade
|
train
|
func NewFacade(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*AgentToolsAPI, error) {
newEnviron := func() (environs.Environ, error) {
newEnviron := stateenvirons.GetNewEnvironFunc(environs.New)
return newEnviron(st)
}
return NewAgentToolsAPI(st, newEnviron, findTools, envVersionUpdate, authorizer)
}
|
go
|
{
"resource": ""
}
|
q3719
|
NewAgentToolsAPI
|
train
|
func NewAgentToolsAPI(
modelGetter ModelGetter,
newEnviron func() (environs.Environ, error),
findTools toolsFinder,
envVersionUpdate func(*state.Model, version.Number) error,
authorizer facade.Authorizer,
) (*AgentToolsAPI, error) {
return &AgentToolsAPI{
modelGetter: modelGetter,
newEnviron: newEnviron,
authorizer: authorizer,
findTools: findTools,
envVersionUpdate: envVersionUpdate,
}, nil
}
|
go
|
{
"resource": ""
}
|
q3720
|
envVersionUpdate
|
train
|
func envVersionUpdate(env *state.Model, ver version.Number) error {
return env.UpdateLatestToolsVersion(ver)
}
|
go
|
{
"resource": ""
}
|
q3721
|
UpdateToolsAvailable
|
train
|
func (api *AgentToolsAPI) UpdateToolsAvailable() error {
if !api.authorizer.AuthController() {
return common.ErrPerm
}
return updateToolsAvailability(api.modelGetter, api.newEnviron, api.findTools, api.envVersionUpdate)
}
|
go
|
{
"resource": ""
}
|
q3722
|
formatFindTabular
|
train
|
func formatFindTabular(writer io.Writer, value interface{}) error {
endpoints, ok := value.(map[string]ApplicationOfferResult)
if !ok {
return errors.Errorf("expected value of type %T, got %T", endpoints, value)
}
return formatFoundEndpointsTabular(writer, endpoints)
}
|
go
|
{
"resource": ""
}
|
q3723
|
formatFoundEndpointsTabular
|
train
|
func formatFoundEndpointsTabular(writer io.Writer, all map[string]ApplicationOfferResult) error {
tw := output.TabWriter(writer)
w := output.Wrapper{tw}
w.Println("Store", "URL", "Access", "Interfaces")
for urlStr, one := range all {
url, err := crossmodel.ParseOfferURL(urlStr)
if err != nil {
return err
}
store := url.Source
url.Source = ""
interfaces := []string{}
for name, ep := range one.Endpoints {
interfaces = append(interfaces, fmt.Sprintf("%s:%s", ep.Interface, name))
}
sort.Strings(interfaces)
w.Println(store, url.String(), one.Access, strings.Join(interfaces, ", "))
}
tw.Flush()
return nil
}
|
go
|
{
"resource": ""
}
|
q3724
|
Path
|
train
|
func (u *OfferURL) Path() string {
var parts []string
if u.User != "" {
parts = append(parts, u.User)
}
if u.ModelName != "" {
parts = append(parts, u.ModelName)
}
path := strings.Join(parts, "/")
path = fmt.Sprintf("%s.%s", path, u.ApplicationName)
if u.Source == "" {
return path
}
return fmt.Sprintf("%s:%s", u.Source, path)
}
|
go
|
{
"resource": ""
}
|
q3725
|
parseOfferURL
|
train
|
func parseOfferURL(urlStr string) (*OfferURL, error) {
urlParts, err := parseOfferURLParts(urlStr, false)
if err != nil {
return nil, err
}
url := OfferURL(*urlParts)
return &url, nil
}
|
go
|
{
"resource": ""
}
|
q3726
|
MakeURL
|
train
|
func MakeURL(user, model, application, controller string) string {
base := fmt.Sprintf("%s/%s.%s", user, model, application)
if controller == "" {
return base
}
return fmt.Sprintf("%s:%s", controller, base)
}
|
go
|
{
"resource": ""
}
|
q3727
|
Open
|
train
|
func (environProvider) Open(args environs.OpenParams) (environs.Environ, error) {
logger.Infof("opening model %q", args.Config.Name())
if err := validateCloudSpec(args.Cloud); err != nil {
return nil, errors.Annotate(err, "validating cloud spec")
}
client, err := newClient(args.Cloud, args.Config.UUID())
if err != nil {
return nil, errors.Trace(err)
}
env := &environ{
name: args.Config.Name(),
cloud: args.Cloud,
client: client,
}
if err := env.SetConfig(args.Config); err != nil {
return nil, err
}
return env, nil
}
|
go
|
{
"resource": ""
}
|
q3728
|
Validate
|
train
|
func (environProvider) Validate(cfg, old *config.Config) (*config.Config, error) {
logger.Infof("validating model %q", cfg.Name())
// You should almost certainly not change this method; if you need to change
// how configs are validated, you should edit validateConfig itself, to ensure
// that your checks are always applied.
newEcfg, err := validateConfig(cfg, nil)
if err != nil {
return nil, errors.Errorf("invalid config: %v", err)
}
if old != nil {
oldEcfg, err := validateConfig(old, nil)
if err != nil {
return nil, errors.Errorf("invalid base config: %v", err)
}
if newEcfg, err = validateConfig(cfg, oldEcfg); err != nil {
return nil, errors.Errorf("invalid config change: %v", err)
}
}
return newEcfg.Config, nil
}
|
go
|
{
"resource": ""
}
|
q3729
|
newCleanup
|
train
|
func newCleanup(client metricsmanager.MetricsManagerClient, notify chan string) worker.Worker {
f := func(stopCh <-chan struct{}) error {
err := client.CleanupOldMetrics()
if err != nil {
cleanupLogger.Warningf("failed to cleanup %v - will retry later", err)
return nil
}
select {
case notify <- "cleanupCalled":
default:
}
return nil
}
return jworker.NewPeriodicWorker(f, cleanupPeriod, jworker.NewTimer)
}
|
go
|
{
"resource": ""
}
|
q3730
|
ensureNetworksAndSubnets
|
train
|
func (e *Environ) ensureNetworksAndSubnets(ctx envcontext.ProviderCallContext, controllerUUID, modelUUID string) (map[string][]ociCore.Subnet, error) {
// if we have the subnets field populated, it means we already checked/created
// the necessary resources. Simply return.
if e.subnets != nil {
return e.subnets, nil
}
vcn, err := e.ensureVCN(controllerUUID, modelUUID)
if err != nil {
providerCommon.HandleCredentialError(err, ctx)
return nil, errors.Trace(err)
}
// NOTE(gsamfira): There are some limitations at the moment in regards to
// security lists:
// * Security lists can only be applied on subnets
// * Once subnet is created, you may not attach a new security list to that subnet
// * there is no way to apply a security list on an instance/VNIC
// * We cannot create a model level security list, unless we create a new subnet for that model
// ** that means at least 3 subnets per model, which is something we probably don't want
// * There is no way to specify the target prefix for an Ingress/Egress rule, thus making
// instance level firewalling, impossible.
// For now, we open all ports until we decide how to properly take care of this.
secList, err := e.ensureSecurityList(controllerUUID, modelUUID, vcn.Id)
if err != nil {
providerCommon.HandleCredentialError(err, ctx)
return nil, errors.Trace(err)
}
ig, err := e.ensureInternetGateway(controllerUUID, modelUUID, vcn.Id)
if err != nil {
providerCommon.HandleCredentialError(err, ctx)
return nil, errors.Trace(err)
}
// Create a default route through the gateway created above
// as a default gateway
prefix := AllowAllPrefix
routeRules := []ociCore.RouteRule{
{
CidrBlock: &prefix,
NetworkEntityId: ig.Id,
},
}
routeTable, err := e.ensureRouteTable(controllerUUID, modelUUID, vcn.Id, routeRules)
if err != nil {
providerCommon.HandleCredentialError(err, ctx)
return nil, errors.Trace(err)
}
subnets, err := e.ensureSubnets(ctx, vcn, secList, controllerUUID, modelUUID, routeTable.Id)
if err != nil {
providerCommon.HandleCredentialError(err, ctx)
return nil, errors.Trace(err)
}
// TODO(gsamfira): should we use a lock here?
e.subnets = subnets
return e.subnets, nil
}
|
go
|
{
"resource": ""
}
|
q3731
|
cleanupNetworksAndSubnets
|
train
|
func (e *Environ) cleanupNetworksAndSubnets(controllerUUID, modelUUID string) error {
vcns, err := e.allVCNs(controllerUUID, modelUUID)
if err != nil {
return errors.Trace(err)
}
if len(vcns) == 0 {
return nil
}
for _, vcn := range vcns {
allSubnets, err := e.allSubnets(controllerUUID, modelUUID, vcn.Id)
if err != nil {
return errors.Trace(err)
}
if err := e.removeSubnets(allSubnets); err != nil {
return errors.Trace(err)
}
secList, err := e.allSecurityLists(controllerUUID, modelUUID, vcn.Id)
if err != nil {
return errors.Trace(err)
}
if err := e.removeSeclist(secList); err != nil {
return errors.Trace(err)
}
if err := e.deleteRouteTable(controllerUUID, modelUUID, vcn.Id); err != nil {
return errors.Trace(err)
}
if err := e.deleteInternetGateway(vcn.Id); err != nil {
return errors.Trace(err)
}
if err := e.removeVCN(vcn); err != nil {
return errors.Trace(err)
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q3732
|
validate
|
train
|
func (m *MetricBatch) validate() error {
charmURL, err := charm.ParseURL(m.doc.CharmURL)
if err != nil {
return errors.Trace(err)
}
chrm, err := m.st.Charm(charmURL)
if err != nil {
return errors.Trace(err)
}
chrmMetrics := chrm.Metrics()
if chrmMetrics == nil {
return errors.Errorf("charm doesn't implement metrics")
}
for _, m := range m.doc.Metrics {
if err := chrmMetrics.ValidateMetric(m.Key, m.Value); err != nil {
return errors.Trace(err)
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q3733
|
AddMetrics
|
train
|
func (st *State) AddMetrics(batch BatchParam) (*MetricBatch, error) {
if len(batch.Metrics) == 0 {
return nil, errors.New("cannot add a batch of 0 metrics")
}
charmURL, err := charm.ParseURL(batch.CharmURL)
if err != nil {
return nil, errors.NewNotValid(err, "could not parse charm URL")
}
unit, err := st.Unit(batch.Unit.Id())
if err != nil {
return nil, errors.Trace(err)
}
application, err := unit.Application()
slaCreds, err := st.SLACredential()
if err != nil {
return nil, errors.Trace(err)
}
metric := &MetricBatch{
st: st,
doc: metricBatchDoc{
UUID: batch.UUID,
ModelUUID: st.ModelUUID(),
Unit: batch.Unit.Id(),
CharmURL: charmURL.String(),
Sent: false,
Created: batch.Created,
Metrics: batch.Metrics,
Credentials: application.MetricCredentials(),
SLACredentials: slaCreds,
},
}
if err := metric.validate(); err != nil {
return nil, err
}
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
notDead, err := isNotDead(st, unitsC, batch.Unit.Id())
if err != nil || !notDead {
return nil, errors.NotFoundf(batch.Unit.Id())
}
exists, err := st.MetricBatch(batch.UUID)
if exists != nil && err == nil {
return nil, errors.AlreadyExistsf("metrics batch UUID %q", batch.UUID)
}
if !errors.IsNotFound(err) {
return nil, errors.Trace(err)
}
}
ops := []txn.Op{{
C: unitsC,
Id: st.docID(batch.Unit.Id()),
Assert: notDeadDoc,
}, {
C: metricsC,
Id: metric.UUID(),
Assert: txn.DocMissing,
Insert: &metric.doc,
}}
return ops, nil
}
err = st.db().Run(buildTxn)
if err != nil {
return nil, errors.Trace(err)
}
return metric, nil
}
|
go
|
{
"resource": ""
}
|
q3734
|
AddModelMetrics
|
train
|
func (st *State) AddModelMetrics(batch ModelBatchParam) (*MetricBatch, error) {
if len(batch.Metrics) == 0 {
return nil, errors.New("cannot add a batch of 0 metrics")
}
slaCreds, err := st.SLACredential()
if err != nil {
return nil, errors.Trace(err)
}
metric := &MetricBatch{
st: st,
doc: metricBatchDoc{
UUID: batch.UUID,
ModelUUID: st.ModelUUID(),
Sent: false,
Created: batch.Created,
Metrics: batch.Metrics,
SLACredentials: slaCreds,
},
}
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
exists, err := st.MetricBatch(batch.UUID)
if exists != nil && err == nil {
return nil, errors.AlreadyExistsf("metrics batch UUID %q", batch.UUID)
}
if !errors.IsNotFound(err) {
return nil, errors.Trace(err)
}
}
ops := []txn.Op{{
C: metricsC,
Id: metric.UUID(),
Assert: txn.DocMissing,
Insert: &metric.doc,
}}
return ops, nil
}
err = st.db().Run(buildTxn)
if err != nil {
return nil, errors.Trace(err)
}
return metric, nil
}
|
go
|
{
"resource": ""
}
|
q3735
|
MetricBatchesForUnit
|
train
|
func (st *State) MetricBatchesForUnit(unit string) ([]MetricBatch, error) {
_, err := st.Unit(unit)
if err != nil {
return nil, errors.Trace(err)
}
return st.queryMetricBatches(bson.M{"unit": unit})
}
|
go
|
{
"resource": ""
}
|
q3736
|
MetricBatchesForModel
|
train
|
func (st *State) MetricBatchesForModel() ([]MetricBatch, error) {
return st.queryMetricBatches(bson.M{"model-uuid": st.ModelUUID()})
}
|
go
|
{
"resource": ""
}
|
q3737
|
MetricBatchesForApplication
|
train
|
func (st *State) MetricBatchesForApplication(application string) ([]MetricBatch, error) {
app, err := st.Application(application)
if err != nil {
return nil, errors.Trace(err)
}
units, err := app.AllUnits()
if err != nil {
return nil, errors.Trace(err)
}
unitNames := make([]bson.M, len(units))
for i, u := range units {
unitNames[i] = bson.M{"unit": u.Name()}
}
return st.queryMetricBatches(bson.M{"$or": unitNames})
}
|
go
|
{
"resource": ""
}
|
q3738
|
MetricBatch
|
train
|
func (st *State) MetricBatch(id string) (*MetricBatch, error) {
c, closer := st.db().GetCollection(metricsC)
defer closer()
doc := metricBatchDoc{}
err := c.Find(bson.M{"_id": id}).One(&doc)
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("metric %v", id)
}
if err != nil {
return nil, err
}
return &MetricBatch{st: st, doc: doc}, nil
}
|
go
|
{
"resource": ""
}
|
q3739
|
MetricsToSend
|
train
|
func (st *State) MetricsToSend(batchSize int) ([]*MetricBatch, error) {
var docs []metricBatchDoc
c, closer := st.db().GetCollection(metricsC)
defer closer()
q := bson.M{
"model-uuid": st.ModelUUID(),
"sent": false,
}
err := c.Find(q).Limit(batchSize).All(&docs)
if err != nil {
return nil, errors.Trace(err)
}
batch := make([]*MetricBatch, len(docs))
for i, doc := range docs {
batch[i] = &MetricBatch{st: st, doc: doc}
}
return batch, nil
}
|
go
|
{
"resource": ""
}
|
q3740
|
CountOfUnsentMetrics
|
train
|
func (st *State) CountOfUnsentMetrics() (int, error) {
c, closer := st.db().GetCollection(metricsC)
defer closer()
return c.Find(bson.M{
"model-uuid": st.ModelUUID(),
"sent": false,
}).Count()
}
|
go
|
{
"resource": ""
}
|
q3741
|
CountOfSentMetrics
|
train
|
func (st *State) CountOfSentMetrics() (int, error) {
c, closer := st.db().GetCollection(metricsC)
defer closer()
return c.Find(bson.M{
"model-uuid": st.ModelUUID(),
"sent": true,
}).Count()
}
|
go
|
{
"resource": ""
}
|
q3742
|
Metrics
|
train
|
func (m *MetricBatch) Metrics() []Metric {
result := make([]Metric, len(m.doc.Metrics))
copy(result, m.doc.Metrics)
return result
}
|
go
|
{
"resource": ""
}
|
q3743
|
UniqueMetrics
|
train
|
func (m *MetricBatch) UniqueMetrics() []Metric {
metrics := m.Metrics()
sort.Sort(byTime(metrics))
uniq := map[string]Metric{}
for _, m := range metrics {
uniq[fmt.Sprintf("%s-%s", m.Key, labelsKey(m.Labels))] = m
}
results := make([]Metric, len(uniq))
i := 0
for _, m := range uniq {
results[i] = m
i++
}
sort.Sort(byKey(results))
return results
}
|
go
|
{
"resource": ""
}
|
q3744
|
SetSent
|
train
|
func (m *MetricBatch) SetSent(t time.Time) error {
deleteTime := t.UTC().Add(CleanupAge)
ops := setSentOps([]string{m.UUID()}, deleteTime)
if err := m.st.db().RunTransaction(ops); err != nil {
return errors.Annotatef(err, "cannot set metric sent for metric %q", m.UUID())
}
m.doc.Sent = true
m.doc.DeleteTime = deleteTime
return nil
}
|
go
|
{
"resource": ""
}
|
q3745
|
SetMetricBatchesSent
|
train
|
func (st *State) SetMetricBatchesSent(batchUUIDs []string) error {
deleteTime := st.clock().Now().UTC().Add(CleanupAge)
ops := setSentOps(batchUUIDs, deleteTime)
if err := st.db().RunTransaction(ops); err != nil {
return errors.Annotatef(err, "cannot set metric sent in bulk call")
}
return nil
}
|
go
|
{
"resource": ""
}
|
q3746
|
NewActionSetCommand
|
train
|
func NewActionSetCommand(ctx Context) (cmd.Command, error) {
return &ActionSetCommand{ctx: ctx}, nil
}
|
go
|
{
"resource": ""
}
|
q3747
|
hash
|
train
|
func hash(settings map[string]interface{}) (string, error) {
bytes, err := yaml.Marshal(settings)
if err != nil {
return "", errors.Trace(err)
}
hash := sha256.New()
_, err = hash.Write(bytes)
if err != nil {
return "", errors.Trace(err)
}
return hex.EncodeToString(hash.Sum(nil)), nil
}
|
go
|
{
"resource": ""
}
|
q3748
|
NewClient
|
train
|
func NewClient(st base.APICallCloser) *Client {
frontend, backend := base.NewClientFacade(st, "Controller")
return &Client{
ClientFacade: frontend,
facade: backend,
ControllerConfigAPI: common.NewControllerConfig(backend),
ModelStatusAPI: common.NewModelStatusAPI(backend),
}
}
|
go
|
{
"resource": ""
}
|
q3749
|
CloudSpec
|
train
|
func (c *Client) CloudSpec(modelTag names.ModelTag) (environs.CloudSpec, error) {
api := cloudspec.NewCloudSpecAPI(c.facade, modelTag)
return api.CloudSpec()
}
|
go
|
{
"resource": ""
}
|
q3750
|
HostedModelConfigs
|
train
|
func (c *Client) HostedModelConfigs() ([]HostedConfig, error) {
result := params.HostedModelConfigsResults{}
err := c.facade.FacadeCall("HostedModelConfigs", nil, &result)
if err != nil {
return nil, errors.Trace(err)
}
// If we get to here, we have some values. Each value may or
// may not have an error, but it should at least have a name
// and owner.
hostedConfigs := make([]HostedConfig, len(result.Models))
for i, modelConfig := range result.Models {
hostedConfigs[i].Name = modelConfig.Name
tag, err := names.ParseUserTag(modelConfig.OwnerTag)
if err != nil {
hostedConfigs[i].Error = errors.Trace(err)
continue
}
hostedConfigs[i].Owner = tag
if modelConfig.Error != nil {
hostedConfigs[i].Error = errors.Trace(modelConfig.Error)
continue
}
hostedConfigs[i].Config = modelConfig.Config
spec, err := c.MakeCloudSpec(modelConfig.CloudSpec)
if err != nil {
hostedConfigs[i].Error = errors.Trace(err)
continue
}
hostedConfigs[i].CloudSpec = spec
}
return hostedConfigs, err
}
|
go
|
{
"resource": ""
}
|
q3751
|
DestroyController
|
train
|
func (c *Client) DestroyController(args DestroyControllerParams) error {
if c.BestAPIVersion() < 4 {
if args.DestroyStorage == nil || !*args.DestroyStorage {
return errors.New("this Juju controller requires DestroyStorage to be true")
}
args.DestroyStorage = nil
}
return c.facade.FacadeCall("DestroyController", params.DestroyControllerArgs{
DestroyModels: args.DestroyModels,
DestroyStorage: args.DestroyStorage,
}, nil)
}
|
go
|
{
"resource": ""
}
|
q3752
|
ListBlockedModels
|
train
|
func (c *Client) ListBlockedModels() ([]params.ModelBlockInfo, error) {
result := params.ModelBlockInfoList{}
err := c.facade.FacadeCall("ListBlockedModels", nil, &result)
return result.Models, err
}
|
go
|
{
"resource": ""
}
|
q3753
|
GrantController
|
train
|
func (c *Client) GrantController(user, access string) error {
return c.modifyControllerUser(params.GrantControllerAccess, user, access)
}
|
go
|
{
"resource": ""
}
|
q3754
|
RevokeController
|
train
|
func (c *Client) RevokeController(user, access string) error {
return c.modifyControllerUser(params.RevokeControllerAccess, user, access)
}
|
go
|
{
"resource": ""
}
|
q3755
|
GetControllerAccess
|
train
|
func (c *Client) GetControllerAccess(user string) (permission.Access, error) {
if !names.IsValidUser(user) {
return "", errors.Errorf("invalid username: %q", user)
}
entities := params.Entities{Entities: []params.Entity{{names.NewUserTag(user).String()}}}
var results params.UserAccessResults
err := c.facade.FacadeCall("GetControllerAccess", entities, &results)
if err != nil {
return "", errors.Trace(err)
}
if len(results.Results) != 1 {
return "", errors.Errorf("expected 1 result, got %d", len(results.Results))
}
if err := results.Results[0].Error; err != nil {
return "", errors.Trace(err)
}
return permission.Access(results.Results[0].Result.Access), nil
}
|
go
|
{
"resource": ""
}
|
q3756
|
ConfigSet
|
train
|
func (c *Client) ConfigSet(values map[string]interface{}) error {
if c.BestAPIVersion() < 5 {
return errors.Errorf("this controller version doesn't support updating controller config")
}
return errors.Trace(
c.facade.FacadeCall("ConfigSet", params.ControllerConfigSet{Config: values}, nil),
)
}
|
go
|
{
"resource": ""
}
|
q3757
|
Validate
|
train
|
func (s *MigrationSpec) Validate() error {
if !names.IsValidModel(s.ModelUUID) {
return errors.NotValidf("model UUID")
}
if !names.IsValidModel(s.TargetControllerUUID) {
return errors.NotValidf("controller UUID")
}
if len(s.TargetAddrs) < 1 {
return errors.NotValidf("empty target API addresses")
}
if !names.IsValidUser(s.TargetUser) {
return errors.NotValidf("target user")
}
if s.TargetPassword == "" && len(s.TargetMacaroons) == 0 {
return errors.NotValidf("missing authentication secrets")
}
return nil
}
|
go
|
{
"resource": ""
}
|
q3758
|
NewStatusAPI
|
train
|
func NewStatusAPI(st *state.State, getCanModify common.GetAuthFunc, leadershipChecker leadership.Checker) *StatusAPI {
// TODO(fwereade): so *all* of these have exactly the same auth
// characteristics? I think not.
unitSetter := common.NewStatusSetter(st, getCanModify)
unitGetter := common.NewStatusGetter(st, getCanModify)
applicationSetter := common.NewApplicationStatusSetter(st, getCanModify, leadershipChecker)
applicationGetter := common.NewApplicationStatusGetter(st, getCanModify, leadershipChecker)
agentSetter := common.NewStatusSetter(&common.UnitAgentFinder{st}, getCanModify)
return &StatusAPI{
agentSetter: agentSetter,
unitSetter: unitSetter,
unitGetter: unitGetter,
applicationSetter: applicationSetter,
applicationGetter: applicationGetter,
getCanModify: getCanModify,
}
}
|
go
|
{
"resource": ""
}
|
q3759
|
SetStatus
|
train
|
func (s *StatusAPI) SetStatus(args params.SetStatus) (params.ErrorResults, error) {
return s.SetAgentStatus(args)
}
|
go
|
{
"resource": ""
}
|
q3760
|
SetUnitStatus
|
train
|
func (s *StatusAPI) SetUnitStatus(args params.SetStatus) (params.ErrorResults, error) {
return s.unitSetter.SetStatus(args)
}
|
go
|
{
"resource": ""
}
|
q3761
|
SetApplicationStatus
|
train
|
func (s *StatusAPI) SetApplicationStatus(args params.SetStatus) (params.ErrorResults, error) {
return s.applicationSetter.SetStatus(args)
}
|
go
|
{
"resource": ""
}
|
q3762
|
UnitStatus
|
train
|
func (s *StatusAPI) UnitStatus(args params.Entities) (params.StatusResults, error) {
return s.unitGetter.Status(args)
}
|
go
|
{
"resource": ""
}
|
q3763
|
ApplicationStatus
|
train
|
func (s *StatusAPI) ApplicationStatus(args params.Entities) (params.ApplicationStatusResults, error) {
return s.applicationGetter.Status(args)
}
|
go
|
{
"resource": ""
}
|
q3764
|
formatFirewallRulesTabular
|
train
|
func formatFirewallRulesTabular(writer io.Writer, rules firewallRules) {
tw := output.TabWriter(writer)
w := output.Wrapper{tw}
sort.Sort(rules)
w.Println("Service", "Whitelist subnets")
for _, rule := range rules {
w.Println(rule.KnownService, strings.Join(rule.WhitelistCIDRS, ","))
}
tw.Flush()
}
|
go
|
{
"resource": ""
}
|
q3765
|
FirstIndex
|
train
|
func (s *syncLogStore) FirstIndex() (uint64, error) {
s.mu.Lock()
defer s.mu.Unlock()
return s.store.FirstIndex()
}
|
go
|
{
"resource": ""
}
|
q3766
|
GetLog
|
train
|
func (s *syncLogStore) GetLog(index uint64, log *raft.Log) error {
s.mu.Lock()
defer s.mu.Unlock()
return s.store.GetLog(index, log)
}
|
go
|
{
"resource": ""
}
|
q3767
|
StoreLog
|
train
|
func (s *syncLogStore) StoreLog(log *raft.Log) error {
s.mu.Lock()
defer s.mu.Unlock()
return s.store.StoreLog(log)
}
|
go
|
{
"resource": ""
}
|
q3768
|
StoreLogs
|
train
|
func (s *syncLogStore) StoreLogs(logs []*raft.Log) error {
s.mu.Lock()
defer s.mu.Unlock()
return s.store.StoreLogs(logs)
}
|
go
|
{
"resource": ""
}
|
q3769
|
DeleteRange
|
train
|
func (s *syncLogStore) DeleteRange(min, max uint64) error {
s.mu.Lock()
defer s.mu.Unlock()
return s.store.DeleteRange(min, max)
}
|
go
|
{
"resource": ""
}
|
q3770
|
Close
|
train
|
func (s *syncLogStore) Close() error {
s.mu.Lock()
defer s.mu.Unlock()
return s.store.Close()
}
|
go
|
{
"resource": ""
}
|
q3771
|
docAsMetadata
|
train
|
func docAsMetadata(doc *storageMetaDoc) *Metadata {
meta := NewMetadata()
meta.Started = metadocUnixToTime(doc.Started)
meta.Notes = doc.Notes
meta.Origin.Model = doc.Model
meta.Origin.Machine = doc.Machine
meta.Origin.Hostname = doc.Hostname
meta.Origin.Version = doc.Version
meta.Origin.Series = doc.Series
meta.SetID(doc.ID)
if doc.Finished != 0 {
finished := metadocUnixToTime(doc.Finished)
meta.Finished = &finished
}
if doc.isFileInfoComplete() {
// Set the file-related fields.
// The doc should have already been validated when stored.
meta.FileMetadata.Raw.Size = doc.Size
meta.FileMetadata.Raw.Checksum = doc.Checksum
meta.FileMetadata.Raw.ChecksumFormat = doc.ChecksumFormat
}
if doc.Stored != 0 {
stored := metadocUnixToTime(doc.Stored)
meta.SetStored(&stored)
}
return meta
}
|
go
|
{
"resource": ""
}
|
q3772
|
newStorageMetaDoc
|
train
|
func newStorageMetaDoc(meta *Metadata) storageMetaDoc {
var doc storageMetaDoc
// Ignore metadata.ID. It will be set by storage later.
doc.Checksum = meta.Checksum()
doc.ChecksumFormat = meta.ChecksumFormat()
doc.Size = meta.Size()
if meta.Stored() != nil {
stored := meta.Stored()
doc.Stored = metadocTimeToUnix(*stored)
}
doc.Started = metadocTimeToUnix(meta.Started)
if meta.Finished != nil {
doc.Finished = metadocTimeToUnix(*meta.Finished)
}
doc.Notes = meta.Notes
doc.Model = meta.Origin.Model
doc.Machine = meta.Origin.Machine
doc.Hostname = meta.Origin.Hostname
doc.Version = meta.Origin.Version
doc.Series = meta.Origin.Series
return doc
}
|
go
|
{
"resource": ""
}
|
q3773
|
newStorageDBWrapper
|
train
|
func newStorageDBWrapper(db *mgo.Database, metaColl, modelUUID string) *storageDBWrapper {
session := db.Session.Copy()
db = db.With(session)
coll := db.C(metaColl)
txnRunner := jujutxn.NewRunner(jujutxn.RunnerParams{
Database: db,
ServerSideTransactions: false,
})
dbWrap := storageDBWrapper{
session: session,
db: db,
metaColl: coll,
txnRunner: txnRunner,
modelUUID: modelUUID,
}
return &dbWrap
}
|
go
|
{
"resource": ""
}
|
q3774
|
metadata
|
train
|
func (b *storageDBWrapper) metadata(id string, doc interface{}) error {
err := b.metaColl.FindId(id).One(doc)
if err == mgo.ErrNotFound {
return errors.NotFoundf("backup metadata %q", id)
}
return errors.Trace(err)
}
|
go
|
{
"resource": ""
}
|
q3775
|
allMetadata
|
train
|
func (b *storageDBWrapper) allMetadata(docs interface{}) error {
err := b.metaColl.Find(nil).All(docs)
return errors.Trace(err)
}
|
go
|
{
"resource": ""
}
|
q3776
|
removeMetadataID
|
train
|
func (b *storageDBWrapper) removeMetadataID(id string) error {
err := b.metaColl.RemoveId(id)
return errors.Trace(err)
}
|
go
|
{
"resource": ""
}
|
q3777
|
txnOpBase
|
train
|
func (b *storageDBWrapper) txnOpBase(id string) txn.Op {
op := txn.Op{
C: b.metaColl.Name,
Id: id,
}
return op
}
|
go
|
{
"resource": ""
}
|
q3778
|
txnOpInsert
|
train
|
func (b *storageDBWrapper) txnOpInsert(id string, doc interface{}) txn.Op {
op := b.txnOpBase(id)
op.Assert = txn.DocMissing
op.Insert = doc
return op
}
|
go
|
{
"resource": ""
}
|
q3779
|
txnOpUpdate
|
train
|
func (b *storageDBWrapper) txnOpUpdate(id string, updates ...bson.DocElem) txn.Op {
op := b.txnOpBase(id)
op.Assert = txn.DocExists
op.Update = bson.D{{"$set", bson.D(updates)}}
return op
}
|
go
|
{
"resource": ""
}
|
q3780
|
runTransaction
|
train
|
func (b *storageDBWrapper) runTransaction(ops []txn.Op) error {
err := b.txnRunner.RunTransaction(&jujutxn.Transaction{Ops: ops})
return errors.Trace(err)
}
|
go
|
{
"resource": ""
}
|
q3781
|
blobStorage
|
train
|
func (b *storageDBWrapper) blobStorage(blobDB string) blobstore.ManagedStorage {
dataStore := blobstore.NewGridFS(blobDB, blobDB, b.session)
return blobstore.NewManagedStorage(b.db, dataStore)
}
|
go
|
{
"resource": ""
}
|
q3782
|
Copy
|
train
|
func (b *storageDBWrapper) Copy() *storageDBWrapper {
session := b.session.Copy()
coll := b.metaColl.With(session)
db := coll.Database
txnRunner := jujutxn.NewRunner(jujutxn.RunnerParams{
Database: db,
ServerSideTransactions: false,
})
dbWrap := storageDBWrapper{
session: session,
db: db,
metaColl: coll,
txnRunner: txnRunner,
modelUUID: b.modelUUID,
}
return &dbWrap
}
|
go
|
{
"resource": ""
}
|
q3783
|
addStorageMetadata
|
train
|
func addStorageMetadata(dbWrap *storageDBWrapper, doc *storageMetaDoc) (string, error) {
// We use our own mongo _id value since the auto-generated one from
// mongo may contain sensitive data (see bson.ObjectID).
id := newStorageID(doc)
doc.ID = id
if err := doc.validate(); err != nil {
return "", errors.Trace(err)
}
op := dbWrap.txnOpInsert(id, doc)
if err := dbWrap.runTransaction([]txn.Op{op}); err != nil {
if errors.Cause(err) == txn.ErrAborted {
return "", errors.AlreadyExistsf("backup metadata %q", doc.ID)
}
return "", errors.Annotate(err, "while running transaction")
}
return id, nil
}
|
go
|
{
"resource": ""
}
|
q3784
|
AddDoc
|
train
|
func (s *backupsDocStorage) AddDoc(doc filestorage.Document) (string, error) {
metadata, ok := doc.(*Metadata)
if !ok {
return "", errors.Errorf("doc must be of type *backups.Metadata")
}
metaDoc := newStorageMetaDoc(metadata)
dbWrap := s.dbWrap.Copy()
defer dbWrap.Close()
id, err := addStorageMetadata(dbWrap, &metaDoc)
return id, errors.Trace(err)
}
|
go
|
{
"resource": ""
}
|
q3785
|
Doc
|
train
|
func (s *backupsDocStorage) Doc(id string) (filestorage.Document, error) {
dbWrap := s.dbWrap.Copy()
defer dbWrap.Close()
doc, err := getStorageMetadata(dbWrap, id)
if err != nil {
return nil, errors.Trace(err)
}
metadata := docAsMetadata(doc)
return metadata, nil
}
|
go
|
{
"resource": ""
}
|
q3786
|
ListDocs
|
train
|
func (s *backupsDocStorage) ListDocs() ([]filestorage.Document, error) {
dbWrap := s.dbWrap.Copy()
defer dbWrap.Close()
var docs []storageMetaDoc
if err := dbWrap.allMetadata(&docs); err != nil {
return nil, errors.Trace(err)
}
list := make([]filestorage.Document, len(docs))
for i, doc := range docs {
meta := docAsMetadata(&doc)
list[i] = meta
}
return list, nil
}
|
go
|
{
"resource": ""
}
|
q3787
|
RemoveDoc
|
train
|
func (s *backupsDocStorage) RemoveDoc(id string) error {
dbWrap := s.dbWrap.Copy()
defer dbWrap.Close()
return errors.Trace(dbWrap.removeMetadataID(id))
}
|
go
|
{
"resource": ""
}
|
q3788
|
SetStored
|
train
|
func (s *backupsMetadataStorage) SetStored(id string) error {
dbWrap := newStorageDBWrapper(s.db, storageMetaName, s.modelUUID)
defer dbWrap.Close()
// TODO(perrito666) 2016-05-02 lp:1558657
err := setStorageStoredTime(dbWrap, id, time.Now())
return errors.Trace(err)
}
|
go
|
{
"resource": ""
}
|
q3789
|
File
|
train
|
func (s *backupBlobStorage) File(id string) (io.ReadCloser, error) {
file, _, err := s.storeImpl.GetForBucket(s.modelUUID, s.path(id))
return file, errors.Trace(err)
}
|
go
|
{
"resource": ""
}
|
q3790
|
AddFile
|
train
|
func (s *backupBlobStorage) AddFile(id string, file io.Reader, size int64) error {
return s.storeImpl.PutForBucket(s.modelUUID, s.path(id), file, size)
}
|
go
|
{
"resource": ""
}
|
q3791
|
RemoveFile
|
train
|
func (s *backupBlobStorage) RemoveFile(id string) error {
return s.storeImpl.RemoveForBucket(s.modelUUID, s.path(id))
}
|
go
|
{
"resource": ""
}
|
q3792
|
NewUnitUpgraderAPI
|
train
|
func NewUnitUpgraderAPI(
st *state.State,
resources facade.Resources,
authorizer facade.Authorizer,
) (*UnitUpgraderAPI, error) {
if !authorizer.AuthUnitAgent() {
return nil, common.ErrPerm
}
getCanWrite := func() (common.AuthFunc, error) {
return authorizer.AuthOwner, nil
}
return &UnitUpgraderAPI{
ToolsSetter: common.NewToolsSetter(st, getCanWrite),
st: st,
resources: resources,
authorizer: authorizer,
}, nil
}
|
go
|
{
"resource": ""
}
|
q3793
|
WatchAPIVersion
|
train
|
func (u *UnitUpgraderAPI) 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 {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if u.authorizer.AuthOwner(tag) {
var watcherId string
watcherId, err = u.watchAssignedMachine(tag)
if err == nil {
result.Results[i].NotifyWatcherId = watcherId
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
|
go
|
{
"resource": ""
}
|
q3794
|
DesiredVersion
|
train
|
func (u *UnitUpgraderAPI) DesiredVersion(args params.Entities) (params.VersionResults, error) {
result := make([]params.VersionResult, len(args.Entities))
for i, entity := range args.Entities {
tag, err := names.ParseTag(entity.Tag)
if err != nil {
result[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if u.authorizer.AuthOwner(tag) {
result[i].Version, err = u.getMachineToolsVersion(tag)
}
result[i].Error = common.ServerError(err)
}
return params.VersionResults{Results: result}, nil
}
|
go
|
{
"resource": ""
}
|
q3795
|
formatGoalState
|
train
|
func formatGoalState(gs application.GoalState) formattedGoalState {
result := formattedGoalState{}
copyUnits := func(units application.UnitsGoalState) unitsGoalStateContents {
copiedUnits := unitsGoalStateContents{}
for name, gs := range units {
copiedUnits[name] = goalStateStatusContents{
Status: gs.Status,
Since: common.FormatTime(gs.Since, true),
}
}
return copiedUnits
}
result.Units = copyUnits(gs.Units)
result.Relations = make(map[string]unitsGoalStateContents, len(gs.Relations))
for relation, units := range gs.Relations {
result.Relations[relation] = copyUnits(units)
}
return result
}
|
go
|
{
"resource": ""
}
|
q3796
|
ValidateSeries
|
train
|
func ValidateSeries(modelType ModelType, charmSeries string) error {
os, err := series.GetOSFromSeries(charmSeries)
if err != nil {
return errors.Trace(err)
}
switch modelType {
case CAAS:
if !caasOS.Contains(os.String()) {
return errors.NotValidf("series %q in a kubernetes model", charmSeries)
}
case IAAS:
if caasOS.Contains(os.String()) {
return errors.NotValidf("series %q in a non container model", charmSeries)
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q3797
|
NewStateBackend
|
train
|
func NewStateBackend(st *state.State) (Backend, error) {
m, err := st.Model()
if err != nil {
return nil, err
}
if m.Type() != state.ModelTypeIAAS {
return nil, errors.NotSupportedf("Firewall Rules for non-IAAS models")
}
return &stateShim{
State: st,
Model: m,
}, nil
}
|
go
|
{
"resource": ""
}
|
q3798
|
ModelAgentVersion
|
train
|
func (m *Machine) ModelAgentVersion() (*version.Number, error) {
mc, err := m.st.ModelConfig()
if err != nil {
return nil, errors.Trace(err)
}
if v, ok := mc.AgentVersion(); ok {
return &v, nil
}
return nil, errors.New("failed to get model's agent version.")
}
|
go
|
{
"resource": ""
}
|
q3799
|
ProvisioningInfo
|
train
|
func (m *Machine) ProvisioningInfo() (*params.ProvisioningInfo, error) {
var results params.ProvisioningInfoResults
args := params.Entities{Entities: []params.Entity{{m.tag.String()}}}
err := m.st.facade.FacadeCall("ProvisioningInfo", args, &results)
if err != nil {
return nil, err
}
if len(results.Results) != 1 {
return nil, fmt.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": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.