_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5100 | String | train | func (m stringMap) String() string {
pairs := make([]string, 0, len(*m.mapping))
for name, value := range *m.mapping {
pairs = append(pairs, name+"="+value)
}
return strings.Join(pairs, ";")
} | go | {
"resource": ""
} |
q5101 | CurrentConfig | train | func (a *modelAgent) CurrentConfig() agent.Config {
return &modelAgentConfig{
Config: a.Agent.CurrentConfig(),
modelUUID: a.modelUUID,
controllerUUID: a.controllerUUID,
}
} | go | {
"resource": ""
} |
q5102 | APIInfo | train | func (c *modelAgentConfig) APIInfo() (*api.Info, bool) {
info, ok := c.Config.APIInfo()
if !ok {
return nil, false
}
info.ModelTag = names.NewModelTag(c.modelUUID)
return info, true
} | go | {
"resource": ""
} |
q5103 | NewWorker | train | func NewWorker(config Config) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
paths := NewPaths(config.DataDir, names.NewApplicationTag(config.Application))
deployer, err := jujucharm.NewDeployer(
paths.State.CharmDir,
paths.State.DeployerDir,
jujucharm.New... | go | {
"resource": ""
} |
q5104 | Juju1xEnvConfigExists | train | func Juju1xEnvConfigExists() bool {
dir := OldJujuHomeDir()
if dir == "" {
return false
}
_, err := os.Stat(filepath.Join(dir, "environments.yaml"))
return err == nil
} | go | {
"resource": ""
} |
q5105 | OldJujuHomeDir | train | func OldJujuHomeDir() string {
JujuHomeDir := os.Getenv(oldJujuHomeEnvKey)
if JujuHomeDir == "" {
if runtime.GOOS == "windows" {
JujuHomeDir = oldJujuHomeWin()
} else {
JujuHomeDir = oldJujuHomeLinux()
}
}
return JujuHomeDir
} | go | {
"resource": ""
} |
q5106 | Prune | train | func (s *Facade) Prune(maxHistoryTime time.Duration, maxHistoryMB int) error {
p := params.StatusHistoryPruneArgs{
MaxHistoryTime: maxHistoryTime,
MaxHistoryMB: maxHistoryMB,
}
return s.facade.FacadeCall("Prune", p, nil)
} | go | {
"resource": ""
} |
q5107 | NewMockSummary | train | func NewMockSummary(ctrl *gomock.Controller) *MockSummary {
mock := &MockSummary{ctrl: ctrl}
mock.recorder = &MockSummaryMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q5108 | Collect | train | func (mr *MockSummaryMockRecorder) Collect(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Collect", reflect.TypeOf((*MockSummary)(nil).Collect), arg0)
} | go | {
"resource": ""
} |
q5109 | Observe | train | func (m *MockSummary) Observe(arg0 float64) {
m.ctrl.Call(m, "Observe", arg0)
} | go | {
"resource": ""
} |
q5110 | Handle | train | func (l *handler) Handle(c net.Conn, abort <-chan struct{}) error {
defer c.Close()
// TODO(fwereade): 2016-03-17 lp:1558657
err := c.SetDeadline(time.Now().Add(spool.DefaultTimeout))
if err != nil {
return errors.Annotate(err, "failed to set the deadline")
}
err = l.config.charmdir.Visit(func() error {
ret... | go | {
"resource": ""
} |
q5111 | NewProvisionerWorker | train | func NewProvisionerWorker(config Config) (worker.Worker, error) {
p := &provisioner{
provisionerFacade: config.Facade,
broker: config.Broker,
modelTag: config.ModelTag,
agentConfig: config.AgentConfig,
clock: config.Clock,
}
err := catacomb.Invoke(catacomb.Plan{
Site... | go | {
"resource": ""
} |
q5112 | ensureOperators | train | func (p *provisioner) ensureOperators(apps []string) error {
var appPasswords []apicaasprovisioner.ApplicationPassword
operatorConfig := make([]*caas.OperatorConfig, len(apps))
for i, app := range apps {
opState, err := p.broker.OperatorExists(app)
if err != nil {
return errors.Annotatef(err, "failed to find ... | go | {
"resource": ""
} |
q5113 | Manifold | train | func Manifold(config ManifoldConfig) dependency.Manifold {
return dependency.Manifold{
Inputs: []string{
config.AgentName,
config.ClockName,
config.ControllerPortName,
config.StateName,
},
Start: config.start,
}
} | go | {
"resource": ""
} |
q5114 | Run | train | func (c *enableHACommand) Run(ctx *cmd.Context) error {
controllerName, err := c.ControllerName()
if err != nil {
return errors.Trace(err)
}
if err := common.ValidateIaasController(c.CommandBase, c.Info().Name, controllerName, c.ClientStore()); err != nil {
return errors.Trace(err)
}
c.Constraints, err = com... | go | {
"resource": ""
} |
q5115 | machineTagsToIds | train | func machineTagsToIds(tags ...string) []string {
var result []string
for _, rawTag := range tags {
tag, err := names.ParseTag(rawTag)
if err != nil {
continue
}
result = append(result, tag.Id())
}
return result
} | go | {
"resource": ""
} |
q5116 | OpenResource | train | func (ro *resourceOpener) OpenResource(name string) (o resource.Opened, err error) {
if ro.unit == nil {
return resource.Opened{}, errors.Errorf("missing unit")
}
app, err := ro.unit.Application()
if err != nil {
return resource.Opened{}, errors.Trace(err)
}
cURL, _ := ro.unit.CharmURL()
id := csclient.Charm... | go | {
"resource": ""
} |
q5117 | Validate | train | func (config Config) Validate() error {
if config.Facade == nil {
return errors.NotValidf("nil Facade")
}
if config.CredentialAPI == nil {
return errors.NotValidf("nil CredentialAPI")
}
if config.Destroyer == nil {
return errors.NotValidf("nil Destroyer")
}
return nil
} | go | {
"resource": ""
} |
q5118 | NewUndertaker | train | func NewUndertaker(config Config) (*Undertaker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
u := &Undertaker{
config: config,
}
err := catacomb.Invoke(catacomb.Plan{
Site: &u.catacomb,
Work: u.run,
})
if err != nil {
return nil, errors.Trace(err)
}
u.setCallCtx... | go | {
"resource": ""
} |
q5119 | ImportModel | train | func ImportModel(importer StateImporter, getClaimer ClaimerFunc, bytes []byte) (*state.Model, *state.State, error) {
model, err := description.Deserialize(bytes)
if err != nil {
return nil, nil, errors.Trace(err)
}
dbModel, dbState, err := importer.Import(model)
if err != nil {
return nil, nil, errors.Trace(e... | go | {
"resource": ""
} |
q5120 | Validate | train | func (c *UploadBinariesConfig) Validate() error {
if c.CharmDownloader == nil {
return errors.NotValidf("missing CharmDownloader")
}
if c.CharmUploader == nil {
return errors.NotValidf("missing CharmUploader")
}
if c.ToolsDownloader == nil {
return errors.NotValidf("missing ToolsDownloader")
}
if c.ToolsUp... | go | {
"resource": ""
} |
q5121 | UploadBinaries | train | func UploadBinaries(config UploadBinariesConfig) error {
if err := config.Validate(); err != nil {
return errors.Trace(err)
}
if err := uploadCharms(config); err != nil {
return errors.Trace(err)
}
if err := uploadTools(config); err != nil {
return errors.Trace(err)
}
if err := uploadResources(config); err... | go | {
"resource": ""
} |
q5122 | Recorder | train | func (f *factory) Recorder(declaredMetrics map[string]corecharm.Metric, charmURL, unitTag string) (MetricRecorder, error) {
return NewJSONMetricRecorder(MetricRecorderConfig{
SpoolDir: f.spoolDir,
Metrics: declaredMetrics,
CharmURL: charmURL,
UnitTag: unitTag,
})
} | go | {
"resource": ""
} |
q5123 | Manifold | train | func Manifold(config ManifoldConfig) dependency.Manifold {
manifold := engine.AgentManifold(engine.AgentManifoldConfig(config), newWorker)
manifold.Output = outputFunc
return manifold
} | go | {
"resource": ""
} |
q5124 | newWorker | train | func newWorker(a agent.Agent) (worker.Worker, error) {
metricsSpoolDir := a.CurrentConfig().MetricsSpoolDir()
err := checkSpoolDir(metricsSpoolDir)
if err != nil {
return nil, errors.Annotatef(err, "error checking spool directory %q", metricsSpoolDir)
}
w := &spoolWorker{factory: newFactory(metricsSpoolDir)}
w.... | go | {
"resource": ""
} |
q5125 | FormatPayload | train | func FormatPayload(payload payload.FullPayloadInfo) FormattedPayload {
var labels []string
if len(payload.Labels) > 0 {
labels = make([]string, len(payload.Labels))
copy(labels, payload.Labels)
}
return FormattedPayload{
Unit: payload.Unit,
Machine: payload.Machine,
ID: payload.ID,
Type: payl... | go | {
"resource": ""
} |
q5126 | EnsureCachedImage | train | func (mock *MockContainer) EnsureCachedImage(params kvm.StartParams) error {
imageCacheCalls++
mock.StartParams = params
return nil
} | go | {
"resource": ""
} |
q5127 | Stop | train | func (mock *MockContainer) Stop() error {
if !mock.started {
return fmt.Errorf("container is not running")
}
mock.started = false
mock.factory.notify(Stopped, mock.name)
return nil
} | go | {
"resource": ""
} |
q5128 | SourcePrecheck | train | func SourcePrecheck(
backend PrecheckBackend,
modelPresence ModelPresence,
controllerPresence ModelPresence,
) error {
ctx := precheckContext{backend, modelPresence}
if err := ctx.checkModel(); err != nil {
return errors.Trace(err)
}
if err := ctx.checkMachines(); err != nil {
return errors.Trace(err)
}
... | go | {
"resource": ""
} |
q5129 | TargetPrecheck | train | func TargetPrecheck(backend PrecheckBackend, pool Pool, modelInfo coremigration.ModelInfo, presence ModelPresence) error {
if err := modelInfo.Validate(); err != nil {
return errors.Trace(err)
}
// This check is necessary because there is a window between the
// REAP phase and then end of the DONE phase where a ... | go | {
"resource": ""
} |
q5130 | IsMetricsDataError | train | func IsMetricsDataError(err error) bool {
_, ok := errors.Cause(err).(*errMetricsData)
return ok
} | go | {
"resource": ""
} |
q5131 | APIMetricBatch | train | func APIMetricBatch(batch MetricBatch) params.MetricBatchParam {
metrics := make([]params.Metric, len(batch.Metrics))
for i, metric := range batch.Metrics {
metrics[i] = params.Metric{
Key: metric.Key,
Value: metric.Value,
Time: metric.Time,
Labels: metric.Labels,
}
}
return params.MetricBatch... | go | {
"resource": ""
} |
q5132 | NewJSONMetricRecorder | train | func NewJSONMetricRecorder(config MetricRecorderConfig) (rec *JSONMetricRecorder, rErr error) {
mbUUID, err := utils.NewUUID()
if err != nil {
return nil, errors.Trace(err)
}
recorder := &JSONMetricRecorder{
spoolDir: config.SpoolDir,
uuid: mbUUID,
charmURL: config.CharmURL,
// TODO(fwereade): 2016-0... | go | {
"resource": ""
} |
q5133 | Close | train | func (m *JSONMetricRecorder) Close() error {
m.lock.Lock()
defer m.lock.Unlock()
err := m.file.Close()
if err != nil {
return errors.Trace(err)
}
// We have an exclusive lock on this metric batch here, because
// metricsFile.Close was able to rename the final filename atomically.
//
// Now write the meta f... | go | {
"resource": ""
} |
q5134 | AddMetric | train | func (m *JSONMetricRecorder) AddMetric(
key, value string, created time.Time, labels map[string]string) (err error) {
defer func() {
if err != nil {
err = &errMetricsData{err}
}
}()
err = m.validateMetric(key, value)
if err != nil {
return errors.Trace(err)
}
m.lock.Lock()
defer m.lock.Unlock()
return... | go | {
"resource": ""
} |
q5135 | IsDeclaredMetric | train | func (m *JSONMetricRecorder) IsDeclaredMetric(key string) bool {
_, ok := m.validMetrics[key]
return ok
} | go | {
"resource": ""
} |
q5136 | NewJSONMetricReader | train | func NewJSONMetricReader(spoolDir string) (*JSONMetricReader, error) {
if _, err := os.Stat(spoolDir); err != nil {
return nil, errors.Annotatef(err, "failed to open spool directory %q", spoolDir)
}
return &JSONMetricReader{
dir: spoolDir,
}, nil
} | go | {
"resource": ""
} |
q5137 | Read | train | func (r *JSONMetricReader) Read() (_ []MetricBatch, err error) {
defer func() {
if err != nil {
err = &errMetricsData{err}
}
}()
var batches []MetricBatch
walker := func(path string, info os.FileInfo, err error) error {
if err != nil {
return errors.Trace(err)
}
if info.IsDir() && path != r.dir {
... | go | {
"resource": ""
} |
q5138 | Remove | train | func (r *JSONMetricReader) Remove(uuid string) error {
metaFile := filepath.Join(r.dir, fmt.Sprintf("%s.meta", uuid))
dataFile := filepath.Join(r.dir, uuid)
err := os.Remove(metaFile)
if err != nil && !os.IsNotExist(err) {
return errors.Trace(err)
}
err = os.Remove(dataFile)
if err != nil {
return errors.Tra... | go | {
"resource": ""
} |
q5139 | AddPendingResources | train | func (cl *deployClient) AddPendingResources(applicationID string, chID charmstore.CharmID, csMac *macaroon.Macaroon, resources []charmresource.Resource) ([]string, error) {
return cl.Client.AddPendingResources(client.AddPendingResourcesArgs{
ApplicationID: applicationID,
CharmID: chID,
CharmStore... | go | {
"resource": ""
} |
q5140 | checkOperation | train | func (rc *rawConn) checkOperation(projectID string, op *compute.Operation) (*compute.Operation, error) {
var call opDoer
if op.Zone != "" {
zoneName := path.Base(op.Zone)
call = rc.ZoneOperations.Get(projectID, zoneName, op.Name)
} else if op.Region != "" {
region := path.Base(op.Region)
call = rc.RegionOper... | go | {
"resource": ""
} |
q5141 | ListMachineTypes | train | func (rc *rawConn) ListMachineTypes(projectID, zone string) (*compute.MachineTypeList, error) {
op := rc.MachineTypes.List(projectID, zone)
machines, err := op.Do()
if err != nil {
return nil, errors.Annotatef(err, "listing machine types for project %q and zone %q", projectID, zone)
}
return machines, nil
} | go | {
"resource": ""
} |
q5142 | Validate | train | func (c *Config) Validate() error {
if c.Logger == nil {
return errors.NotValidf("missing logger")
}
if c.WatcherFactory == nil {
return errors.NotValidf("missing watcher factory")
}
if c.PrometheusRegisterer == nil {
return errors.NotValidf("missing prometheus registerer")
}
if c.Cleanup == nil {
return... | go | {
"resource": ""
} |
q5143 | NewWorker | train | func NewWorker(config Config) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
w := &cacheWorker{
config: config,
changes: make(chan interface{}),
}
controller, err := cache.NewController(
cache.ControllerConfig{
Changes: w.changes,
Notify: config.N... | go | {
"resource": ""
} |
q5144 | runForAllModelStates | train | func runForAllModelStates(pool *StatePool, runner func(st *State) error) error {
st := pool.SystemState()
models, closer := st.db().GetCollection(modelsC)
defer closer()
var modelDocs []bson.M
err := models.Find(nil).Select(bson.M{"_id": 1}).All(&modelDocs)
if err != nil {
return errors.Annotate(err, "failed t... | go | {
"resource": ""
} |
q5145 | readBsonDField | train | func readBsonDField(d bson.D, name string) (interface{}, bool) {
for i := range d {
field := &d[i]
if field.Name == name {
return field.Value, true
}
}
return nil, false
} | go | {
"resource": ""
} |
q5146 | replaceBsonDField | train | func replaceBsonDField(d bson.D, name string, value interface{}) error {
for i, field := range d {
if field.Name == name {
newField := field
newField.Value = value
d[i] = newField
return nil
}
}
return errors.NotFoundf("field %q", name)
} | go | {
"resource": ""
} |
q5147 | RenameAddModelPermission | train | func RenameAddModelPermission(pool *StatePool) error {
st := pool.SystemState()
coll, closer := st.db().GetRawCollection(permissionsC)
defer closer()
upgradesLogger.Infof("migrating addmodel permission")
iter := coll.Find(bson.M{"access": "addmodel"}).Iter()
defer iter.Close()
var ops []txn.Op
var doc bson.M
... | go | {
"resource": ""
} |
q5148 | StripLocalUserDomain | train | func StripLocalUserDomain(pool *StatePool) error {
st := pool.SystemState()
var ops []txn.Op
more, err := stripLocalFromFields(st, cloudCredentialsC, "_id", "owner")
if err != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, modelsC, "owner", "cloud-credential")
if err != ni... | go | {
"resource": ""
} |
q5149 | AddMigrationAttempt | train | func AddMigrationAttempt(pool *StatePool) error {
st := pool.SystemState()
coll, closer := st.db().GetRawCollection(migrationsC)
defer closer()
query := coll.Find(bson.M{"attempt": bson.M{"$exists": false}})
query = query.Select(bson.M{"_id": 1})
iter := query.Iter()
defer iter.Close()
var ops []txn.Op
var do... | go | {
"resource": ""
} |
q5150 | AddLocalCharmSequences | train | func AddLocalCharmSequences(pool *StatePool) error {
st := pool.SystemState()
charmsColl, closer := st.db().GetRawCollection(charmsC)
defer closer()
query := bson.M{
"url": bson.M{"$regex": "^local:"},
}
var docs []bson.M
err := charmsColl.Find(query).Select(bson.M{
"_id": 1,
"life": 1,
}).All(&docs)
i... | go | {
"resource": ""
} |
q5151 | UpdateLegacyLXDCloudCredentials | train | func UpdateLegacyLXDCloudCredentials(
st *State,
endpoint string,
credential cloud.Credential,
) error {
cloudOps, err := updateLegacyLXDCloudsOps(st, endpoint)
if err != nil {
return errors.Trace(err)
}
credOps, err := updateLegacyLXDCredentialsOps(st, credential)
if err != nil {
return errors.Trace(err)
... | go | {
"resource": ""
} |
q5152 | UpgradeNoProxyDefaults | train | func UpgradeNoProxyDefaults(pool *StatePool) error {
st := pool.SystemState()
var ops []txn.Op
coll, closer := st.db().GetRawCollection(settingsC)
defer closer()
iter := coll.Find(bson.D{}).Iter()
defer iter.Close()
var doc settingsDoc
for iter.Next(&doc) {
noProxyVal := doc.Settings[config.NoProxyKey]
noPr... | go | {
"resource": ""
} |
q5153 | RemoveNilValueApplicationSettings | train | func RemoveNilValueApplicationSettings(pool *StatePool) error {
st := pool.SystemState()
coll, closer := st.db().GetRawCollection(settingsC)
defer closer()
iter := coll.Find(bson.M{"_id": bson.M{"$regex": "^.*:a#.*"}}).Iter()
defer iter.Close()
var ops []txn.Op
var doc settingsDoc
for iter.Next(&doc) {
settin... | go | {
"resource": ""
} |
q5154 | AddControllerLogCollectionsSizeSettings | train | func AddControllerLogCollectionsSizeSettings(pool *StatePool) error {
st := pool.SystemState()
coll, closer := st.db().GetRawCollection(controllersC)
defer closer()
var doc settingsDoc
if err := coll.FindId(controllerSettingsGlobalKey).One(&doc); err != nil {
if err == mgo.ErrNotFound {
return nil
}
retur... | go | {
"resource": ""
} |
q5155 | applyToAllModelSettings | train | func applyToAllModelSettings(st *State, change func(*settingsDoc) (bool, error)) error {
uuids, err := st.AllModelUUIDs()
if err != nil {
return errors.Trace(err)
}
coll, closer := st.db().GetRawCollection(settingsC)
defer closer()
var ids []string
for _, uuid := range uuids {
ids = append(ids, uuid+":e")
... | go | {
"resource": ""
} |
q5156 | AddStatusHistoryPruneSettings | train | func AddStatusHistoryPruneSettings(pool *StatePool) error {
st := pool.SystemState()
err := applyToAllModelSettings(st, func(doc *settingsDoc) (bool, error) {
settingsChanged :=
maybeUpdateSettings(doc.Settings, config.MaxStatusHistoryAge, config.DefaultStatusHistoryAge)
settingsChanged =
maybeUpdateSetting... | go | {
"resource": ""
} |
q5157 | AddActionPruneSettings | train | func AddActionPruneSettings(pool *StatePool) error {
st := pool.SystemState()
err := applyToAllModelSettings(st, func(doc *settingsDoc) (bool, error) {
settingsChanged :=
maybeUpdateSettings(doc.Settings, config.MaxActionResultsAge, config.DefaultActionResultsAge)
settingsChanged =
maybeUpdateSettings(doc.S... | go | {
"resource": ""
} |
q5158 | AddUpdateStatusHookSettings | train | func AddUpdateStatusHookSettings(pool *StatePool) error {
st := pool.SystemState()
err := applyToAllModelSettings(st, func(doc *settingsDoc) (bool, error) {
settingsChanged :=
maybeUpdateSettings(doc.Settings, config.UpdateStatusHookInterval, config.DefaultUpdateStatusHookInterval)
return settingsChanged, nil
... | go | {
"resource": ""
} |
q5159 | SplitLogCollections | train | func SplitLogCollections(pool *StatePool) error {
st := pool.SystemState()
session := st.MongoSession()
db := session.DB(logsDB)
oldLogs := db.C("logs")
// If we haven't seen any particular model, we need to initialise
// the logs collection with the right indices.
seen := set.NewStrings()
iter := oldLogs.Fin... | go | {
"resource": ""
} |
q5160 | MoveOldAuditLog | train | func MoveOldAuditLog(pool *StatePool) error {
st := pool.SystemState()
names, err := st.MongoSession().DB("juju").CollectionNames()
if err != nil {
return errors.Trace(err)
}
if !set.NewStrings(names...).Contains("audit.log") {
// No audit log collection to move.
return nil
}
coll, closer := st.db().GetRa... | go | {
"resource": ""
} |
q5161 | DeleteCloudImageMetadata | train | func DeleteCloudImageMetadata(pool *StatePool) error {
st := pool.SystemState()
coll, closer := st.db().GetRawCollection(cloudimagemetadataC)
defer closer()
bulk := coll.Bulk()
bulk.Unordered()
bulk.RemoveAll(bson.D{{"source", bson.D{{"$ne", "custom"}}}})
_, err := bulk.Run()
return errors.Annotate(err, "delet... | go | {
"resource": ""
} |
q5162 | MoveMongoSpaceToHASpaceConfig | train | func MoveMongoSpaceToHASpaceConfig(pool *StatePool) error {
st := pool.SystemState()
// Holds Mongo space fields removed from controllersDoc.
type controllersUpgradeDoc struct {
MongoSpaceName string `bson:"mongo-space-name"`
MongoSpaceState string `bson:"mongo-space-state"`
}
var doc controllersUpgradeDoc
... | go | {
"resource": ""
} |
q5163 | CreateMissingApplicationConfig | train | func CreateMissingApplicationConfig(pool *StatePool) error {
st := pool.SystemState()
settingsColl, settingsCloser := st.db().GetRawCollection(settingsC)
defer settingsCloser()
var applicationConfigIDs []struct {
ID string `bson:"_id"`
}
settingsColl.Find(bson.M{
"_id": bson.M{"$regex": bson.RegEx{"#applicat... | go | {
"resource": ""
} |
q5164 | RemoveVotingMachineIds | train | func RemoveVotingMachineIds(pool *StatePool) error {
st := pool.SystemState()
controllerColl, controllerCloser := st.db().GetRawCollection(controllersC)
defer controllerCloser()
// The votingmachineids field is just a denormalization of Machine.WantsVote() so we can just
// remove it as being redundant
err := con... | go | {
"resource": ""
} |
q5165 | AddCloudModelCounts | train | func AddCloudModelCounts(pool *StatePool) error {
st := pool.SystemState()
cloudsColl, closer := st.db().GetCollection(cloudsC)
defer closer()
var clouds []cloudDoc
err := cloudsColl.Find(nil).All(&clouds)
if err != nil {
return errors.Trace(err)
}
modelsColl, closer := st.db().GetCollection(modelsC)
defer... | go | {
"resource": ""
} |
q5166 | UpgradeContainerImageStreamDefault | train | func UpgradeContainerImageStreamDefault(pool *StatePool) error {
st := pool.SystemState()
err := applyToAllModelSettings(st, func(doc *settingsDoc) (bool, error) {
ciStreamVal, keySet := doc.Settings[config.ContainerImageStreamKey]
if keySet {
if ciStream, _ := ciStreamVal.(string); ciStream != "" {
return... | go | {
"resource": ""
} |
q5167 | ReplicaSetMembers | train | func ReplicaSetMembers(pool *StatePool) ([]replicaset.Member, error) {
return replicaset.CurrentMembers(pool.SystemState().MongoSession())
} | go | {
"resource": ""
} |
q5168 | LegacyLeases | train | func LegacyLeases(pool *StatePool, localTime time.Time) (map[corelease.Key]corelease.Info, error) {
st := pool.SystemState()
reader, err := globalclock.NewReader(globalclock.ReaderConfig{
Config: globalclock.Config{
Collection: globalClockC,
Mongo: &environMongo{state: st},
},
})
if err != nil {
re... | go | {
"resource": ""
} |
q5169 | MigrateAddModelPermissions | train | func MigrateAddModelPermissions(pool *StatePool) error {
st := pool.SystemState()
controllerInfo, err := st.ControllerInfo()
if err != nil {
return errors.Trace(err)
}
coll, closer := st.db().GetRawCollection(permissionsC)
defer closer()
query := bson.M{
"_id": bson.M{"$regex": "^" + controllerKey(st.Con... | go | {
"resource": ""
} |
q5170 | SetEnableDiskUUIDOnVsphere | train | func SetEnableDiskUUIDOnVsphere(pool *StatePool) error {
return errors.Trace(applyToAllModelSettings(pool.SystemState(), func(doc *settingsDoc) (bool, error) {
typeVal, found := doc.Settings["type"]
if !found {
return false, nil
}
typeStr, ok := typeVal.(string)
if !ok || typeStr != "vsphere" {
return ... | go | {
"resource": ""
} |
q5171 | UpdateInheritedControllerConfig | train | func UpdateInheritedControllerConfig(pool *StatePool) error {
st := pool.SystemState()
model, err := st.Model()
if err != nil {
return errors.Trace(err)
}
key := cloudGlobalKey(model.Cloud())
var ops []txn.Op
coll, closer := st.db().GetRawCollection(globalSettingsC)
defer closer()
iter := coll.FindId("contr... | go | {
"resource": ""
} |
q5172 | EnsureDefaultModificationStatus | train | func EnsureDefaultModificationStatus(pool *StatePool) error {
st := pool.SystemState()
db := st.db()
machineCol, machineCloser := db.GetRawCollection(machinesC)
defer machineCloser()
machineIter := machineCol.Find(nil).Iter()
defer machineIter.Close()
statusCol, statusCloser := db.GetRawCollection(statusesC)
... | go | {
"resource": ""
} |
q5173 | EnsureApplicationDeviceConstraints | train | func EnsureApplicationDeviceConstraints(pool *StatePool) error {
st := pool.SystemState()
db := st.db()
applicationCol, applicationCloser := db.GetRawCollection(applicationsC)
defer applicationCloser()
applicationIter := applicationCol.Find(nil).Iter()
defer applicationIter.Close()
constraintsCol, constraintsC... | go | {
"resource": ""
} |
q5174 | RemoveInstanceCharmProfileDataCollection | train | func RemoveInstanceCharmProfileDataCollection(pool *StatePool) error {
db := pool.SystemState().MongoSession().DB(jujuDB)
instanceCharmProfileData := db.C("instanceCharmProfileData")
if err := instanceCharmProfileData.DropCollection(); err != nil {
// If the namespace is already missing, that's fine.
if isMgoNam... | go | {
"resource": ""
} |
q5175 | CreateVolumes | train | func (s *VolumeSource) CreateVolumes(ctx context.ProviderCallContext, params []storage.VolumeParams) ([]storage.CreateVolumesResult, error) {
s.MethodCall(s, "CreateVolumes", ctx, params)
if s.CreateVolumesFunc != nil {
return s.CreateVolumesFunc(ctx, params)
}
return nil, errors.NotImplementedf("CreateVolumes")
... | go | {
"resource": ""
} |
q5176 | ListVolumes | train | func (s *VolumeSource) ListVolumes(ctx context.ProviderCallContext) ([]string, error) {
s.MethodCall(s, "ListVolumes", ctx)
if s.ListVolumesFunc != nil {
return s.ListVolumesFunc(ctx)
}
return nil, nil
} | go | {
"resource": ""
} |
q5177 | DescribeVolumes | train | func (s *VolumeSource) DescribeVolumes(ctx context.ProviderCallContext, volIds []string) ([]storage.DescribeVolumesResult, error) {
s.MethodCall(s, "DescribeVolumes", ctx, volIds)
if s.DescribeVolumesFunc != nil {
return s.DescribeVolumesFunc(ctx, volIds)
}
return nil, errors.NotImplementedf("DescribeVolumes")
} | go | {
"resource": ""
} |
q5178 | DestroyVolumes | train | func (s *VolumeSource) DestroyVolumes(ctx context.ProviderCallContext, volIds []string) ([]error, error) {
s.MethodCall(s, "DestroyVolumes", ctx, volIds)
if s.DestroyVolumesFunc != nil {
return s.DestroyVolumesFunc(ctx, volIds)
}
return nil, errors.NotImplementedf("DestroyVolumes")
} | go | {
"resource": ""
} |
q5179 | ReleaseVolumes | train | func (s *VolumeSource) ReleaseVolumes(ctx context.ProviderCallContext, volIds []string) ([]error, error) {
s.MethodCall(s, "ReleaseVolumes", ctx, volIds)
if s.ReleaseVolumesFunc != nil {
return s.ReleaseVolumesFunc(ctx, volIds)
}
return nil, errors.NotImplementedf("ReleaseVolumes")
} | go | {
"resource": ""
} |
q5180 | ValidateVolumeParams | train | func (s *VolumeSource) ValidateVolumeParams(params storage.VolumeParams) error {
s.MethodCall(s, "ValidateVolumeParams", params)
if s.ValidateVolumeParamsFunc != nil {
return s.ValidateVolumeParamsFunc(params)
}
return nil
} | go | {
"resource": ""
} |
q5181 | AttachVolumes | train | func (s *VolumeSource) AttachVolumes(ctx context.ProviderCallContext, params []storage.VolumeAttachmentParams) ([]storage.AttachVolumesResult, error) {
s.MethodCall(s, "AttachVolumes", ctx, params)
if s.AttachVolumesFunc != nil {
return s.AttachVolumesFunc(ctx, params)
}
return nil, errors.NotImplementedf("Attach... | go | {
"resource": ""
} |
q5182 | DetachVolumes | train | func (s *VolumeSource) DetachVolumes(ctx context.ProviderCallContext, params []storage.VolumeAttachmentParams) ([]error, error) {
s.MethodCall(s, "DetachVolumes", ctx, params)
if s.DetachVolumesFunc != nil {
return s.DetachVolumesFunc(ctx, params)
}
return nil, errors.NotImplementedf("DetachVolumes")
} | go | {
"resource": ""
} |
q5183 | NewAgentEntityWatcher | train | func NewAgentEntityWatcher(st state.EntityFinder, resources facade.Resources, getCanWatch GetAuthFunc) *AgentEntityWatcher {
return &AgentEntityWatcher{
st: st,
resources: resources,
getCanWatch: getCanWatch,
}
} | go | {
"resource": ""
} |
q5184 | Watch | train | func (a *AgentEntityWatcher) Watch(args params.Entities) (params.NotifyWatchResults, error) {
result := params.NotifyWatchResults{
Results: make([]params.NotifyWatchResult, len(args.Entities)),
}
if len(args.Entities) == 0 {
return result, nil
}
canWatch, err := a.getCanWatch()
if err != nil {
return params... | go | {
"resource": ""
} |
q5185 | dumpMetadata | train | func (c *CommandBase) dumpMetadata(ctx *cmd.Context, result *params.BackupsMetadataResult) {
// TODO: (hml) 2018-04-26
// fix how --quiet and --verbose are handled with backup/restore commands
// should be ctx.Verbosef() here
fmt.Fprintf(ctx.Stdout, "backup ID: %q\n", result.ID)
fmt.Fprintf(ctx.Stdout, "chec... | go | {
"resource": ""
} |
q5186 | Validate | train | func (cfg ProviderConfig) Validate() error {
if cfg.NewStorageClient == nil {
return errors.NotValidf("nil NewStorageClient")
}
if cfg.RetryClock == nil {
return errors.NotValidf("nil RetryClock")
}
if cfg.RandomWindowsAdminPassword == nil {
return errors.NotValidf("nil RandomWindowsAdminPassword")
}
if cf... | go | {
"resource": ""
} |
q5187 | NewEnvironProvider | train | func NewEnvironProvider(config ProviderConfig) (*azureEnvironProvider, error) {
if err := config.Validate(); err != nil {
return nil, errors.Annotate(err, "validating environ provider configuration")
}
return &azureEnvironProvider{
environProviderCredentials: environProviderCredentials{
servicePrincipalCreato... | go | {
"resource": ""
} |
q5188 | NewLeadershipPinningAPI | train | func NewLeadershipPinningAPI(caller base.APICaller) *LeadershipPinningAPI {
facadeCaller := base.NewFacadeCaller(
caller,
leadershipFacade,
)
return NewLeadershipPinningAPIFromFacade(facadeCaller)
} | go | {
"resource": ""
} |
q5189 | PinnedLeadership | train | func (a *LeadershipPinningAPI) PinnedLeadership() (map[string][]names.Tag, error) {
var callResult params.PinnedLeadershipResult
err := a.facade.FacadeCall("PinnedLeadership", nil, &callResult)
if err != nil {
return nil, errors.Trace(err)
}
pinned := make(map[string][]names.Tag, len(callResult.Result))
for ap... | go | {
"resource": ""
} |
q5190 | PinMachineApplications | train | func (a *LeadershipPinningAPI) PinMachineApplications() (map[string]error, error) {
res, err := a.pinMachineAppsOps("PinMachineApplications")
return res, errors.Trace(err)
} | go | {
"resource": ""
} |
q5191 | pinMachineAppsOps | train | func (a *LeadershipPinningAPI) pinMachineAppsOps(callName string) (map[string]error, error) {
var callResult params.PinApplicationsResults
err := a.facade.FacadeCall(callName, nil, &callResult)
if err != nil {
return nil, errors.Trace(err)
}
callResults := callResult.Results
result := make(map[string]error, le... | go | {
"resource": ""
} |
q5192 | NewUniterResolver | train | func NewUniterResolver(cfg ResolverConfig) resolver.Resolver {
return &uniterResolver{
config: cfg,
retryHookTimerStarted: false,
}
} | go | {
"resource": ""
} |
q5193 | nextOpConflicted | train | func (s *uniterResolver) nextOpConflicted(
localState resolver.LocalState,
remoteState remotestate.Snapshot,
opFactory operation.Factory,
) (operation.Operation, error) {
if remoteState.ResolvedMode != params.ResolvedNone {
if err := s.config.ClearResolved(); err != nil {
return nil, errors.Trace(err)
}
re... | go | {
"resource": ""
} |
q5194 | NextOp | train | func (NopResolver) NextOp(resolver.LocalState, remotestate.Snapshot, operation.Factory) (operation.Operation, error) {
return nil, resolver.ErrNoOperation
} | go | {
"resource": ""
} |
q5195 | Lockdown | train | func (f *fortress) Lockdown(abort Abort) error {
return f.allowGuests(false, abort)
} | go | {
"resource": ""
} |
q5196 | Visit | train | func (f *fortress) Visit(visit Visit, abort Abort) error {
result := make(chan error)
select {
case <-f.tomb.Dying():
return ErrShutdown
case <-abort:
return ErrAborted
case f.guestTickets <- guestTicket{visit, result}:
return <-result
}
} | go | {
"resource": ""
} |
q5197 | allowGuests | train | func (f *fortress) allowGuests(allowGuests bool, abort Abort) error {
result := make(chan error)
select {
case <-f.tomb.Dying():
return ErrShutdown
case f.guardTickets <- guardTicket{allowGuests, abort, result}:
return <-result
}
} | go | {
"resource": ""
} |
q5198 | loop | train | func (f *fortress) loop() error {
var active sync.WaitGroup
defer active.Wait()
// guestTickets will be set on Unlock and cleared at the start of Lockdown.
var guestTickets <-chan guestTicket
for {
select {
case <-f.tomb.Dying():
return tomb.ErrDying
case ticket := <-guestTickets:
active.Add(1)
go ... | go | {
"resource": ""
} |
q5199 | GenerateClientCertificate | train | func GenerateClientCertificate() (*Certificate, error) {
cert, key, err := shared.GenerateMemCert(true)
if err != nil {
return nil, errors.Trace(err)
}
return NewCertificate(cert, key), nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.