_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.ServerE... | 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.KubernetesP... | 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 {
... | 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... | 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.ParseAp... | 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,... | 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.Pa... | 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 = c... | 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", fou... | 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... | 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, fa... | 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.
/... | 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{
{I... | 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, envVersionUpd... | 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: newEn... | 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
... | 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("... | 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... | 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 alwa... | 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 <- "cleanu... | 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, n... | 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)
... | 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 impleme... | 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.Uni... | 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{
... | 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 := r... | 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... | 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.Tr... | 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++
}... | 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 = ... | 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 i... | 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("DestroyControll... | 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.Faca... | 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 !name... | 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, getC... | 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
... | 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 = metadocTimeTo... | 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{
... | 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: ... | 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... | 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(dbWra... | 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... | 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{
Tool... | 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.Result... | 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)
contin... | 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.Stat... | 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 IA... | 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) != ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.