id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
5,100 | juju/juju | cmd/juju/application/flags.go | String | 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 | 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, ";")
} | [
"func",
"(",
"m",
"stringMap",
")",
"String",
"(",
")",
"string",
"{",
"pairs",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"*",
"m",
".",
"mapping",
")",
")",
"\n",
"for",
"name",
",",
"value",
":=",
"range",
"*",
"m",
... | // String implements gnuflag.Value's String method | [
"String",
"implements",
"gnuflag",
".",
"Value",
"s",
"String",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/application/flags.go#L196-L202 |
5,101 | juju/juju | cmd/jujud/agent/model/agent.go | CurrentConfig | func (a *modelAgent) CurrentConfig() agent.Config {
return &modelAgentConfig{
Config: a.Agent.CurrentConfig(),
modelUUID: a.modelUUID,
controllerUUID: a.controllerUUID,
}
} | go | func (a *modelAgent) CurrentConfig() agent.Config {
return &modelAgentConfig{
Config: a.Agent.CurrentConfig(),
modelUUID: a.modelUUID,
controllerUUID: a.controllerUUID,
}
} | [
"func",
"(",
"a",
"*",
"modelAgent",
")",
"CurrentConfig",
"(",
")",
"agent",
".",
"Config",
"{",
"return",
"&",
"modelAgentConfig",
"{",
"Config",
":",
"a",
".",
"Agent",
".",
"CurrentConfig",
"(",
")",
",",
"modelUUID",
":",
"a",
".",
"modelUUID",
",... | // CurrentConfig is part of the agent.Agent interface. This implementation
// returns an agent.Config that reports tweaked API connection information. | [
"CurrentConfig",
"is",
"part",
"of",
"the",
"agent",
".",
"Agent",
"interface",
".",
"This",
"implementation",
"returns",
"an",
"agent",
".",
"Config",
"that",
"reports",
"tweaked",
"API",
"connection",
"information",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/model/agent.go#L47-L53 |
5,102 | juju/juju | cmd/jujud/agent/model/agent.go | APIInfo | 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 | 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
} | [
"func",
"(",
"c",
"*",
"modelAgentConfig",
")",
"APIInfo",
"(",
")",
"(",
"*",
"api",
".",
"Info",
",",
"bool",
")",
"{",
"info",
",",
"ok",
":=",
"c",
".",
"Config",
".",
"APIInfo",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
... | // APIInfo is part of the agent.Config interface. This implementation always
// replaces the target model tag with the configured model tag. | [
"APIInfo",
"is",
"part",
"of",
"the",
"agent",
".",
"Config",
"interface",
".",
"This",
"implementation",
"always",
"replaces",
"the",
"target",
"model",
"tag",
"with",
"the",
"configured",
"model",
"tag",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/model/agent.go#L75-L82 |
5,103 | juju/juju | worker/caasoperator/caasoperator.go | NewWorker | 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.NewBundlesDir(paths.State.BundlesDir, config.Downloader),
)
if err != nil {
return nil, errors.Annotatef(err, "cannot create deployer")
}
op := &caasOperator{
config: config,
paths: paths,
deployer: deployer,
runner: worker.NewRunner(worker.RunnerParams{
Clock: config.Clock,
// One of the uniter workers failing should not
// prevent the others from running.
IsFatal: func(error) bool { return false },
// For any failures, try again in 3 seconds.
RestartDelay: 3 * time.Second,
}),
}
if err := catacomb.Invoke(catacomb.Plan{
Site: &op.catacomb,
Work: op.loop,
Init: []worker.Worker{op.runner},
}); err != nil {
return nil, errors.Trace(err)
}
return op, nil
} | go | 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.NewBundlesDir(paths.State.BundlesDir, config.Downloader),
)
if err != nil {
return nil, errors.Annotatef(err, "cannot create deployer")
}
op := &caasOperator{
config: config,
paths: paths,
deployer: deployer,
runner: worker.NewRunner(worker.RunnerParams{
Clock: config.Clock,
// One of the uniter workers failing should not
// prevent the others from running.
IsFatal: func(error) bool { return false },
// For any failures, try again in 3 seconds.
RestartDelay: 3 * time.Second,
}),
}
if err := catacomb.Invoke(catacomb.Plan{
Site: &op.catacomb,
Work: op.loop,
Init: []worker.Worker{op.runner},
}); err != nil {
return nil, errors.Trace(err)
}
return op, nil
} | [
"func",
"NewWorker",
"(",
"config",
"Config",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",... | // NewWorker creates a new worker which will install and operate a
// CaaS-based application, by executing hooks and operations in
// response to application state changes. | [
"NewWorker",
"creates",
"a",
"new",
"worker",
"which",
"will",
"install",
"and",
"operate",
"a",
"CaaS",
"-",
"based",
"application",
"by",
"executing",
"hooks",
"and",
"operations",
"in",
"response",
"to",
"application",
"state",
"changes",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/caasoperator/caasoperator.go#L163-L200 |
5,104 | juju/juju | juju/osenv/old_home.go | Juju1xEnvConfigExists | func Juju1xEnvConfigExists() bool {
dir := OldJujuHomeDir()
if dir == "" {
return false
}
_, err := os.Stat(filepath.Join(dir, "environments.yaml"))
return err == nil
} | go | func Juju1xEnvConfigExists() bool {
dir := OldJujuHomeDir()
if dir == "" {
return false
}
_, err := os.Stat(filepath.Join(dir, "environments.yaml"))
return err == nil
} | [
"func",
"Juju1xEnvConfigExists",
"(",
")",
"bool",
"{",
"dir",
":=",
"OldJujuHomeDir",
"(",
")",
"\n",
"if",
"dir",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"... | // Juju1xEnvConfigExists returns true if there is an environments.yaml file in
// the expected juju 1.x directory. | [
"Juju1xEnvConfigExists",
"returns",
"true",
"if",
"there",
"is",
"an",
"environments",
".",
"yaml",
"file",
"in",
"the",
"expected",
"juju",
"1",
".",
"x",
"directory",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/juju/osenv/old_home.go#L16-L23 |
5,105 | juju/juju | juju/osenv/old_home.go | OldJujuHomeDir | func OldJujuHomeDir() string {
JujuHomeDir := os.Getenv(oldJujuHomeEnvKey)
if JujuHomeDir == "" {
if runtime.GOOS == "windows" {
JujuHomeDir = oldJujuHomeWin()
} else {
JujuHomeDir = oldJujuHomeLinux()
}
}
return JujuHomeDir
} | go | func OldJujuHomeDir() string {
JujuHomeDir := os.Getenv(oldJujuHomeEnvKey)
if JujuHomeDir == "" {
if runtime.GOOS == "windows" {
JujuHomeDir = oldJujuHomeWin()
} else {
JujuHomeDir = oldJujuHomeLinux()
}
}
return JujuHomeDir
} | [
"func",
"OldJujuHomeDir",
"(",
")",
"string",
"{",
"JujuHomeDir",
":=",
"os",
".",
"Getenv",
"(",
"oldJujuHomeEnvKey",
")",
"\n",
"if",
"JujuHomeDir",
"==",
"\"",
"\"",
"{",
"if",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"{",
"JujuHomeDir",
"=",
"oldJuj... | // OldJujuHomeDir returns the directory where juju 1.x stored
// application-specific files. | [
"OldJujuHomeDir",
"returns",
"the",
"directory",
"where",
"juju",
"1",
".",
"x",
"stored",
"application",
"-",
"specific",
"files",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/juju/osenv/old_home.go#L34-L44 |
5,106 | juju/juju | api/statushistory/pruner.go | Prune | 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 | func (s *Facade) Prune(maxHistoryTime time.Duration, maxHistoryMB int) error {
p := params.StatusHistoryPruneArgs{
MaxHistoryTime: maxHistoryTime,
MaxHistoryMB: maxHistoryMB,
}
return s.facade.FacadeCall("Prune", p, nil)
} | [
"func",
"(",
"s",
"*",
"Facade",
")",
"Prune",
"(",
"maxHistoryTime",
"time",
".",
"Duration",
",",
"maxHistoryMB",
"int",
")",
"error",
"{",
"p",
":=",
"params",
".",
"StatusHistoryPruneArgs",
"{",
"MaxHistoryTime",
":",
"maxHistoryTime",
",",
"MaxHistoryMB",... | // Prune calls "StatusHistory.Prune" | [
"Prune",
"calls",
"StatusHistory",
".",
"Prune"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/statushistory/pruner.go#L29-L35 |
5,107 | juju/juju | apiserver/observer/metricobserver/mocks/metrics_mock.go | NewMockSummary | func NewMockSummary(ctrl *gomock.Controller) *MockSummary {
mock := &MockSummary{ctrl: ctrl}
mock.recorder = &MockSummaryMockRecorder{mock}
return mock
} | go | func NewMockSummary(ctrl *gomock.Controller) *MockSummary {
mock := &MockSummary{ctrl: ctrl}
mock.recorder = &MockSummaryMockRecorder{mock}
return mock
} | [
"func",
"NewMockSummary",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockSummary",
"{",
"mock",
":=",
"&",
"MockSummary",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockSummaryMockRecorder",
"{",
"mock",
"}",
... | // NewMockSummary creates a new mock instance | [
"NewMockSummary",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/observer/metricobserver/mocks/metrics_mock.go#L113-L117 |
5,108 | juju/juju | apiserver/observer/metricobserver/mocks/metrics_mock.go | Collect | func (mr *MockSummaryMockRecorder) Collect(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Collect", reflect.TypeOf((*MockSummary)(nil).Collect), arg0)
} | go | func (mr *MockSummaryMockRecorder) Collect(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Collect", reflect.TypeOf((*MockSummary)(nil).Collect), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockSummaryMockRecorder",
")",
"Collect",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"... | // Collect indicates an expected call of Collect | [
"Collect",
"indicates",
"an",
"expected",
"call",
"of",
"Collect"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/observer/metricobserver/mocks/metrics_mock.go#L130-L132 |
5,109 | juju/juju | apiserver/observer/metricobserver/mocks/metrics_mock.go | Observe | func (m *MockSummary) Observe(arg0 float64) {
m.ctrl.Call(m, "Observe", arg0)
} | go | func (m *MockSummary) Observe(arg0 float64) {
m.ctrl.Call(m, "Observe", arg0)
} | [
"func",
"(",
"m",
"*",
"MockSummary",
")",
"Observe",
"(",
"arg0",
"float64",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"}"
] | // Observe mocks base method | [
"Observe",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/observer/metricobserver/mocks/metrics_mock.go#L157-L159 |
5,110 | juju/juju | worker/metrics/collect/handler.go | Handle | 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 {
return l.do(c)
}, abort)
if err != nil {
fmt.Fprintf(c, "error: %v\n", err.Error())
} else {
fmt.Fprintf(c, "ok\n")
}
return errors.Trace(err)
} | go | 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 {
return l.do(c)
}, abort)
if err != nil {
fmt.Fprintf(c, "error: %v\n", err.Error())
} else {
fmt.Fprintf(c, "ok\n")
}
return errors.Trace(err)
} | [
"func",
"(",
"l",
"*",
"handler",
")",
"Handle",
"(",
"c",
"net",
".",
"Conn",
",",
"abort",
"<-",
"chan",
"struct",
"{",
"}",
")",
"error",
"{",
"defer",
"c",
".",
"Close",
"(",
")",
"\n\n",
"// TODO(fwereade): 2016-03-17 lp:1558657",
"err",
":=",
"c"... | // Handle triggers the collect-metrics hook and writes collected metrics
// to the specified connection. | [
"Handle",
"triggers",
"the",
"collect",
"-",
"metrics",
"hook",
"and",
"writes",
"collected",
"metrics",
"to",
"the",
"specified",
"connection",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/collect/handler.go#L39-L57 |
5,111 | juju/juju | worker/caasoperatorprovisioner/worker.go | NewProvisionerWorker | 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: &p.catacomb,
Work: p.loop,
})
return p, err
} | go | 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: &p.catacomb,
Work: p.loop,
})
return p, err
} | [
"func",
"NewProvisionerWorker",
"(",
"config",
"Config",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"p",
":=",
"&",
"provisioner",
"{",
"provisionerFacade",
":",
"config",
".",
"Facade",
",",
"broker",
":",
"config",
".",
"Broker",
",",
"... | // NewProvisionerWorker starts and returns a new CAAS provisioner worker. | [
"NewProvisionerWorker",
"starts",
"and",
"returns",
"a",
"new",
"CAAS",
"provisioner",
"worker",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/caasoperatorprovisioner/worker.go#L49-L62 |
5,112 | juju/juju | worker/caasoperatorprovisioner/worker.go | ensureOperators | 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 operator for %q", app)
}
if opState.Exists && opState.Terminating {
// We can't deploy an app while a previous version is terminating.
// TODO(caas) - the remove application process should block until app terminated
// TODO(caas) - consider making this async, but ok for now as it's a corner case
if err := p.waitForOperatorTerminated(app); err != nil {
return errors.Annotatef(err, "operator for %q was terminating and there was an error waiting for it to stop", app)
}
opState.Exists = false
}
// If the operator does not exist already, we need to create an initial
// password for it.
var password string
if !opState.Exists {
if password, err = utils.RandomPassword(); err != nil {
return errors.Trace(err)
}
appPasswords = append(appPasswords, apicaasprovisioner.ApplicationPassword{Name: app, Password: password})
}
config, err := p.makeOperatorConfig(app, password)
if err != nil {
return errors.Annotatef(err, "failed to generate operator config for %q", app)
}
operatorConfig[i] = config
}
// If we did create any passwords for new operators, first they need
// to be saved so the agent can login when it starts up.
if len(appPasswords) > 0 {
errorResults, err := p.provisionerFacade.SetPasswords(appPasswords)
if err != nil {
return errors.Annotate(err, "failed to set application api passwords")
}
if err := errorResults.Combine(); err != nil {
return errors.Annotate(err, "failed to set application api passwords")
}
}
// Now that any new config/passwords are done, create or update
// the operators themselves.
var errorStrings []string
for i, app := range apps {
if err := p.ensureOperator(app, operatorConfig[i]); err != nil {
errorStrings = append(errorStrings, err.Error())
continue
}
}
if errorStrings != nil {
err := errors.New(strings.Join(errorStrings, "\n"))
return errors.Annotate(err, "failed to provision all operators")
}
return nil
} | go | 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 operator for %q", app)
}
if opState.Exists && opState.Terminating {
// We can't deploy an app while a previous version is terminating.
// TODO(caas) - the remove application process should block until app terminated
// TODO(caas) - consider making this async, but ok for now as it's a corner case
if err := p.waitForOperatorTerminated(app); err != nil {
return errors.Annotatef(err, "operator for %q was terminating and there was an error waiting for it to stop", app)
}
opState.Exists = false
}
// If the operator does not exist already, we need to create an initial
// password for it.
var password string
if !opState.Exists {
if password, err = utils.RandomPassword(); err != nil {
return errors.Trace(err)
}
appPasswords = append(appPasswords, apicaasprovisioner.ApplicationPassword{Name: app, Password: password})
}
config, err := p.makeOperatorConfig(app, password)
if err != nil {
return errors.Annotatef(err, "failed to generate operator config for %q", app)
}
operatorConfig[i] = config
}
// If we did create any passwords for new operators, first they need
// to be saved so the agent can login when it starts up.
if len(appPasswords) > 0 {
errorResults, err := p.provisionerFacade.SetPasswords(appPasswords)
if err != nil {
return errors.Annotate(err, "failed to set application api passwords")
}
if err := errorResults.Combine(); err != nil {
return errors.Annotate(err, "failed to set application api passwords")
}
}
// Now that any new config/passwords are done, create or update
// the operators themselves.
var errorStrings []string
for i, app := range apps {
if err := p.ensureOperator(app, operatorConfig[i]); err != nil {
errorStrings = append(errorStrings, err.Error())
continue
}
}
if errorStrings != nil {
err := errors.New(strings.Join(errorStrings, "\n"))
return errors.Annotate(err, "failed to provision all operators")
}
return nil
} | [
"func",
"(",
"p",
"*",
"provisioner",
")",
"ensureOperators",
"(",
"apps",
"[",
"]",
"string",
")",
"error",
"{",
"var",
"appPasswords",
"[",
"]",
"apicaasprovisioner",
".",
"ApplicationPassword",
"\n",
"operatorConfig",
":=",
"make",
"(",
"[",
"]",
"*",
"... | // ensureOperators creates operator pods for the specified app names -> api passwords. | [
"ensureOperators",
"creates",
"operator",
"pods",
"for",
"the",
"specified",
"app",
"names",
"-",
">",
"api",
"passwords",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/caasoperatorprovisioner/worker.go#L162-L221 |
5,113 | juju/juju | worker/peergrouper/manifold.go | Manifold | func Manifold(config ManifoldConfig) dependency.Manifold {
return dependency.Manifold{
Inputs: []string{
config.AgentName,
config.ClockName,
config.ControllerPortName,
config.StateName,
},
Start: config.start,
}
} | go | func Manifold(config ManifoldConfig) dependency.Manifold {
return dependency.Manifold{
Inputs: []string{
config.AgentName,
config.ClockName,
config.ControllerPortName,
config.StateName,
},
Start: config.start,
}
} | [
"func",
"Manifold",
"(",
"config",
"ManifoldConfig",
")",
"dependency",
".",
"Manifold",
"{",
"return",
"dependency",
".",
"Manifold",
"{",
"Inputs",
":",
"[",
"]",
"string",
"{",
"config",
".",
"AgentName",
",",
"config",
".",
"ClockName",
",",
"config",
... | // Manifold returns a dependency.Manifold that will run a peergrouper. | [
"Manifold",
"returns",
"a",
"dependency",
".",
"Manifold",
"that",
"will",
"run",
"a",
"peergrouper",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/peergrouper/manifold.go#L53-L63 |
5,114 | juju/juju | cmd/juju/commands/enableha.go | Run | 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 = common.ParseConstraints(ctx, c.ConstraintsStr)
if err != nil {
return err
}
haClient, err := c.newHAClientFunc()
if err != nil {
return err
}
defer haClient.Close()
enableHAResult, err := haClient.EnableHA(
c.NumControllers,
c.Constraints,
c.Placement,
)
if err != nil {
return block.ProcessBlockedError(err, block.BlockChange)
}
result := availabilityInfo{
Added: machineTagsToIds(enableHAResult.Added...),
Removed: machineTagsToIds(enableHAResult.Removed...),
Maintained: machineTagsToIds(enableHAResult.Maintained...),
Promoted: machineTagsToIds(enableHAResult.Promoted...),
Demoted: machineTagsToIds(enableHAResult.Demoted...),
Converted: machineTagsToIds(enableHAResult.Converted...),
}
return c.out.Write(ctx, result)
} | go | 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 = common.ParseConstraints(ctx, c.ConstraintsStr)
if err != nil {
return err
}
haClient, err := c.newHAClientFunc()
if err != nil {
return err
}
defer haClient.Close()
enableHAResult, err := haClient.EnableHA(
c.NumControllers,
c.Constraints,
c.Placement,
)
if err != nil {
return block.ProcessBlockedError(err, block.BlockChange)
}
result := availabilityInfo{
Added: machineTagsToIds(enableHAResult.Added...),
Removed: machineTagsToIds(enableHAResult.Removed...),
Maintained: machineTagsToIds(enableHAResult.Maintained...),
Promoted: machineTagsToIds(enableHAResult.Promoted...),
Demoted: machineTagsToIds(enableHAResult.Demoted...),
Converted: machineTagsToIds(enableHAResult.Converted...),
}
return c.out.Write(ctx, result)
} | [
"func",
"(",
"c",
"*",
"enableHACommand",
")",
"Run",
"(",
"ctx",
"*",
"cmd",
".",
"Context",
")",
"error",
"{",
"controllerName",
",",
"err",
":=",
"c",
".",
"ControllerName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
... | // Run connects to the environment specified on the command line
// and calls EnableHA. | [
"Run",
"connects",
"to",
"the",
"environment",
"specified",
"on",
"the",
"command",
"line",
"and",
"calls",
"EnableHA",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/commands/enableha.go#L212-L249 |
5,115 | juju/juju | cmd/juju/commands/enableha.go | machineTagsToIds | 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 | 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
} | [
"func",
"machineTagsToIds",
"(",
"tags",
"...",
"string",
")",
"[",
"]",
"string",
"{",
"var",
"result",
"[",
"]",
"string",
"\n\n",
"for",
"_",
",",
"rawTag",
":=",
"range",
"tags",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseTag",
"(",
"rawTa... | // Convert machine tags to ids, skipping any non-machine tags. | [
"Convert",
"machine",
"tags",
"to",
"ids",
"skipping",
"any",
"non",
"-",
"machine",
"tags",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/commands/enableha.go#L252-L263 |
5,116 | juju/juju | resource/resourceadapters/opener.go | OpenResource | 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.CharmID{
URL: cURL,
Channel: app.Channel(),
}
csOpener := newCharmstoreOpener(ro.st)
client, err := csOpener.NewClient()
if err != nil {
return resource.Opened{}, errors.Trace(err)
}
cache := &charmstoreEntityCache{
st: ro.res,
userID: ro.userID,
unit: ro.unit,
applicationID: ro.unit.ApplicationName(),
}
res, reader, err := charmstore.GetResource(charmstore.GetResourceArgs{
Client: client,
Cache: cache,
CharmID: id,
Name: name,
})
if err != nil {
return resource.Opened{}, errors.Trace(err)
}
opened := resource.Opened{
Resource: res,
ReadCloser: reader,
}
return opened, nil
} | go | 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.CharmID{
URL: cURL,
Channel: app.Channel(),
}
csOpener := newCharmstoreOpener(ro.st)
client, err := csOpener.NewClient()
if err != nil {
return resource.Opened{}, errors.Trace(err)
}
cache := &charmstoreEntityCache{
st: ro.res,
userID: ro.userID,
unit: ro.unit,
applicationID: ro.unit.ApplicationName(),
}
res, reader, err := charmstore.GetResource(charmstore.GetResourceArgs{
Client: client,
Cache: cache,
CharmID: id,
Name: name,
})
if err != nil {
return resource.Opened{}, errors.Trace(err)
}
opened := resource.Opened{
Resource: res,
ReadCloser: reader,
}
return opened, nil
} | [
"func",
"(",
"ro",
"*",
"resourceOpener",
")",
"OpenResource",
"(",
"name",
"string",
")",
"(",
"o",
"resource",
".",
"Opened",
",",
"err",
"error",
")",
"{",
"if",
"ro",
".",
"unit",
"==",
"nil",
"{",
"return",
"resource",
".",
"Opened",
"{",
"}",
... | // OpenResource implements server.ResourceOpener. | [
"OpenResource",
"implements",
"server",
".",
"ResourceOpener",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/resource/resourceadapters/opener.go#L52-L94 |
5,117 | juju/juju | worker/undertaker/undertaker.go | Validate | 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 | 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
} | [
"func",
"(",
"config",
"Config",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"config",
".",
"Facade",
"==",
"nil",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"CredentialAPI",
"==",
"nil",... | // Validate returns an error if the config cannot be expected to drive
// a functional undertaker worker. | [
"Validate",
"returns",
"an",
"error",
"if",
"the",
"config",
"cannot",
"be",
"expected",
"to",
"drive",
"a",
"functional",
"undertaker",
"worker",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/undertaker/undertaker.go#L41-L52 |
5,118 | juju/juju | worker/undertaker/undertaker.go | NewUndertaker | 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(common.NewCloudCallContext(config.CredentialAPI, u.catacomb.Dying))
return u, nil
} | go | 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(common.NewCloudCallContext(config.CredentialAPI, u.catacomb.Dying))
return u, nil
} | [
"func",
"NewUndertaker",
"(",
"config",
"Config",
")",
"(",
"*",
"Undertaker",
",",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
"... | // NewUndertaker returns a worker which processes a dying model. | [
"NewUndertaker",
"returns",
"a",
"worker",
"which",
"processes",
"a",
"dying",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/undertaker/undertaker.go#L55-L72 |
5,119 | juju/juju | migration/migration.go | ImportModel | 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(err)
}
config, err := dbState.ControllerConfig()
if err != nil {
return nil, nil, errors.Trace(err)
}
// If we're using legacy-leases we get the claimer from the new
// state - otherwise use the function passed in.
//
var claimer leadership.Claimer
if config.Features().Contains(feature.LegacyLeases) {
claimer = dbState.LeadershipClaimer()
} else {
claimer, err = getClaimer(dbModel.UUID())
if err != nil {
return nil, nil, errors.Annotate(err, "getting leadership claimer")
}
}
logger.Debugf("importing leadership")
for _, application := range model.Applications() {
if application.Leader() == "" {
continue
}
// When we import a new model, we need to give the leaders
// some time to settle. We don't want to have leader switches
// just because we migrated a model, so this time needs to be
// long enough to make sure we cover the time taken to migrate
// a reasonable sized model. We don't yet know how long this
// is going to be, but we need something.
// TODO(babbageclunk): Handle this better - maybe a way to
// suppress leadership expiries for a model until it's
// finished importing?
logger.Debugf("%q is the leader for %q", application.Leader(), application.Name())
err := claimer.ClaimLeadership(
application.Name(),
application.Leader(),
state.InitialLeaderClaimTime,
)
if err != nil {
return nil, nil, errors.Annotatef(
err,
"claiming leadership for %q",
application.Leader(),
)
}
}
return dbModel, dbState, nil
} | go | 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(err)
}
config, err := dbState.ControllerConfig()
if err != nil {
return nil, nil, errors.Trace(err)
}
// If we're using legacy-leases we get the claimer from the new
// state - otherwise use the function passed in.
//
var claimer leadership.Claimer
if config.Features().Contains(feature.LegacyLeases) {
claimer = dbState.LeadershipClaimer()
} else {
claimer, err = getClaimer(dbModel.UUID())
if err != nil {
return nil, nil, errors.Annotate(err, "getting leadership claimer")
}
}
logger.Debugf("importing leadership")
for _, application := range model.Applications() {
if application.Leader() == "" {
continue
}
// When we import a new model, we need to give the leaders
// some time to settle. We don't want to have leader switches
// just because we migrated a model, so this time needs to be
// long enough to make sure we cover the time taken to migrate
// a reasonable sized model. We don't yet know how long this
// is going to be, but we need something.
// TODO(babbageclunk): Handle this better - maybe a way to
// suppress leadership expiries for a model until it's
// finished importing?
logger.Debugf("%q is the leader for %q", application.Leader(), application.Name())
err := claimer.ClaimLeadership(
application.Name(),
application.Leader(),
state.InitialLeaderClaimTime,
)
if err != nil {
return nil, nil, errors.Annotatef(
err,
"claiming leadership for %q",
application.Leader(),
)
}
}
return dbModel, dbState, nil
} | [
"func",
"ImportModel",
"(",
"importer",
"StateImporter",
",",
"getClaimer",
"ClaimerFunc",
",",
"bytes",
"[",
"]",
"byte",
")",
"(",
"*",
"state",
".",
"Model",
",",
"*",
"state",
".",
"State",
",",
"error",
")",
"{",
"model",
",",
"err",
":=",
"descri... | // ImportModel deserializes a model description from the bytes, transforms
// the model config based on information from the controller model, and then
// imports that as a new database model. | [
"ImportModel",
"deserializes",
"a",
"model",
"description",
"from",
"the",
"bytes",
"transforms",
"the",
"model",
"config",
"based",
"on",
"information",
"from",
"the",
"controller",
"model",
"and",
"then",
"imports",
"that",
"as",
"a",
"new",
"database",
"model... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/migration/migration.go#L65-L124 |
5,120 | juju/juju | migration/migration.go | Validate | 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.ToolsUploader == nil {
return errors.NotValidf("missing ToolsUploader")
}
if c.ResourceDownloader == nil {
return errors.NotValidf("missing ResourceDownloader")
}
if c.ResourceUploader == nil {
return errors.NotValidf("missing ResourceUploader")
}
return nil
} | go | 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.ToolsUploader == nil {
return errors.NotValidf("missing ToolsUploader")
}
if c.ResourceDownloader == nil {
return errors.NotValidf("missing ResourceDownloader")
}
if c.ResourceUploader == nil {
return errors.NotValidf("missing ResourceUploader")
}
return nil
} | [
"func",
"(",
"c",
"*",
"UploadBinariesConfig",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"c",
".",
"CharmDownloader",
"==",
"nil",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"CharmUploader",
... | // Validate makes sure that all the config values are non-nil. | [
"Validate",
"makes",
"sure",
"that",
"all",
"the",
"config",
"values",
"are",
"non",
"-",
"nil",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/migration/migration.go#L182-L202 |
5,121 | juju/juju | migration/migration.go | UploadBinaries | 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 != nil {
return errors.Trace(err)
}
return nil
} | go | 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 != nil {
return errors.Trace(err)
}
return nil
} | [
"func",
"UploadBinaries",
"(",
"config",
"UploadBinariesConfig",
")",
"error",
"{",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
... | // UploadBinaries will send binaries stored in the source blobstore to
// the target controller. | [
"UploadBinaries",
"will",
"send",
"binaries",
"stored",
"in",
"the",
"source",
"blobstore",
"to",
"the",
"target",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/migration/migration.go#L206-L220 |
5,122 | juju/juju | worker/metrics/spool/manifold.go | Recorder | 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 | 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,
})
} | [
"func",
"(",
"f",
"*",
"factory",
")",
"Recorder",
"(",
"declaredMetrics",
"map",
"[",
"string",
"]",
"corecharm",
".",
"Metric",
",",
"charmURL",
",",
"unitTag",
"string",
")",
"(",
"MetricRecorder",
",",
"error",
")",
"{",
"return",
"NewJSONMetricRecorder"... | // Recorder implements the MetricFactory interface. | [
"Recorder",
"implements",
"the",
"MetricFactory",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/manifold.go#L66-L73 |
5,123 | juju/juju | worker/metrics/spool/manifold.go | Manifold | func Manifold(config ManifoldConfig) dependency.Manifold {
manifold := engine.AgentManifold(engine.AgentManifoldConfig(config), newWorker)
manifold.Output = outputFunc
return manifold
} | go | func Manifold(config ManifoldConfig) dependency.Manifold {
manifold := engine.AgentManifold(engine.AgentManifoldConfig(config), newWorker)
manifold.Output = outputFunc
return manifold
} | [
"func",
"Manifold",
"(",
"config",
"ManifoldConfig",
")",
"dependency",
".",
"Manifold",
"{",
"manifold",
":=",
"engine",
".",
"AgentManifold",
"(",
"engine",
".",
"AgentManifoldConfig",
"(",
"config",
")",
",",
"newWorker",
")",
"\n",
"manifold",
".",
"Output... | // Manifold returns a dependency.Manifold that extracts the metrics
// spool directory path from the agent. | [
"Manifold",
"returns",
"a",
"dependency",
".",
"Manifold",
"that",
"extracts",
"the",
"metrics",
"spool",
"directory",
"path",
"from",
"the",
"agent",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/manifold.go#L85-L89 |
5,124 | juju/juju | worker/metrics/spool/manifold.go | newWorker | 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.tomb.Go(func() error {
<-w.tomb.Dying()
return nil
})
return w, nil
} | go | 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.tomb.Go(func() error {
<-w.tomb.Dying()
return nil
})
return w, nil
} | [
"func",
"newWorker",
"(",
"a",
"agent",
".",
"Agent",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"metricsSpoolDir",
":=",
"a",
".",
"CurrentConfig",
"(",
")",
".",
"MetricsSpoolDir",
"(",
")",
"\n",
"err",
":=",
"checkSpoolDir",
"(",
"m... | // newWorker creates a degenerate worker that provides access to the metrics
// spool directory path. | [
"newWorker",
"creates",
"a",
"degenerate",
"worker",
"that",
"provides",
"access",
"to",
"the",
"metrics",
"spool",
"directory",
"path",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/manifold.go#L93-L105 |
5,125 | juju/juju | payload/status/formatter.go | FormatPayload | 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: payload.Type,
Class: payload.Name,
Labels: labels,
// TODO(ericsnow) Explicitly convert to a string?
Status: payload.Status,
}
} | go | 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: payload.Type,
Class: payload.Name,
Labels: labels,
// TODO(ericsnow) Explicitly convert to a string?
Status: payload.Status,
}
} | [
"func",
"FormatPayload",
"(",
"payload",
"payload",
".",
"FullPayloadInfo",
")",
"FormattedPayload",
"{",
"var",
"labels",
"[",
"]",
"string",
"\n",
"if",
"len",
"(",
"payload",
".",
"Labels",
")",
">",
"0",
"{",
"labels",
"=",
"make",
"(",
"[",
"]",
"... | // FormatPayload converts the Payload into a FormattedPayload. | [
"FormatPayload",
"converts",
"the",
"Payload",
"into",
"a",
"FormattedPayload",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/payload/status/formatter.go#L34-L50 |
5,126 | juju/juju | container/kvm/mock/mock-kvm.go | EnsureCachedImage | func (mock *MockContainer) EnsureCachedImage(params kvm.StartParams) error {
imageCacheCalls++
mock.StartParams = params
return nil
} | go | func (mock *MockContainer) EnsureCachedImage(params kvm.StartParams) error {
imageCacheCalls++
mock.StartParams = params
return nil
} | [
"func",
"(",
"mock",
"*",
"MockContainer",
")",
"EnsureCachedImage",
"(",
"params",
"kvm",
".",
"StartParams",
")",
"error",
"{",
"imageCacheCalls",
"++",
"\n",
"mock",
".",
"StartParams",
"=",
"params",
"\n",
"return",
"nil",
"\n",
"}"
] | // EnsureCachedImage is the first supply of start-params to the container.
// We set it here for subsequent test assertions.
// Start is called by the manager immediately after, with the same argument. | [
"EnsureCachedImage",
"is",
"the",
"first",
"supply",
"of",
"start",
"-",
"params",
"to",
"the",
"container",
".",
"We",
"set",
"it",
"here",
"for",
"subsequent",
"test",
"assertions",
".",
"Start",
"is",
"called",
"by",
"the",
"manager",
"immediately",
"afte... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/kvm/mock/mock-kvm.go#L82-L86 |
5,127 | juju/juju | container/kvm/mock/mock-kvm.go | Stop | 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 | 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
} | [
"func",
"(",
"mock",
"*",
"MockContainer",
")",
"Stop",
"(",
")",
"error",
"{",
"if",
"!",
"mock",
".",
"started",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"mock",
".",
"started",
"=",
"false",
"\n",
"mock",
"."... | // Stop terminates the running container. | [
"Stop",
"terminates",
"the",
"running",
"container",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/kvm/mock/mock-kvm.go#L98-L105 |
5,128 | juju/juju | migration/precheck.go | SourcePrecheck | 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)
}
appUnits, err := ctx.checkApplications()
if err != nil {
return errors.Trace(err)
}
if err := ctx.checkRelations(appUnits); err != nil {
return errors.Trace(err)
}
if cleanupNeeded, err := backend.NeedsCleanup(); err != nil {
return errors.Annotate(err, "checking cleanups")
} else if cleanupNeeded {
return errors.New("cleanup needed")
}
// Check the source controller.
controllerBackend, err := backend.ControllerBackend()
if err != nil {
return errors.Trace(err)
}
controllerCtx := precheckContext{controllerBackend, controllerPresence}
if err := controllerCtx.checkController(); err != nil {
return errors.Annotate(err, "controller")
}
return nil
} | go | 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)
}
appUnits, err := ctx.checkApplications()
if err != nil {
return errors.Trace(err)
}
if err := ctx.checkRelations(appUnits); err != nil {
return errors.Trace(err)
}
if cleanupNeeded, err := backend.NeedsCleanup(); err != nil {
return errors.Annotate(err, "checking cleanups")
} else if cleanupNeeded {
return errors.New("cleanup needed")
}
// Check the source controller.
controllerBackend, err := backend.ControllerBackend()
if err != nil {
return errors.Trace(err)
}
controllerCtx := precheckContext{controllerBackend, controllerPresence}
if err := controllerCtx.checkController(); err != nil {
return errors.Annotate(err, "controller")
}
return nil
} | [
"func",
"SourcePrecheck",
"(",
"backend",
"PrecheckBackend",
",",
"modelPresence",
"ModelPresence",
",",
"controllerPresence",
"ModelPresence",
",",
")",
"error",
"{",
"ctx",
":=",
"precheckContext",
"{",
"backend",
",",
"modelPresence",
"}",
"\n",
"if",
"err",
":... | // SourcePrecheck checks the state of the source controller to make
// sure that the preconditions for model migration are met. The
// backend provided must be for the model to be migrated. | [
"SourcePrecheck",
"checks",
"the",
"state",
"of",
"the",
"source",
"controller",
"to",
"make",
"sure",
"that",
"the",
"preconditions",
"for",
"model",
"migration",
"are",
"met",
".",
"The",
"backend",
"provided",
"must",
"be",
"for",
"the",
"model",
"to",
"b... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/migration/precheck.go#L118-L157 |
5,129 | juju/juju | migration/precheck.go | TargetPrecheck | 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 model's
// documents have been deleted but the migration isn't quite done
// yet. Migrating a model back into the controller during this
// window can upset the migrationmaster worker.
//
// See also https://lpad.tv/1611391
if migrating, err := backend.IsMigrationActive(modelInfo.UUID); err != nil {
return errors.Annotate(err, "checking for active migration")
} else if migrating {
return errors.New("model is being migrated out of target controller")
}
controllerVersion, err := backend.AgentVersion()
if err != nil {
return errors.Annotate(err, "retrieving model version")
}
if controllerVersion.Compare(modelInfo.AgentVersion) < 0 {
return errors.Errorf("model has higher version than target controller (%s > %s)",
modelInfo.AgentVersion, controllerVersion)
}
if !controllerVersionCompatible(modelInfo.ControllerAgentVersion, controllerVersion) {
return errors.Errorf("source controller has higher version than target controller (%s > %s)",
modelInfo.ControllerAgentVersion, controllerVersion)
}
controllerCtx := precheckContext{backend, presence}
if err := controllerCtx.checkController(); err != nil {
return errors.Trace(err)
}
// Check for conflicts with existing models
modelUUIDs, err := backend.AllModelUUIDs()
if err != nil {
return errors.Annotate(err, "retrieving models")
}
for _, modelUUID := range modelUUIDs {
model, release, err := pool.GetModel(modelUUID)
if err != nil {
return errors.Trace(err)
}
defer release()
// If the model is importing then it's probably left behind
// from a previous migration attempt. It will be removed
// before the next import.
if model.UUID() == modelInfo.UUID && model.MigrationMode() != state.MigrationModeImporting {
return errors.Errorf("model with same UUID already exists (%s)", modelInfo.UUID)
}
if model.Name() == modelInfo.Name && model.Owner() == modelInfo.Owner {
return errors.Errorf("model named %q already exists", model.Name())
}
}
return nil
} | go | 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 model's
// documents have been deleted but the migration isn't quite done
// yet. Migrating a model back into the controller during this
// window can upset the migrationmaster worker.
//
// See also https://lpad.tv/1611391
if migrating, err := backend.IsMigrationActive(modelInfo.UUID); err != nil {
return errors.Annotate(err, "checking for active migration")
} else if migrating {
return errors.New("model is being migrated out of target controller")
}
controllerVersion, err := backend.AgentVersion()
if err != nil {
return errors.Annotate(err, "retrieving model version")
}
if controllerVersion.Compare(modelInfo.AgentVersion) < 0 {
return errors.Errorf("model has higher version than target controller (%s > %s)",
modelInfo.AgentVersion, controllerVersion)
}
if !controllerVersionCompatible(modelInfo.ControllerAgentVersion, controllerVersion) {
return errors.Errorf("source controller has higher version than target controller (%s > %s)",
modelInfo.ControllerAgentVersion, controllerVersion)
}
controllerCtx := precheckContext{backend, presence}
if err := controllerCtx.checkController(); err != nil {
return errors.Trace(err)
}
// Check for conflicts with existing models
modelUUIDs, err := backend.AllModelUUIDs()
if err != nil {
return errors.Annotate(err, "retrieving models")
}
for _, modelUUID := range modelUUIDs {
model, release, err := pool.GetModel(modelUUID)
if err != nil {
return errors.Trace(err)
}
defer release()
// If the model is importing then it's probably left behind
// from a previous migration attempt. It will be removed
// before the next import.
if model.UUID() == modelInfo.UUID && model.MigrationMode() != state.MigrationModeImporting {
return errors.Errorf("model with same UUID already exists (%s)", modelInfo.UUID)
}
if model.Name() == modelInfo.Name && model.Owner() == modelInfo.Owner {
return errors.Errorf("model named %q already exists", model.Name())
}
}
return nil
} | [
"func",
"TargetPrecheck",
"(",
"backend",
"PrecheckBackend",
",",
"pool",
"Pool",
",",
"modelInfo",
"coremigration",
".",
"ModelInfo",
",",
"presence",
"ModelPresence",
")",
"error",
"{",
"if",
"err",
":=",
"modelInfo",
".",
"Validate",
"(",
")",
";",
"err",
... | // TargetPrecheck checks the state of the target controller to make
// sure that the preconditions for model migration are met. The
// backend provided must be for the target controller. | [
"TargetPrecheck",
"checks",
"the",
"state",
"of",
"the",
"target",
"controller",
"to",
"make",
"sure",
"that",
"the",
"preconditions",
"for",
"model",
"migration",
"are",
"met",
".",
"The",
"backend",
"provided",
"must",
"be",
"for",
"the",
"target",
"controll... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/migration/precheck.go#L190-L252 |
5,130 | juju/juju | worker/metrics/spool/metrics.go | IsMetricsDataError | func IsMetricsDataError(err error) bool {
_, ok := errors.Cause(err).(*errMetricsData)
return ok
} | go | func IsMetricsDataError(err error) bool {
_, ok := errors.Cause(err).(*errMetricsData)
return ok
} | [
"func",
"IsMetricsDataError",
"(",
"err",
"error",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"errors",
".",
"Cause",
"(",
"err",
")",
".",
"(",
"*",
"errMetricsData",
")",
"\n",
"return",
"ok",
"\n",
"}"
] | // IsMetricsDataError returns true if the error
// cause is errMetricsData. | [
"IsMetricsDataError",
"returns",
"true",
"if",
"the",
"error",
"cause",
"is",
"errMetricsData",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/metrics.go#L34-L37 |
5,131 | juju/juju | worker/metrics/spool/metrics.go | APIMetricBatch | 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.MetricBatchParam{
Tag: batch.UnitTag,
Batch: params.MetricBatch{
UUID: batch.UUID,
CharmURL: batch.CharmURL,
Created: batch.Created,
Metrics: metrics,
},
}
} | go | 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.MetricBatchParam{
Tag: batch.UnitTag,
Batch: params.MetricBatch{
UUID: batch.UUID,
CharmURL: batch.CharmURL,
Created: batch.Created,
Metrics: metrics,
},
}
} | [
"func",
"APIMetricBatch",
"(",
"batch",
"MetricBatch",
")",
"params",
".",
"MetricBatchParam",
"{",
"metrics",
":=",
"make",
"(",
"[",
"]",
"params",
".",
"Metric",
",",
"len",
"(",
"batch",
".",
"Metrics",
")",
")",
"\n",
"for",
"i",
",",
"metric",
":... | // APIMetricBatch converts the specified MetricBatch to a params.MetricBatch,
// which can then be sent to the controller. | [
"APIMetricBatch",
"converts",
"the",
"specified",
"MetricBatch",
"to",
"a",
"params",
".",
"MetricBatch",
"which",
"can",
"then",
"be",
"sent",
"to",
"the",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/metrics.go#L100-L119 |
5,132 | juju/juju | worker/metrics/spool/metrics.go | NewJSONMetricRecorder | 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-03-17 lp:1558657
created: time.Now().UTC(),
validMetrics: config.Metrics,
unitTag: config.UnitTag,
}
if err := recorder.open(); err != nil {
return nil, errors.Trace(err)
}
return recorder, nil
} | go | 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-03-17 lp:1558657
created: time.Now().UTC(),
validMetrics: config.Metrics,
unitTag: config.UnitTag,
}
if err := recorder.open(); err != nil {
return nil, errors.Trace(err)
}
return recorder, nil
} | [
"func",
"NewJSONMetricRecorder",
"(",
"config",
"MetricRecorderConfig",
")",
"(",
"rec",
"*",
"JSONMetricRecorder",
",",
"rErr",
"error",
")",
"{",
"mbUUID",
",",
"err",
":=",
"utils",
".",
"NewUUID",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return"... | // NewJSONMetricRecorder creates a new JSON metrics recorder. | [
"NewJSONMetricRecorder",
"creates",
"a",
"new",
"JSON",
"metrics",
"recorder",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/metrics.go#L154-L173 |
5,133 | juju/juju | worker/metrics/spool/metrics.go | Close | 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 file so that JSONMetricReader discovers a finished
// pair of files.
err = m.recordMetaData()
if err != nil {
return errors.Trace(err)
}
return nil
} | go | 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 file so that JSONMetricReader discovers a finished
// pair of files.
err = m.recordMetaData()
if err != nil {
return errors.Trace(err)
}
return nil
} | [
"func",
"(",
"m",
"*",
"JSONMetricRecorder",
")",
"Close",
"(",
")",
"error",
"{",
"m",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"err",
":=",
"m",
".",
"file",
".",
"Close",
"(",
")",... | // Close implements the MetricsRecorder interface. | [
"Close",
"implements",
"the",
"MetricsRecorder",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/metrics.go#L176-L196 |
5,134 | juju/juju | worker/metrics/spool/metrics.go | AddMetric | 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 errors.Trace(m.enc.Encode(jujuc.Metric{
Key: key,
Value: value,
Time: created,
Labels: labels,
}))
} | go | 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 errors.Trace(m.enc.Encode(jujuc.Metric{
Key: key,
Value: value,
Time: created,
Labels: labels,
}))
} | [
"func",
"(",
"m",
"*",
"JSONMetricRecorder",
")",
"AddMetric",
"(",
"key",
",",
"value",
"string",
",",
"created",
"time",
".",
"Time",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",... | // AddMetric implements the MetricsRecorder interface. | [
"AddMetric",
"implements",
"the",
"MetricsRecorder",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/metrics.go#L199-L218 |
5,135 | juju/juju | worker/metrics/spool/metrics.go | IsDeclaredMetric | func (m *JSONMetricRecorder) IsDeclaredMetric(key string) bool {
_, ok := m.validMetrics[key]
return ok
} | go | func (m *JSONMetricRecorder) IsDeclaredMetric(key string) bool {
_, ok := m.validMetrics[key]
return ok
} | [
"func",
"(",
"m",
"*",
"JSONMetricRecorder",
")",
"IsDeclaredMetric",
"(",
"key",
"string",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"m",
".",
"validMetrics",
"[",
"key",
"]",
"\n",
"return",
"ok",
"\n",
"}"
] | // IsDeclaredMetric returns true if the metric recorder is permitted to store this metric.
// Returns false if the uniter using this recorder doesn't define this metric. | [
"IsDeclaredMetric",
"returns",
"true",
"if",
"the",
"metric",
"recorder",
"is",
"permitted",
"to",
"store",
"this",
"metric",
".",
"Returns",
"false",
"if",
"the",
"uniter",
"using",
"this",
"recorder",
"doesn",
"t",
"define",
"this",
"metric",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/metrics.go#L241-L244 |
5,136 | juju/juju | worker/metrics/spool/metrics.go | NewJSONMetricReader | 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 | 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
} | [
"func",
"NewJSONMetricReader",
"(",
"spoolDir",
"string",
")",
"(",
"*",
"JSONMetricReader",
",",
"error",
")",
"{",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"spoolDir",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
"... | // NewJSONMetricsReader creates a new JSON metrics reader for the specified spool directory. | [
"NewJSONMetricsReader",
"creates",
"a",
"new",
"JSON",
"metrics",
"reader",
"for",
"the",
"specified",
"spool",
"directory",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/metrics.go#L312-L319 |
5,137 | juju/juju | worker/metrics/spool/metrics.go | Read | 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 {
return filepath.SkipDir
} else if !strings.HasSuffix(info.Name(), ".meta") {
return nil
}
batch, err := decodeBatch(path)
if err != nil {
return errors.Trace(err)
}
batch.Metrics, err = decodeMetrics(filepath.Join(r.dir, batch.UUID))
if err != nil {
return errors.Trace(err)
}
if len(batch.Metrics) > 0 {
batches = append(batches, batch)
}
return nil
}
if err := filepath.Walk(r.dir, walker); err != nil {
return nil, errors.Trace(err)
}
return batches, nil
} | go | 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 {
return filepath.SkipDir
} else if !strings.HasSuffix(info.Name(), ".meta") {
return nil
}
batch, err := decodeBatch(path)
if err != nil {
return errors.Trace(err)
}
batch.Metrics, err = decodeMetrics(filepath.Join(r.dir, batch.UUID))
if err != nil {
return errors.Trace(err)
}
if len(batch.Metrics) > 0 {
batches = append(batches, batch)
}
return nil
}
if err := filepath.Walk(r.dir, walker); err != nil {
return nil, errors.Trace(err)
}
return batches, nil
} | [
"func",
"(",
"r",
"*",
"JSONMetricReader",
")",
"Read",
"(",
")",
"(",
"_",
"[",
"]",
"MetricBatch",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"&",
"errMetricsData",
"{",
"err",
"}",... | // Read implements the MetricsReader interface.
// Due to the way the batches are stored in the file system,
// they will be returned in an arbitrary order. This does not affect the behavior. | [
"Read",
"implements",
"the",
"MetricsReader",
"interface",
".",
"Due",
"to",
"the",
"way",
"the",
"batches",
"are",
"stored",
"in",
"the",
"file",
"system",
"they",
"will",
"be",
"returned",
"in",
"an",
"arbitrary",
"order",
".",
"This",
"does",
"not",
"af... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/metrics.go#L324-L360 |
5,138 | juju/juju | worker/metrics/spool/metrics.go | Remove | 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.Trace(err)
}
return nil
} | go | 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.Trace(err)
}
return nil
} | [
"func",
"(",
"r",
"*",
"JSONMetricReader",
")",
"Remove",
"(",
"uuid",
"string",
")",
"error",
"{",
"metaFile",
":=",
"filepath",
".",
"Join",
"(",
"r",
".",
"dir",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"uuid",
")",
")",
"\n",
"dataFile... | // Remove implements the MetricsReader interface. | [
"Remove",
"implements",
"the",
"MetricsReader",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/spool/metrics.go#L363-L375 |
5,139 | juju/juju | resource/resourceadapters/deploy.go | AddPendingResources | 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,
CharmStoreMacaroon: csMac,
Resources: resources,
})
} | go | 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,
CharmStoreMacaroon: csMac,
Resources: resources,
})
} | [
"func",
"(",
"cl",
"*",
"deployClient",
")",
"AddPendingResources",
"(",
"applicationID",
"string",
",",
"chID",
"charmstore",
".",
"CharmID",
",",
"csMac",
"*",
"macaroon",
".",
"Macaroon",
",",
"resources",
"[",
"]",
"charmresource",
".",
"Resource",
")",
... | // AddPendingResources adds pending metadata for store-based resources. | [
"AddPendingResources",
"adds",
"pending",
"metadata",
"for",
"store",
"-",
"based",
"resources",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/resource/resourceadapters/deploy.go#L82-L89 |
5,140 | juju/juju | provider/gce/google/raw.go | checkOperation | 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.RegionOperations.Get(projectID, region, op.Name)
} else {
call = rc.GlobalOperations.Get(projectID, op.Name)
}
operation, err := doOpCall(call)
if err != nil {
return nil, errors.Annotatef(err, "request for GCE operation %q failed", op.Name)
}
return operation, nil
} | go | 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.RegionOperations.Get(projectID, region, op.Name)
} else {
call = rc.GlobalOperations.Get(projectID, op.Name)
}
operation, err := doOpCall(call)
if err != nil {
return nil, errors.Annotatef(err, "request for GCE operation %q failed", op.Name)
}
return operation, nil
} | [
"func",
"(",
"rc",
"*",
"rawConn",
")",
"checkOperation",
"(",
"projectID",
"string",
",",
"op",
"*",
"compute",
".",
"Operation",
")",
"(",
"*",
"compute",
".",
"Operation",
",",
"error",
")",
"{",
"var",
"call",
"opDoer",
"\n",
"if",
"op",
".",
"Zo... | // checkOperation requests a new copy of the given operation from the
// GCE API and returns it. The new copy will have the operation's
// current status. | [
"checkOperation",
"requests",
"a",
"new",
"copy",
"of",
"the",
"given",
"operation",
"from",
"the",
"GCE",
"API",
"and",
"returns",
"it",
".",
"The",
"new",
"copy",
"will",
"have",
"the",
"operation",
"s",
"current",
"status",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/gce/google/raw.go#L318-L335 |
5,141 | juju/juju | provider/gce/google/raw.go | ListMachineTypes | 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 | 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
} | [
"func",
"(",
"rc",
"*",
"rawConn",
")",
"ListMachineTypes",
"(",
"projectID",
",",
"zone",
"string",
")",
"(",
"*",
"compute",
".",
"MachineTypeList",
",",
"error",
")",
"{",
"op",
":=",
"rc",
".",
"MachineTypes",
".",
"List",
"(",
"projectID",
",",
"z... | // ListMachineTypes returns a list of machines available in the project and zone provided. | [
"ListMachineTypes",
"returns",
"a",
"list",
"of",
"machines",
"available",
"in",
"the",
"project",
"and",
"zone",
"provided",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/gce/google/raw.go#L378-L385 |
5,142 | juju/juju | worker/modelcache/worker.go | Validate | 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 errors.NotValidf("missing cleanup func")
}
return nil
} | go | 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 errors.NotValidf("missing cleanup func")
}
return nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"c",
".",
"Logger",
"==",
"nil",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"WatcherFactory",
"==",
"nil",
"{",... | // Validate ensures all the necessary values are specified | [
"Validate",
"ensures",
"all",
"the",
"necessary",
"values",
"are",
"specified"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/modelcache/worker.go#L50-L64 |
5,143 | juju/juju | worker/modelcache/worker.go | NewWorker | 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.Notify,
})
if err != nil {
return nil, errors.Trace(err)
}
w.controller = controller
if err := catacomb.Invoke(catacomb.Plan{
Site: &w.catacomb,
Work: w.loop,
Init: []worker.Worker{w.controller},
}); err != nil {
return nil, errors.Trace(err)
}
return w, nil
} | go | 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.Notify,
})
if err != nil {
return nil, errors.Trace(err)
}
w.controller = controller
if err := catacomb.Invoke(catacomb.Plan{
Site: &w.catacomb,
Work: w.loop,
Init: []worker.Worker{w.controller},
}); err != nil {
return nil, errors.Trace(err)
}
return w, nil
} | [
"func",
"NewWorker",
"(",
"config",
"Config",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",... | // NewWorker creates a new cacheWorker, and starts an
// all model watcher. | [
"NewWorker",
"creates",
"a",
"new",
"cacheWorker",
"and",
"starts",
"an",
"all",
"model",
"watcher",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/modelcache/worker.go#L77-L102 |
5,144 | juju/juju | state/upgrades.go | runForAllModelStates | 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 to read models")
}
for _, modelDoc := range modelDocs {
modelUUID := modelDoc["_id"].(string)
model, err := pool.Get(modelUUID)
if err != nil {
return errors.Annotatef(err, "failed to open model %q", modelUUID)
}
defer func() {
model.Release()
}()
if err := runner(model.State); err != nil {
return errors.Annotatef(err, "model UUID %q", modelUUID)
}
}
return nil
} | go | 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 to read models")
}
for _, modelDoc := range modelDocs {
modelUUID := modelDoc["_id"].(string)
model, err := pool.Get(modelUUID)
if err != nil {
return errors.Annotatef(err, "failed to open model %q", modelUUID)
}
defer func() {
model.Release()
}()
if err := runner(model.State); err != nil {
return errors.Annotatef(err, "model UUID %q", modelUUID)
}
}
return nil
} | [
"func",
"runForAllModelStates",
"(",
"pool",
"*",
"StatePool",
",",
"runner",
"func",
"(",
"st",
"*",
"State",
")",
"error",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"models",
",",
"closer",
":=",
"st",
".",
"db",
"(... | // runForAllModelStates will run runner function for every model passing a state
// for that model. | [
"runForAllModelStates",
"will",
"run",
"runner",
"function",
"for",
"every",
"model",
"passing",
"a",
"state",
"for",
"that",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L41-L66 |
5,145 | juju/juju | state/upgrades.go | readBsonDField | 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 | 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
} | [
"func",
"readBsonDField",
"(",
"d",
"bson",
".",
"D",
",",
"name",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"for",
"i",
":=",
"range",
"d",
"{",
"field",
":=",
"&",
"d",
"[",
"i",
"]",
"\n",
"if",
"field",
".",
"Name",
... | // readBsonDField returns the value of a given field in a bson.D. | [
"readBsonDField",
"returns",
"the",
"value",
"of",
"a",
"given",
"field",
"in",
"a",
"bson",
".",
"D",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L69-L77 |
5,146 | juju/juju | state/upgrades.go | replaceBsonDField | 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 | 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)
} | [
"func",
"replaceBsonDField",
"(",
"d",
"bson",
".",
"D",
",",
"name",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"for",
"i",
",",
"field",
":=",
"range",
"d",
"{",
"if",
"field",
".",
"Name",
"==",
"name",
"{",
"newField",
":... | // replaceBsonDField replaces a field in bson.D. | [
"replaceBsonDField",
"replaces",
"a",
"field",
"in",
"bson",
".",
"D",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L80-L90 |
5,147 | juju/juju | state/upgrades.go | RenameAddModelPermission | 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
for iter.Next(&doc) {
id, ok := doc["_id"]
if !ok {
return errors.New("no id found in permission doc")
}
ops = append(ops, txn.Op{
C: permissionsC,
Id: id,
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{{"access", "add-model"}}}},
})
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
return st.runRawTransaction(ops)
} | go | 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
for iter.Next(&doc) {
id, ok := doc["_id"]
if !ok {
return errors.New("no id found in permission doc")
}
ops = append(ops, txn.Op{
C: permissionsC,
Id: id,
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{{"access", "add-model"}}}},
})
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
return st.runRawTransaction(ops)
} | [
"func",
"RenameAddModelPermission",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"coll",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetRawCollection",
"(",
"permissionsC",
")",
"\n",... | // RenameAddModelPermission renames any permissions called addmodel to add-model. | [
"RenameAddModelPermission",
"renames",
"any",
"permissions",
"called",
"addmodel",
"to",
"add",
"-",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L93-L120 |
5,148 | juju/juju | state/upgrades.go | StripLocalUserDomain | 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 != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, usermodelnameC, "_id")
if err != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, controllerUsersC, "_id", "user", "createdby")
if err != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, modelUsersC, "_id", "user", "createdby")
if err != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, permissionsC, "_id", "subject-global-key")
if err != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, modelUserLastConnectionC, "_id", "user")
if err != nil {
return err
}
ops = append(ops, more...)
return st.runRawTransaction(ops)
} | go | 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 != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, usermodelnameC, "_id")
if err != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, controllerUsersC, "_id", "user", "createdby")
if err != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, modelUsersC, "_id", "user", "createdby")
if err != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, permissionsC, "_id", "subject-global-key")
if err != nil {
return err
}
ops = append(ops, more...)
more, err = stripLocalFromFields(st, modelUserLastConnectionC, "_id", "user")
if err != nil {
return err
}
ops = append(ops, more...)
return st.runRawTransaction(ops)
} | [
"func",
"StripLocalUserDomain",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"var",
"ops",
"[",
"]",
"txn",
".",
"Op",
"\n",
"more",
",",
"err",
":=",
"stripLocalFromFields",
"(",
"st",
",",
... | // StripLocalUserDomain removes any @local suffix from any relevant document field values. | [
"StripLocalUserDomain",
"removes",
"any"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L123-L168 |
5,149 | juju/juju | state/upgrades.go | AddMigrationAttempt | 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 doc bson.M
for iter.Next(&doc) {
id := doc["_id"]
attempt, err := extractMigrationAttempt(id)
if err != nil {
upgradesLogger.Warningf("%s (skipping)", err)
continue
}
ops = append(ops, txn.Op{
C: migrationsC,
Id: id,
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{{"attempt", attempt}}}},
})
}
if err := iter.Close(); err != nil {
return errors.Annotate(err, "iterating migrations")
}
return errors.Trace(st.runRawTransaction(ops))
} | go | 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 doc bson.M
for iter.Next(&doc) {
id := doc["_id"]
attempt, err := extractMigrationAttempt(id)
if err != nil {
upgradesLogger.Warningf("%s (skipping)", err)
continue
}
ops = append(ops, txn.Op{
C: migrationsC,
Id: id,
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{{"attempt", attempt}}}},
})
}
if err := iter.Close(); err != nil {
return errors.Annotate(err, "iterating migrations")
}
return errors.Trace(st.runRawTransaction(ops))
} | [
"func",
"AddMigrationAttempt",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"coll",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetRawCollection",
"(",
"migrationsC",
")",
"\n",
"de... | // AddMigrationAttempt adds an "attempt" field to migration documents
// which are missing one. | [
"AddMigrationAttempt",
"adds",
"an",
"attempt",
"field",
"to",
"migration",
"documents",
"which",
"are",
"missing",
"one",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L252-L283 |
5,150 | juju/juju | state/upgrades.go | AddLocalCharmSequences | 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)
if err != nil {
return errors.Trace(err)
}
// model UUID -> charm URL base -> max revision
maxRevs := make(map[string]map[string]int)
var deadIds []string
for _, doc := range docs {
id, ok := doc["_id"].(string)
if !ok {
upgradesLogger.Errorf("invalid charm id: %v", doc["_id"])
continue
}
modelUUID, urlStr, ok := splitDocID(id)
if !ok {
upgradesLogger.Errorf("unable to split charm _id: %v", id)
continue
}
url, err := charm.ParseURL(urlStr)
if err != nil {
upgradesLogger.Errorf("unable to parse charm URL: %v", err)
continue
}
if _, exists := maxRevs[modelUUID]; !exists {
maxRevs[modelUUID] = make(map[string]int)
}
baseURL := url.WithRevision(-1).String()
curRev := maxRevs[modelUUID][baseURL]
if url.Revision > curRev {
maxRevs[modelUUID][baseURL] = url.Revision
}
if life, ok := doc["life"].(int); !ok {
upgradesLogger.Errorf("invalid life for charm: %s", id)
continue
} else if life == int(Dead) {
deadIds = append(deadIds, id)
}
}
sequences, closer := st.db().GetRawCollection(sequenceC)
defer closer()
for modelUUID, modelRevs := range maxRevs {
for baseURL, maxRevision := range modelRevs {
name := charmRevSeqName(baseURL)
updater := newDbSeqUpdater(sequences, modelUUID, name)
err := updater.ensure(maxRevision + 1)
if err != nil {
return errors.Annotatef(err, "setting sequence %s", name)
}
}
}
// Remove dead charm documents
var ops []txn.Op
for _, id := range deadIds {
ops = append(ops, txn.Op{
C: charmsC,
Id: id,
Remove: true,
})
}
err = st.runRawTransaction(ops)
return errors.Annotate(err, "removing dead charms")
} | go | 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)
if err != nil {
return errors.Trace(err)
}
// model UUID -> charm URL base -> max revision
maxRevs := make(map[string]map[string]int)
var deadIds []string
for _, doc := range docs {
id, ok := doc["_id"].(string)
if !ok {
upgradesLogger.Errorf("invalid charm id: %v", doc["_id"])
continue
}
modelUUID, urlStr, ok := splitDocID(id)
if !ok {
upgradesLogger.Errorf("unable to split charm _id: %v", id)
continue
}
url, err := charm.ParseURL(urlStr)
if err != nil {
upgradesLogger.Errorf("unable to parse charm URL: %v", err)
continue
}
if _, exists := maxRevs[modelUUID]; !exists {
maxRevs[modelUUID] = make(map[string]int)
}
baseURL := url.WithRevision(-1).String()
curRev := maxRevs[modelUUID][baseURL]
if url.Revision > curRev {
maxRevs[modelUUID][baseURL] = url.Revision
}
if life, ok := doc["life"].(int); !ok {
upgradesLogger.Errorf("invalid life for charm: %s", id)
continue
} else if life == int(Dead) {
deadIds = append(deadIds, id)
}
}
sequences, closer := st.db().GetRawCollection(sequenceC)
defer closer()
for modelUUID, modelRevs := range maxRevs {
for baseURL, maxRevision := range modelRevs {
name := charmRevSeqName(baseURL)
updater := newDbSeqUpdater(sequences, modelUUID, name)
err := updater.ensure(maxRevision + 1)
if err != nil {
return errors.Annotatef(err, "setting sequence %s", name)
}
}
}
// Remove dead charm documents
var ops []txn.Op
for _, id := range deadIds {
ops = append(ops, txn.Op{
C: charmsC,
Id: id,
Remove: true,
})
}
err = st.runRawTransaction(ops)
return errors.Annotate(err, "removing dead charms")
} | [
"func",
"AddLocalCharmSequences",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"charmsColl",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetRawCollection",
"(",
"charmsC",
")",
"\n",
... | // AddLocalCharmSequences creates any missing sequences in the
// database for tracking already used local charm revisions. | [
"AddLocalCharmSequences",
"creates",
"any",
"missing",
"sequences",
"in",
"the",
"database",
"for",
"tracking",
"already",
"used",
"local",
"charm",
"revisions",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L306-L387 |
5,151 | juju/juju | state/upgrades.go | UpdateLegacyLXDCloudCredentials | 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)
}
return st.db().RunTransaction(append(cloudOps, credOps...))
} | go | 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)
}
return st.db().RunTransaction(append(cloudOps, credOps...))
} | [
"func",
"UpdateLegacyLXDCloudCredentials",
"(",
"st",
"*",
"State",
",",
"endpoint",
"string",
",",
"credential",
"cloud",
".",
"Credential",
",",
")",
"error",
"{",
"cloudOps",
",",
"err",
":=",
"updateLegacyLXDCloudsOps",
"(",
"st",
",",
"endpoint",
")",
"\n... | // UpdateLegacyLXDCloudCredentials updates the cloud credentials for the
// LXD-based controller, and updates the cloud endpoint with the given
// value. | [
"UpdateLegacyLXDCloudCredentials",
"updates",
"the",
"cloud",
"credentials",
"for",
"the",
"LXD",
"-",
"based",
"controller",
"and",
"updates",
"the",
"cloud",
"endpoint",
"with",
"the",
"given",
"value",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L392-L406 |
5,152 | juju/juju | state/upgrades.go | UpgradeNoProxyDefaults | 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]
noProxy, ok := noProxyVal.(string)
if !ok {
continue
}
noProxy = upgradeNoProxy(noProxy)
doc.Settings[config.NoProxyKey] = noProxy
ops = append(ops, txn.Op{
C: settingsC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Settings}},
})
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | go | 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]
noProxy, ok := noProxyVal.(string)
if !ok {
continue
}
noProxy = upgradeNoProxy(noProxy)
doc.Settings[config.NoProxyKey] = noProxy
ops = append(ops, txn.Op{
C: settingsC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Settings}},
})
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | [
"func",
"UpgradeNoProxyDefaults",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"var",
"ops",
"[",
"]",
"txn",
".",
"Op",
"\n",
"coll",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",... | // UpgradeNoProxyDefaults changes the default values of no_proxy
// to hold localhost values as defaults. | [
"UpgradeNoProxyDefaults",
"changes",
"the",
"default",
"values",
"of",
"no_proxy",
"to",
"hold",
"localhost",
"values",
"as",
"defaults",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L486-L516 |
5,153 | juju/juju | state/upgrades.go | RemoveNilValueApplicationSettings | 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) {
settingsChanged := false
for key, value := range doc.Settings {
if value != nil {
continue
}
settingsChanged = true
delete(doc.Settings, key)
}
if settingsChanged {
ops = append(ops, txn.Op{
C: settingsC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Settings}},
})
}
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | go | 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) {
settingsChanged := false
for key, value := range doc.Settings {
if value != nil {
continue
}
settingsChanged = true
delete(doc.Settings, key)
}
if settingsChanged {
ops = append(ops, txn.Op{
C: settingsC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Settings}},
})
}
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | [
"func",
"RemoveNilValueApplicationSettings",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"coll",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetRawCollection",
"(",
"settingsC",
")",
... | // RemoveNilValueApplicationSettings removes any application setting
// key-value pairs from "settings" where value is nil. | [
"RemoveNilValueApplicationSettings",
"removes",
"any",
"application",
"setting",
"key",
"-",
"value",
"pairs",
"from",
"settings",
"where",
"value",
"is",
"nil",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L665-L698 |
5,154 | juju/juju | state/upgrades.go | AddControllerLogCollectionsSizeSettings | 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
}
return errors.Trace(err)
}
var ops []txn.Op
settingsChanged := maybeUpdateSettings(doc.Settings, controller.MaxLogsAge, fmt.Sprintf("%vh", controller.DefaultMaxLogsAgeDays*24))
settingsChanged =
maybeUpdateSettings(doc.Settings, controller.MaxLogsSize, fmt.Sprintf("%vM", controller.DefaultMaxLogCollectionMB)) || settingsChanged
settingsChanged =
maybeUpdateSettings(doc.Settings, controller.MaxTxnLogSize, fmt.Sprintf("%vM", controller.DefaultMaxTxnLogCollectionMB)) || settingsChanged
if settingsChanged {
ops = append(ops, txn.Op{
C: controllersC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Settings}},
})
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | go | 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
}
return errors.Trace(err)
}
var ops []txn.Op
settingsChanged := maybeUpdateSettings(doc.Settings, controller.MaxLogsAge, fmt.Sprintf("%vh", controller.DefaultMaxLogsAgeDays*24))
settingsChanged =
maybeUpdateSettings(doc.Settings, controller.MaxLogsSize, fmt.Sprintf("%vM", controller.DefaultMaxLogCollectionMB)) || settingsChanged
settingsChanged =
maybeUpdateSettings(doc.Settings, controller.MaxTxnLogSize, fmt.Sprintf("%vM", controller.DefaultMaxTxnLogCollectionMB)) || settingsChanged
if settingsChanged {
ops = append(ops, txn.Op{
C: controllersC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Settings}},
})
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | [
"func",
"AddControllerLogCollectionsSizeSettings",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"coll",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetRawCollection",
"(",
"controllersC",... | // AddControllerLogCollectionsSizeSettings adds the controller
// settings to control log pruning and txn log size if they are missing. | [
"AddControllerLogCollectionsSizeSettings",
"adds",
"the",
"controller",
"settings",
"to",
"control",
"log",
"pruning",
"and",
"txn",
"log",
"size",
"if",
"they",
"are",
"missing",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L702-L732 |
5,155 | juju/juju | state/upgrades.go | applyToAllModelSettings | 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")
}
iter := coll.Find(bson.M{"_id": bson.M{"$in": ids}}).Iter()
defer iter.Close()
var ops []txn.Op
var doc settingsDoc
for iter.Next(&doc) {
settingsChanged, err := change(&doc)
if err != nil {
return errors.Trace(err)
}
if settingsChanged {
ops = append(ops, txn.Op{
C: settingsC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Settings}},
})
}
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | go | 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")
}
iter := coll.Find(bson.M{"_id": bson.M{"$in": ids}}).Iter()
defer iter.Close()
var ops []txn.Op
var doc settingsDoc
for iter.Next(&doc) {
settingsChanged, err := change(&doc)
if err != nil {
return errors.Trace(err)
}
if settingsChanged {
ops = append(ops, txn.Op{
C: settingsC,
Id: doc.DocID,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"settings": doc.Settings}},
})
}
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | [
"func",
"applyToAllModelSettings",
"(",
"st",
"*",
"State",
",",
"change",
"func",
"(",
"*",
"settingsDoc",
")",
"(",
"bool",
",",
"error",
")",
")",
"error",
"{",
"uuids",
",",
"err",
":=",
"st",
".",
"AllModelUUIDs",
"(",
")",
"\n",
"if",
"err",
"!... | // applyToAllModelSettings iterates the model settings documents and applys the
// passed in function to them. If the function returns 'true' it indicates the
// settings have been modified, and they should be written back to the
// database.
// Note that if there are any problems with updating settings, then none of the
// changes will be applied, as they are all updated in a single transaction. | [
"applyToAllModelSettings",
"iterates",
"the",
"model",
"settings",
"documents",
"and",
"applys",
"the",
"passed",
"in",
"function",
"to",
"them",
".",
"If",
"the",
"function",
"returns",
"true",
"it",
"indicates",
"the",
"settings",
"have",
"been",
"modified",
"... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L748-L788 |
5,156 | juju/juju | state/upgrades.go | AddStatusHistoryPruneSettings | 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 =
maybeUpdateSettings(doc.Settings, config.MaxStatusHistorySize, config.DefaultStatusHistorySize) || settingsChanged
return settingsChanged, nil
})
if err != nil {
return errors.Trace(err)
}
return nil
} | go | 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 =
maybeUpdateSettings(doc.Settings, config.MaxStatusHistorySize, config.DefaultStatusHistorySize) || settingsChanged
return settingsChanged, nil
})
if err != nil {
return errors.Trace(err)
}
return nil
} | [
"func",
"AddStatusHistoryPruneSettings",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"err",
":=",
"applyToAllModelSettings",
"(",
"st",
",",
"func",
"(",
"doc",
"*",
"settingsDoc",
")",
"(",
"bo... | // AddStatusHistoryPruneSettings adds the model settings
// to control log pruning if they are missing. | [
"AddStatusHistoryPruneSettings",
"adds",
"the",
"model",
"settings",
"to",
"control",
"log",
"pruning",
"if",
"they",
"are",
"missing",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L792-L805 |
5,157 | juju/juju | state/upgrades.go | AddActionPruneSettings | 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.Settings, config.MaxActionResultsSize, config.DefaultActionResultsSize) || settingsChanged
return settingsChanged, nil
})
if err != nil {
return errors.Trace(err)
}
return nil
} | go | 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.Settings, config.MaxActionResultsSize, config.DefaultActionResultsSize) || settingsChanged
return settingsChanged, nil
})
if err != nil {
return errors.Trace(err)
}
return nil
} | [
"func",
"AddActionPruneSettings",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"err",
":=",
"applyToAllModelSettings",
"(",
"st",
",",
"func",
"(",
"doc",
"*",
"settingsDoc",
")",
"(",
"bool",
... | // AddActionPruneSettings adds the model settings
// to control log pruning if they are missing. | [
"AddActionPruneSettings",
"adds",
"the",
"model",
"settings",
"to",
"control",
"log",
"pruning",
"if",
"they",
"are",
"missing",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L809-L822 |
5,158 | juju/juju | state/upgrades.go | AddUpdateStatusHookSettings | 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
})
if err != nil {
return errors.Trace(err)
}
return nil
} | go | 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
})
if err != nil {
return errors.Trace(err)
}
return nil
} | [
"func",
"AddUpdateStatusHookSettings",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"err",
":=",
"applyToAllModelSettings",
"(",
"st",
",",
"func",
"(",
"doc",
"*",
"settingsDoc",
")",
"(",
"bool... | // AddUpdateStatusHookSettings adds the model settings
// to control how often to run the update-status hook
// if they are missing. | [
"AddUpdateStatusHookSettings",
"adds",
"the",
"model",
"settings",
"to",
"control",
"how",
"often",
"to",
"run",
"the",
"update",
"-",
"status",
"hook",
"if",
"they",
"are",
"missing",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L827-L838 |
5,159 | juju/juju | state/upgrades.go | SplitLogCollections | 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.Find(nil).Iter()
defer iter.Close()
var doc bson.M
for iter.Next(&doc) {
modelUUID := doc["e"].(string)
newCollName := logCollectionName(modelUUID)
newLogs := db.C(newCollName)
if !seen.Contains(newCollName) {
if err := InitDbLogs(session, modelUUID); err != nil {
return errors.Annotatef(err, "failed to init new logs collection %q", newCollName)
}
seen.Add(newCollName)
}
delete(doc, "e") // old model uuid
if err := newLogs.Insert(doc); err != nil {
// In the case of a restart, we may have already moved
// some of these rows, in which case we'd get a duplicate
// id error (this is OK).
if !mgo.IsDup(err) {
return errors.Annotate(err, "failed to insert log record")
}
}
doc = nil
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
// drop the old collection
if err := oldLogs.DropCollection(); err != nil {
// If the namespace is already missing, that's fine.
if isMgoNamespaceNotFound(err) {
return nil
}
return errors.Annotate(err, "failed to drop old logs collection")
}
return nil
} | go | 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.Find(nil).Iter()
defer iter.Close()
var doc bson.M
for iter.Next(&doc) {
modelUUID := doc["e"].(string)
newCollName := logCollectionName(modelUUID)
newLogs := db.C(newCollName)
if !seen.Contains(newCollName) {
if err := InitDbLogs(session, modelUUID); err != nil {
return errors.Annotatef(err, "failed to init new logs collection %q", newCollName)
}
seen.Add(newCollName)
}
delete(doc, "e") // old model uuid
if err := newLogs.Insert(doc); err != nil {
// In the case of a restart, we may have already moved
// some of these rows, in which case we'd get a duplicate
// id error (this is OK).
if !mgo.IsDup(err) {
return errors.Annotate(err, "failed to insert log record")
}
}
doc = nil
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
// drop the old collection
if err := oldLogs.DropCollection(); err != nil {
// If the namespace is already missing, that's fine.
if isMgoNamespaceNotFound(err) {
return nil
}
return errors.Annotate(err, "failed to drop old logs collection")
}
return nil
} | [
"func",
"SplitLogCollections",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"session",
":=",
"st",
".",
"MongoSession",
"(",
")",
"\n",
"db",
":=",
"session",
".",
"DB",
"(",
"logsDB",
")",
... | // SplitLogCollections moves log entries from the old single log collection
// to the log collection per model. | [
"SplitLogCollections",
"moves",
"log",
"entries",
"from",
"the",
"old",
"single",
"log",
"collection",
"to",
"the",
"log",
"collection",
"per",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L947-L998 |
5,160 | juju/juju | state/upgrades.go | MoveOldAuditLog | 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().GetRawCollection("audit.log")
defer closer()
rows, err := coll.Count()
if err != nil {
return errors.Trace(err)
}
if rows == 0 {
return errors.Trace(coll.DropCollection())
}
session := st.MongoSession()
renameCommand := bson.D{
{"renameCollection", "juju.audit.log"},
{"to", "juju.old-audit.log"},
}
return errors.Trace(session.Run(renameCommand, nil))
} | go | 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().GetRawCollection("audit.log")
defer closer()
rows, err := coll.Count()
if err != nil {
return errors.Trace(err)
}
if rows == 0 {
return errors.Trace(coll.DropCollection())
}
session := st.MongoSession()
renameCommand := bson.D{
{"renameCollection", "juju.audit.log"},
{"to", "juju.old-audit.log"},
}
return errors.Trace(session.Run(renameCommand, nil))
} | [
"func",
"MoveOldAuditLog",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"names",
",",
"err",
":=",
"st",
".",
"MongoSession",
"(",
")",
".",
"DB",
"(",
"\"",
"\"",
")",
".",
"CollectionName... | // MoveOldAuditLog renames the no-longer-needed audit.log collection
// to old-audit.log if it has any rows - if it's empty it deletes it. | [
"MoveOldAuditLog",
"renames",
"the",
"no",
"-",
"longer",
"-",
"needed",
"audit",
".",
"log",
"collection",
"to",
"old",
"-",
"audit",
".",
"log",
"if",
"it",
"has",
"any",
"rows",
"-",
"if",
"it",
"s",
"empty",
"it",
"deletes",
"it",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1400-L1427 |
5,161 | juju/juju | state/upgrades.go | DeleteCloudImageMetadata | 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, "deleting cloud image metadata records")
} | go | 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, "deleting cloud image metadata records")
} | [
"func",
"DeleteCloudImageMetadata",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"coll",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetRawCollection",
"(",
"cloudimagemetadataC",
")",
... | // DeleteCloudImageMetadata deletes any non-custom cloud
// image metadata records from the cloudimagemetadata collection. | [
"DeleteCloudImageMetadata",
"deletes",
"any",
"non",
"-",
"custom",
"cloud",
"image",
"metadata",
"records",
"from",
"the",
"cloudimagemetadata",
"collection",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1431-L1441 |
5,162 | juju/juju | state/upgrades.go | MoveMongoSpaceToHASpaceConfig | 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
controllerColl, controllerCloser := st.db().GetRawCollection(controllersC)
defer controllerCloser()
err := controllerColl.Find(bson.D{{"_id", modelGlobalKey}}).One(&doc)
if err != nil {
return errors.Annotate(err, "retrieving controller info doc")
}
mongoSpace := doc.MongoSpaceName
if doc.MongoSpaceState == "valid" && mongoSpace != "" {
settings, err := readSettings(st.db(), controllersC, controllerSettingsGlobalKey)
if err != nil {
return errors.Annotate(err, "cannot get controller config")
}
// In the unlikely event that there is already a juju-ha-space
// configuration setting, we do not copy over it with the old Mongo
// space name.
if haSpace, ok := settings.Get(controller.JujuHASpace); ok {
upgradesLogger.Debugf("not copying mongo-space-name %q to juju-ha-space - already set to %q",
mongoSpace, haSpace)
} else {
settings.Set(controller.JujuHASpace, mongoSpace)
if _, err = settings.Write(); err != nil {
return errors.Annotate(err, "writing controller info")
}
}
}
err = controllerColl.UpdateId(modelGlobalKey, bson.M{"$unset": bson.M{
"mongo-space-name": 1,
"mongo-space-state": 1,
}})
return errors.Annotate(err, "removing mongo-space-state and mongo-space-name")
} | go | 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
controllerColl, controllerCloser := st.db().GetRawCollection(controllersC)
defer controllerCloser()
err := controllerColl.Find(bson.D{{"_id", modelGlobalKey}}).One(&doc)
if err != nil {
return errors.Annotate(err, "retrieving controller info doc")
}
mongoSpace := doc.MongoSpaceName
if doc.MongoSpaceState == "valid" && mongoSpace != "" {
settings, err := readSettings(st.db(), controllersC, controllerSettingsGlobalKey)
if err != nil {
return errors.Annotate(err, "cannot get controller config")
}
// In the unlikely event that there is already a juju-ha-space
// configuration setting, we do not copy over it with the old Mongo
// space name.
if haSpace, ok := settings.Get(controller.JujuHASpace); ok {
upgradesLogger.Debugf("not copying mongo-space-name %q to juju-ha-space - already set to %q",
mongoSpace, haSpace)
} else {
settings.Set(controller.JujuHASpace, mongoSpace)
if _, err = settings.Write(); err != nil {
return errors.Annotate(err, "writing controller info")
}
}
}
err = controllerColl.UpdateId(modelGlobalKey, bson.M{"$unset": bson.M{
"mongo-space-name": 1,
"mongo-space-state": 1,
}})
return errors.Annotate(err, "removing mongo-space-state and mongo-space-name")
} | [
"func",
"MoveMongoSpaceToHASpaceConfig",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"// Holds Mongo space fields removed from controllersDoc.",
"type",
"controllersUpgradeDoc",
"struct",
"{",
"MongoSpaceName",... | // CopyMongoSpaceToHASpaceConfig copies the Mongo space name from
// ControllerInfo to the HA space name in ControllerConfig.
// This only happens if the Mongo space state is valid, it is not empty,
// and if there is no value already set for the HA space name.
// The old keys are then deleted from ControllerInfo. | [
"CopyMongoSpaceToHASpaceConfig",
"copies",
"the",
"Mongo",
"space",
"name",
"from",
"ControllerInfo",
"to",
"the",
"HA",
"space",
"name",
"in",
"ControllerConfig",
".",
"This",
"only",
"happens",
"if",
"the",
"Mongo",
"space",
"state",
"is",
"valid",
"it",
"is",... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1448-L1490 |
5,163 | juju/juju | state/upgrades.go | CreateMissingApplicationConfig | 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{"#application$", ""}}}).All(&applicationConfigIDs)
allIDs := set.NewStrings()
for _, id := range applicationConfigIDs {
allIDs.Add(id.ID)
}
appsColl, appsCloser := st.db().GetRawCollection(applicationsC)
defer appsCloser()
var applicationNames []struct {
Name string `bson:"name"`
ModelUUID string `bson:"model-uuid"`
}
appsColl.Find(nil).All(&applicationNames)
var newAppConfigOps []txn.Op
emptySettings := make(map[string]interface{})
for _, app := range applicationNames {
appConfID := fmt.Sprintf("%s:%s", app.ModelUUID, applicationConfigKey(app.Name))
if !allIDs.Contains(appConfID) {
newOp := createSettingsOp(settingsC, appConfID, emptySettings)
// createSettingsOp assumes you're using a model-specific state, which will auto-inject the ModelUUID
// since we're doing this globally, cast it to the underlying type and add it.
newOp.Insert.(*settingsDoc).ModelUUID = app.ModelUUID
newAppConfigOps = append(newAppConfigOps, newOp)
}
}
err := st.db().RunRawTransaction(newAppConfigOps)
if err != nil {
return errors.Annotate(err, "writing application configs")
}
return nil
} | go | 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{"#application$", ""}}}).All(&applicationConfigIDs)
allIDs := set.NewStrings()
for _, id := range applicationConfigIDs {
allIDs.Add(id.ID)
}
appsColl, appsCloser := st.db().GetRawCollection(applicationsC)
defer appsCloser()
var applicationNames []struct {
Name string `bson:"name"`
ModelUUID string `bson:"model-uuid"`
}
appsColl.Find(nil).All(&applicationNames)
var newAppConfigOps []txn.Op
emptySettings := make(map[string]interface{})
for _, app := range applicationNames {
appConfID := fmt.Sprintf("%s:%s", app.ModelUUID, applicationConfigKey(app.Name))
if !allIDs.Contains(appConfID) {
newOp := createSettingsOp(settingsC, appConfID, emptySettings)
// createSettingsOp assumes you're using a model-specific state, which will auto-inject the ModelUUID
// since we're doing this globally, cast it to the underlying type and add it.
newOp.Insert.(*settingsDoc).ModelUUID = app.ModelUUID
newAppConfigOps = append(newAppConfigOps, newOp)
}
}
err := st.db().RunRawTransaction(newAppConfigOps)
if err != nil {
return errors.Annotate(err, "writing application configs")
}
return nil
} | [
"func",
"CreateMissingApplicationConfig",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"settingsColl",
",",
"settingsCloser",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetRawCollection",
"(",
"setting... | // CreateMissingApplicationConfig ensures that all models have an application config in the db. | [
"CreateMissingApplicationConfig",
"ensures",
"that",
"all",
"models",
"have",
"an",
"application",
"config",
"in",
"the",
"db",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1493-L1535 |
5,164 | juju/juju | state/upgrades.go | RemoveVotingMachineIds | 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 := controllerColl.UpdateId(modelGlobalKey, bson.M{"$unset": bson.M{"votingmachineids": 1}})
if err != nil {
return errors.Annotate(err, "removing votingmachineids")
}
return nil
} | go | 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 := controllerColl.UpdateId(modelGlobalKey, bson.M{"$unset": bson.M{"votingmachineids": 1}})
if err != nil {
return errors.Annotate(err, "removing votingmachineids")
}
return nil
} | [
"func",
"RemoveVotingMachineIds",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"controllerColl",
",",
"controllerCloser",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetRawCollection",
"(",
"controllers... | // RemoveVotingMachineIds ensures that the 'votingmachineids' field on controller info has been removed | [
"RemoveVotingMachineIds",
"ensures",
"that",
"the",
"votingmachineids",
"field",
"on",
"controller",
"info",
"has",
"been",
"removed"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1538-L1549 |
5,165 | juju/juju | state/upgrades.go | AddCloudModelCounts | 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 closer()
refCountColl, closer := st.db().GetCollection(globalRefcountsC)
defer closer()
var updateOps []txn.Op
for _, c := range clouds {
n, err := modelsColl.Find(bson.D{{"cloud", c.Name}}).Count()
if err != nil {
return errors.Trace(err)
}
_, currentCount, err := countCloudModelRefOp(st, c.Name)
if err != nil {
return errors.Trace(err)
}
if n != currentCount {
op, err := nsRefcounts.CreateOrIncRefOp(refCountColl, cloudModelRefCountKey(c.Name), n-currentCount)
if err != nil {
return errors.Trace(err)
}
updateOps = append(updateOps, op)
}
}
return st.db().RunTransaction(updateOps)
} | go | 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 closer()
refCountColl, closer := st.db().GetCollection(globalRefcountsC)
defer closer()
var updateOps []txn.Op
for _, c := range clouds {
n, err := modelsColl.Find(bson.D{{"cloud", c.Name}}).Count()
if err != nil {
return errors.Trace(err)
}
_, currentCount, err := countCloudModelRefOp(st, c.Name)
if err != nil {
return errors.Trace(err)
}
if n != currentCount {
op, err := nsRefcounts.CreateOrIncRefOp(refCountColl, cloudModelRefCountKey(c.Name), n-currentCount)
if err != nil {
return errors.Trace(err)
}
updateOps = append(updateOps, op)
}
}
return st.db().RunTransaction(updateOps)
} | [
"func",
"AddCloudModelCounts",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"cloudsColl",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"cloudsC",
")",
"\n",
"def... | // AddCloudModelCounts updates cloud docs to ensure the model count field is set. | [
"AddCloudModelCounts",
"updates",
"cloud",
"docs",
"to",
"ensure",
"the",
"model",
"count",
"field",
"is",
"set",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1552-L1587 |
5,166 | juju/juju | state/upgrades.go | UpgradeContainerImageStreamDefault | 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 false, nil
}
}
doc.Settings[config.ContainerImageStreamKey] = "released"
return true, nil
})
if err != nil {
return errors.Trace(err)
}
return nil
} | go | 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 false, nil
}
}
doc.Settings[config.ContainerImageStreamKey] = "released"
return true, nil
})
if err != nil {
return errors.Trace(err)
}
return nil
} | [
"func",
"UpgradeContainerImageStreamDefault",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"err",
":=",
"applyToAllModelSettings",
"(",
"st",
",",
"func",
"(",
"doc",
"*",
"settingsDoc",
")",
"(",
... | // UpgradeDefaultContainerImageStreamConfig ensures that the config value for
// container-image-stream is set to its default value, "released". | [
"UpgradeDefaultContainerImageStreamConfig",
"ensures",
"that",
"the",
"config",
"value",
"for",
"container",
"-",
"image",
"-",
"stream",
"is",
"set",
"to",
"its",
"default",
"value",
"released",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1591-L1607 |
5,167 | juju/juju | state/upgrades.go | ReplicaSetMembers | func ReplicaSetMembers(pool *StatePool) ([]replicaset.Member, error) {
return replicaset.CurrentMembers(pool.SystemState().MongoSession())
} | go | func ReplicaSetMembers(pool *StatePool) ([]replicaset.Member, error) {
return replicaset.CurrentMembers(pool.SystemState().MongoSession())
} | [
"func",
"ReplicaSetMembers",
"(",
"pool",
"*",
"StatePool",
")",
"(",
"[",
"]",
"replicaset",
".",
"Member",
",",
"error",
")",
"{",
"return",
"replicaset",
".",
"CurrentMembers",
"(",
"pool",
".",
"SystemState",
"(",
")",
".",
"MongoSession",
"(",
")",
... | // ReplicaSetMembers gets the members of the current Mongo replica
// set. These are needed to bootstrap the raft cluster in an upgrade
// and using MongoSession directly from an upgrade steps would make
// testing difficult. | [
"ReplicaSetMembers",
"gets",
"the",
"members",
"of",
"the",
"current",
"Mongo",
"replica",
"set",
".",
"These",
"are",
"needed",
"to",
"bootstrap",
"the",
"raft",
"cluster",
"in",
"an",
"upgrade",
"and",
"using",
"MongoSession",
"directly",
"from",
"an",
"upgr... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1673-L1675 |
5,168 | juju/juju | state/upgrades.go | LegacyLeases | 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 {
return nil, errors.Trace(err)
}
globalTime, err := reader.Now()
// This needs to be the raw collection so we see all leases across
// models.
leaseCollection, closer := st.db().GetRawCollection(leasesC)
defer closer()
iter := leaseCollection.Find(nil).Iter()
results := make(map[corelease.Key]corelease.Info)
var doc struct {
Namespace string `bson:"namespace"`
ModelUUID string `bson:"model-uuid"`
Name string `bson:"name"`
Holder string `bson:"holder"`
Start int64 `bson:"start"`
Duration time.Duration `bson:"duration"`
}
for iter.Next(&doc) {
startTime := time.Unix(0, doc.Start)
globalExpiry := startTime.Add(doc.Duration)
remaining := globalExpiry.Sub(globalTime)
localExpiry := localTime.Add(remaining)
key := corelease.Key{
Namespace: doc.Namespace,
ModelUUID: doc.ModelUUID,
Lease: doc.Name,
}
results[key] = corelease.Info{
Holder: doc.Holder,
Expiry: localExpiry,
Trapdoor: nil,
}
}
if err := iter.Close(); err != nil {
return nil, errors.Trace(err)
}
return results, nil
} | go | 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 {
return nil, errors.Trace(err)
}
globalTime, err := reader.Now()
// This needs to be the raw collection so we see all leases across
// models.
leaseCollection, closer := st.db().GetRawCollection(leasesC)
defer closer()
iter := leaseCollection.Find(nil).Iter()
results := make(map[corelease.Key]corelease.Info)
var doc struct {
Namespace string `bson:"namespace"`
ModelUUID string `bson:"model-uuid"`
Name string `bson:"name"`
Holder string `bson:"holder"`
Start int64 `bson:"start"`
Duration time.Duration `bson:"duration"`
}
for iter.Next(&doc) {
startTime := time.Unix(0, doc.Start)
globalExpiry := startTime.Add(doc.Duration)
remaining := globalExpiry.Sub(globalTime)
localExpiry := localTime.Add(remaining)
key := corelease.Key{
Namespace: doc.Namespace,
ModelUUID: doc.ModelUUID,
Lease: doc.Name,
}
results[key] = corelease.Info{
Holder: doc.Holder,
Expiry: localExpiry,
Trapdoor: nil,
}
}
if err := iter.Close(); err != nil {
return nil, errors.Trace(err)
}
return results, nil
} | [
"func",
"LegacyLeases",
"(",
"pool",
"*",
"StatePool",
",",
"localTime",
"time",
".",
"Time",
")",
"(",
"map",
"[",
"corelease",
".",
"Key",
"]",
"corelease",
".",
"Info",
",",
"error",
")",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n"... | // LegacyLeases returns information about all of the leases in the
// state-based lease store. | [
"LegacyLeases",
"returns",
"information",
"about",
"all",
"of",
"the",
"leases",
"in",
"the",
"state",
"-",
"based",
"lease",
"store",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1728-L1777 |
5,169 | juju/juju | state/upgrades.go | MigrateAddModelPermissions | 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.ControllerUUID()) + "#us#.*"},
"access": "add-model",
}
iter := coll.Find(query).Iter()
var doc struct {
DocId string `bson:"_id"`
ObjectGlobalKey string `bson:"object-global-key"`
SubjectGlobalKey string `bson:"subject-global-key"`
Access string `bson:"access"`
}
var ops []txn.Op
// Set all the existng controller add-model permissions back to login.
// Create a new cloud permission for add-model.
for iter.Next(&doc) {
ops = append(ops, txn.Op{
C: permissionsC,
Id: doc.DocId,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"access": "login"}},
})
ops = append(ops,
createPermissionOp(cloudGlobalKey(controllerInfo.CloudName), doc.SubjectGlobalKey, permission.AddModelAccess))
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | go | 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.ControllerUUID()) + "#us#.*"},
"access": "add-model",
}
iter := coll.Find(query).Iter()
var doc struct {
DocId string `bson:"_id"`
ObjectGlobalKey string `bson:"object-global-key"`
SubjectGlobalKey string `bson:"subject-global-key"`
Access string `bson:"access"`
}
var ops []txn.Op
// Set all the existng controller add-model permissions back to login.
// Create a new cloud permission for add-model.
for iter.Next(&doc) {
ops = append(ops, txn.Op{
C: permissionsC,
Id: doc.DocId,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"access": "login"}},
})
ops = append(ops,
createPermissionOp(cloudGlobalKey(controllerInfo.CloudName), doc.SubjectGlobalKey, permission.AddModelAccess))
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | [
"func",
"MigrateAddModelPermissions",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"controllerInfo",
",",
"err",
":=",
"st",
".",
"ControllerInfo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{"... | // MigrateAddModelPermissions converts add-model permissions on the controller
// to add-model permissions on the controller cloud. | [
"MigrateAddModelPermissions",
"converts",
"add",
"-",
"model",
"permissions",
"on",
"the",
"controller",
"to",
"add",
"-",
"model",
"permissions",
"on",
"the",
"controller",
"cloud",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1781-L1824 |
5,170 | juju/juju | state/upgrades.go | SetEnableDiskUUIDOnVsphere | 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 false, nil
}
_, found = doc.Settings["enable-disk-uuid"]
if found {
// If the config option's already been set don't change
// it.
return false, nil
}
doc.Settings["enable-disk-uuid"] = false
return true, nil
}))
} | go | 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 false, nil
}
_, found = doc.Settings["enable-disk-uuid"]
if found {
// If the config option's already been set don't change
// it.
return false, nil
}
doc.Settings["enable-disk-uuid"] = false
return true, nil
}))
} | [
"func",
"SetEnableDiskUUIDOnVsphere",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"return",
"errors",
".",
"Trace",
"(",
"applyToAllModelSettings",
"(",
"pool",
".",
"SystemState",
"(",
")",
",",
"func",
"(",
"doc",
"*",
"settingsDoc",
")",
"(",
"bool"... | // SetEnableDiskUUIDOnVsphere updates the settings for all vsphere
// models to have enable-disk-uuid=false. The new default is true, but
// this maintains the previous behaviour for upgraded models. | [
"SetEnableDiskUUIDOnVsphere",
"updates",
"the",
"settings",
"for",
"all",
"vsphere",
"models",
"to",
"have",
"enable",
"-",
"disk",
"-",
"uuid",
"=",
"false",
".",
"The",
"new",
"default",
"is",
"true",
"but",
"this",
"maintains",
"the",
"previous",
"behaviour... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1829-L1848 |
5,171 | juju/juju | state/upgrades.go | UpdateInheritedControllerConfig | 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("controller").Iter()
defer iter.Close()
var doc settingsDoc
for iter.Next(&doc) {
ops = append(ops, txn.Op{
C: globalSettingsC,
Id: doc.DocID,
Remove: true,
Assert: txn.DocExists,
})
doc.DocID = key
ops = append(ops, txn.Op{
C: globalSettingsC,
Id: key,
Insert: doc,
Assert: txn.DocMissing,
})
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
err = errors.Trace(st.runRawTransaction(ops))
return err
}
return nil
} | go | 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("controller").Iter()
defer iter.Close()
var doc settingsDoc
for iter.Next(&doc) {
ops = append(ops, txn.Op{
C: globalSettingsC,
Id: doc.DocID,
Remove: true,
Assert: txn.DocExists,
})
doc.DocID = key
ops = append(ops, txn.Op{
C: globalSettingsC,
Id: key,
Insert: doc,
Assert: txn.DocMissing,
})
}
if err := iter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
err = errors.Trace(st.runRawTransaction(ops))
return err
}
return nil
} | [
"func",
"UpdateInheritedControllerConfig",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"model",
",",
"err",
":=",
"st",
".",
"Model",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",... | // UpdateInheritedControllerConfig migrates the existing global
// settings doc keyed on "controller" to be keyed on the cloud name. | [
"UpdateInheritedControllerConfig",
"migrates",
"the",
"existing",
"global",
"settings",
"doc",
"keyed",
"on",
"controller",
"to",
"be",
"keyed",
"on",
"the",
"cloud",
"name",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1852-L1889 |
5,172 | juju/juju | state/upgrades.go | EnsureDefaultModificationStatus | 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)
defer statusCloser()
var ops []txn.Op
var machine machineDoc
updatedTime := st.clock().Now().UnixNano()
for machineIter.Next(&machine) {
// Since we are using a raw collection, we need to manually
// ensure that we prefix the IDs with the model-uuid.
localID := machineGlobalModificationKey(machine.Id)
key := ensureModelUUID(machine.ModelUUID, localID)
// We only need to migrate machines that don't have a modification
// status document. So we need to first check if there is one, before
// creating a txn.Op for the missing document.
var doc statusDoc
err := statusCol.Find(bson.D{{"_id", key}}).Select(bson.D{{"_id", 1}}).One(&doc)
if err == nil {
continue
} else if err != mgo.ErrNotFound {
return errors.Trace(err)
}
rawDoc := statusDoc{
ModelUUID: machine.ModelUUID,
Status: status.Idle,
Updated: updatedTime,
}
ops = append(ops, txn.Op{
C: statusesC,
Id: key,
Assert: txn.DocMissing,
Insert: rawDoc,
})
}
if err := machineIter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | go | 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)
defer statusCloser()
var ops []txn.Op
var machine machineDoc
updatedTime := st.clock().Now().UnixNano()
for machineIter.Next(&machine) {
// Since we are using a raw collection, we need to manually
// ensure that we prefix the IDs with the model-uuid.
localID := machineGlobalModificationKey(machine.Id)
key := ensureModelUUID(machine.ModelUUID, localID)
// We only need to migrate machines that don't have a modification
// status document. So we need to first check if there is one, before
// creating a txn.Op for the missing document.
var doc statusDoc
err := statusCol.Find(bson.D{{"_id", key}}).Select(bson.D{{"_id", 1}}).One(&doc)
if err == nil {
continue
} else if err != mgo.ErrNotFound {
return errors.Trace(err)
}
rawDoc := statusDoc{
ModelUUID: machine.ModelUUID,
Status: status.Idle,
Updated: updatedTime,
}
ops = append(ops, txn.Op{
C: statusesC,
Id: key,
Assert: txn.DocMissing,
Insert: rawDoc,
})
}
if err := machineIter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | [
"func",
"EnsureDefaultModificationStatus",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"db",
":=",
"st",
".",
"db",
"(",
")",
"\n\n",
"machineCol",
",",
"machineCloser",
":=",
"db",
".",
"GetR... | // EnsureDefaultModificationStatus ensures that there is a modification status
// document for every machine in the statuses. | [
"EnsureDefaultModificationStatus",
"ensures",
"that",
"there",
"is",
"a",
"modification",
"status",
"document",
"for",
"every",
"machine",
"in",
"the",
"statuses",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L1988-L2039 |
5,173 | juju/juju | state/upgrades.go | EnsureApplicationDeviceConstraints | 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, constraintsCloser := db.GetRawCollection(deviceConstraintsC)
defer constraintsCloser()
var ops []txn.Op
var application applicationDoc
for applicationIter.Next(&application) {
// Since we are using a raw collection, we need to manually
// ensure that we prefix the IDs with the model-uuid.
localID := applicationDeviceConstraintsKey(application.Name, application.CharmURL)
key := ensureModelUUID(application.ModelUUID, localID)
// We only need to migrate applications that don't have a device
// constraints document. So we need to first check if there is one, before
// creating a txn.Op for the missing document.
var doc statusDoc
err := constraintsCol.Find(bson.D{{"_id", key}}).Select(bson.D{{"_id", 1}}).One(&doc)
if err == nil {
continue
} else if err != mgo.ErrNotFound {
return errors.Trace(err)
}
ops = append(ops, txn.Op{
C: deviceConstraintsC,
Id: key,
Assert: txn.DocMissing,
Insert: deviceConstraintsDoc{},
})
}
if err := applicationIter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | go | 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, constraintsCloser := db.GetRawCollection(deviceConstraintsC)
defer constraintsCloser()
var ops []txn.Op
var application applicationDoc
for applicationIter.Next(&application) {
// Since we are using a raw collection, we need to manually
// ensure that we prefix the IDs with the model-uuid.
localID := applicationDeviceConstraintsKey(application.Name, application.CharmURL)
key := ensureModelUUID(application.ModelUUID, localID)
// We only need to migrate applications that don't have a device
// constraints document. So we need to first check if there is one, before
// creating a txn.Op for the missing document.
var doc statusDoc
err := constraintsCol.Find(bson.D{{"_id", key}}).Select(bson.D{{"_id", 1}}).One(&doc)
if err == nil {
continue
} else if err != mgo.ErrNotFound {
return errors.Trace(err)
}
ops = append(ops, txn.Op{
C: deviceConstraintsC,
Id: key,
Assert: txn.DocMissing,
Insert: deviceConstraintsDoc{},
})
}
if err := applicationIter.Close(); err != nil {
return errors.Trace(err)
}
if len(ops) > 0 {
return errors.Trace(st.runRawTransaction(ops))
}
return nil
} | [
"func",
"EnsureApplicationDeviceConstraints",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"st",
":=",
"pool",
".",
"SystemState",
"(",
")",
"\n",
"db",
":=",
"st",
".",
"db",
"(",
")",
"\n\n",
"applicationCol",
",",
"applicationCloser",
":=",
"db",
"... | // EnsureApplicationDeviceConstraints ensures that there is a device
// constraints document for every application. | [
"EnsureApplicationDeviceConstraints",
"ensures",
"that",
"there",
"is",
"a",
"device",
"constraints",
"document",
"for",
"every",
"application",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L2043-L2088 |
5,174 | juju/juju | state/upgrades.go | RemoveInstanceCharmProfileDataCollection | 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 isMgoNamespaceNotFound(err) {
return nil
}
return errors.Annotate(err, "failed to drop instanceCharmProfileData collection")
}
return nil
} | go | 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 isMgoNamespaceNotFound(err) {
return nil
}
return errors.Annotate(err, "failed to drop instanceCharmProfileData collection")
}
return nil
} | [
"func",
"RemoveInstanceCharmProfileDataCollection",
"(",
"pool",
"*",
"StatePool",
")",
"error",
"{",
"db",
":=",
"pool",
".",
"SystemState",
"(",
")",
".",
"MongoSession",
"(",
")",
".",
"DB",
"(",
"jujuDB",
")",
"\n",
"instanceCharmProfileData",
":=",
"db",
... | // RemoveInstanceCharmProfileDataCollection removes the
// instanceCharmProfileData collection on upgrade. | [
"RemoveInstanceCharmProfileDataCollection",
"removes",
"the",
"instanceCharmProfileData",
"collection",
"on",
"upgrade",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/upgrades.go#L2092-L2103 |
5,175 | juju/juju | storage/provider/dummy/volumesource.go | CreateVolumes | 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 | 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")
} | [
"func",
"(",
"s",
"*",
"VolumeSource",
")",
"CreateVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"params",
"[",
"]",
"storage",
".",
"VolumeParams",
")",
"(",
"[",
"]",
"storage",
".",
"CreateVolumesResult",
",",
"error",
")",
"{",
"s",... | // CreateVolumes is defined on storage.VolumeSource. | [
"CreateVolumes",
"is",
"defined",
"on",
"storage",
".",
"VolumeSource",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/dummy/volumesource.go#L31-L37 |
5,176 | juju/juju | storage/provider/dummy/volumesource.go | ListVolumes | 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 | 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
} | [
"func",
"(",
"s",
"*",
"VolumeSource",
")",
"ListVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"s",
".",
"MethodCall",
"(",
"s",
",",
"\"",
"\"",
",",
"ctx",
")",
"\n",
"if",
"s",... | // ListVolumes is defined on storage.VolumeSource. | [
"ListVolumes",
"is",
"defined",
"on",
"storage",
".",
"VolumeSource",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/dummy/volumesource.go#L40-L46 |
5,177 | juju/juju | storage/provider/dummy/volumesource.go | DescribeVolumes | 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 | 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")
} | [
"func",
"(",
"s",
"*",
"VolumeSource",
")",
"DescribeVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"volIds",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"storage",
".",
"DescribeVolumesResult",
",",
"error",
")",
"{",
"s",
".",
"MethodCall"... | // DescribeVolumes is defined on storage.VolumeSource. | [
"DescribeVolumes",
"is",
"defined",
"on",
"storage",
".",
"VolumeSource",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/dummy/volumesource.go#L49-L55 |
5,178 | juju/juju | storage/provider/dummy/volumesource.go | DestroyVolumes | 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 | 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")
} | [
"func",
"(",
"s",
"*",
"VolumeSource",
")",
"DestroyVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"volIds",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"error",
",",
"error",
")",
"{",
"s",
".",
"MethodCall",
"(",
"s",
",",
"\"",
"\""... | // DestroyVolumes is defined on storage.VolumeSource. | [
"DestroyVolumes",
"is",
"defined",
"on",
"storage",
".",
"VolumeSource",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/dummy/volumesource.go#L58-L64 |
5,179 | juju/juju | storage/provider/dummy/volumesource.go | ReleaseVolumes | 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 | 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")
} | [
"func",
"(",
"s",
"*",
"VolumeSource",
")",
"ReleaseVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"volIds",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"error",
",",
"error",
")",
"{",
"s",
".",
"MethodCall",
"(",
"s",
",",
"\"",
"\""... | // ReleaseVolumes is defined on storage.VolumeSource. | [
"ReleaseVolumes",
"is",
"defined",
"on",
"storage",
".",
"VolumeSource",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/dummy/volumesource.go#L67-L73 |
5,180 | juju/juju | storage/provider/dummy/volumesource.go | ValidateVolumeParams | func (s *VolumeSource) ValidateVolumeParams(params storage.VolumeParams) error {
s.MethodCall(s, "ValidateVolumeParams", params)
if s.ValidateVolumeParamsFunc != nil {
return s.ValidateVolumeParamsFunc(params)
}
return nil
} | go | func (s *VolumeSource) ValidateVolumeParams(params storage.VolumeParams) error {
s.MethodCall(s, "ValidateVolumeParams", params)
if s.ValidateVolumeParamsFunc != nil {
return s.ValidateVolumeParamsFunc(params)
}
return nil
} | [
"func",
"(",
"s",
"*",
"VolumeSource",
")",
"ValidateVolumeParams",
"(",
"params",
"storage",
".",
"VolumeParams",
")",
"error",
"{",
"s",
".",
"MethodCall",
"(",
"s",
",",
"\"",
"\"",
",",
"params",
")",
"\n",
"if",
"s",
".",
"ValidateVolumeParamsFunc",
... | // ValidateVolumeParams is defined on storage.VolumeSource. | [
"ValidateVolumeParams",
"is",
"defined",
"on",
"storage",
".",
"VolumeSource",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/dummy/volumesource.go#L76-L82 |
5,181 | juju/juju | storage/provider/dummy/volumesource.go | AttachVolumes | 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("AttachVolumes")
} | go | 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("AttachVolumes")
} | [
"func",
"(",
"s",
"*",
"VolumeSource",
")",
"AttachVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"params",
"[",
"]",
"storage",
".",
"VolumeAttachmentParams",
")",
"(",
"[",
"]",
"storage",
".",
"AttachVolumesResult",
",",
"error",
")",
"... | // AttachVolumes is defined on storage.VolumeSource. | [
"AttachVolumes",
"is",
"defined",
"on",
"storage",
".",
"VolumeSource",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/dummy/volumesource.go#L85-L91 |
5,182 | juju/juju | storage/provider/dummy/volumesource.go | DetachVolumes | 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 | 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")
} | [
"func",
"(",
"s",
"*",
"VolumeSource",
")",
"DetachVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"params",
"[",
"]",
"storage",
".",
"VolumeAttachmentParams",
")",
"(",
"[",
"]",
"error",
",",
"error",
")",
"{",
"s",
".",
"MethodCall",
... | // DetachVolumes is defined on storage.VolumeSource. | [
"DetachVolumes",
"is",
"defined",
"on",
"storage",
".",
"VolumeSource",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/dummy/volumesource.go#L94-L100 |
5,183 | juju/juju | apiserver/common/watch.go | NewAgentEntityWatcher | func NewAgentEntityWatcher(st state.EntityFinder, resources facade.Resources, getCanWatch GetAuthFunc) *AgentEntityWatcher {
return &AgentEntityWatcher{
st: st,
resources: resources,
getCanWatch: getCanWatch,
}
} | go | func NewAgentEntityWatcher(st state.EntityFinder, resources facade.Resources, getCanWatch GetAuthFunc) *AgentEntityWatcher {
return &AgentEntityWatcher{
st: st,
resources: resources,
getCanWatch: getCanWatch,
}
} | [
"func",
"NewAgentEntityWatcher",
"(",
"st",
"state",
".",
"EntityFinder",
",",
"resources",
"facade",
".",
"Resources",
",",
"getCanWatch",
"GetAuthFunc",
")",
"*",
"AgentEntityWatcher",
"{",
"return",
"&",
"AgentEntityWatcher",
"{",
"st",
":",
"st",
",",
"resou... | // NewAgentEntityWatcher returns a new AgentEntityWatcher. The
// GetAuthFunc will be used on each invocation of Watch to determine
// current permissions. | [
"NewAgentEntityWatcher",
"returns",
"a",
"new",
"AgentEntityWatcher",
".",
"The",
"GetAuthFunc",
"will",
"be",
"used",
"on",
"each",
"invocation",
"of",
"Watch",
"to",
"determine",
"current",
"permissions",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/watch.go#L31-L37 |
5,184 | juju/juju | apiserver/common/watch.go | Watch | 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.NotifyWatchResults{}, errors.Trace(err)
}
for i, entity := range args.Entities {
tag, err := names.ParseTag(entity.Tag)
if err != nil {
result.Results[i].Error = ServerError(ErrPerm)
continue
}
err = ErrPerm
watcherId := ""
if canWatch(tag) {
watcherId, err = a.watchEntity(tag)
}
result.Results[i].NotifyWatcherId = watcherId
result.Results[i].Error = ServerError(err)
}
return result, nil
} | go | 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.NotifyWatchResults{}, errors.Trace(err)
}
for i, entity := range args.Entities {
tag, err := names.ParseTag(entity.Tag)
if err != nil {
result.Results[i].Error = ServerError(ErrPerm)
continue
}
err = ErrPerm
watcherId := ""
if canWatch(tag) {
watcherId, err = a.watchEntity(tag)
}
result.Results[i].NotifyWatcherId = watcherId
result.Results[i].Error = ServerError(err)
}
return result, nil
} | [
"func",
"(",
"a",
"*",
"AgentEntityWatcher",
")",
"Watch",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"NotifyWatchResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"NotifyWatchResults",
"{",
"Results",
":",
"make",
"(",... | // Watch starts an NotifyWatcher for each given entity. | [
"Watch",
"starts",
"an",
"NotifyWatcher",
"for",
"each",
"given",
"entity",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/watch.go#L60-L86 |
5,185 | juju/juju | cmd/juju/backups/backups.go | dumpMetadata | 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, "checksum: %q\n", result.Checksum)
fmt.Fprintf(ctx.Stdout, "checksum format: %q\n", result.ChecksumFormat)
fmt.Fprintf(ctx.Stdout, "size (B): %d\n", result.Size)
fmt.Fprintf(ctx.Stdout, "stored: %v\n", result.Stored)
fmt.Fprintf(ctx.Stdout, "started: %v\n", result.Started)
fmt.Fprintf(ctx.Stdout, "finished: %v\n", result.Finished)
fmt.Fprintf(ctx.Stdout, "notes: %q\n", result.Notes)
fmt.Fprintf(ctx.Stdout, "model ID: %q\n", result.Model)
fmt.Fprintf(ctx.Stdout, "machine ID: %q\n", result.Machine)
fmt.Fprintf(ctx.Stdout, "created on host: %q\n", result.Hostname)
fmt.Fprintf(ctx.Stdout, "juju version: %v\n", result.Version)
} | go | 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, "checksum: %q\n", result.Checksum)
fmt.Fprintf(ctx.Stdout, "checksum format: %q\n", result.ChecksumFormat)
fmt.Fprintf(ctx.Stdout, "size (B): %d\n", result.Size)
fmt.Fprintf(ctx.Stdout, "stored: %v\n", result.Stored)
fmt.Fprintf(ctx.Stdout, "started: %v\n", result.Started)
fmt.Fprintf(ctx.Stdout, "finished: %v\n", result.Finished)
fmt.Fprintf(ctx.Stdout, "notes: %q\n", result.Notes)
fmt.Fprintf(ctx.Stdout, "model ID: %q\n", result.Model)
fmt.Fprintf(ctx.Stdout, "machine ID: %q\n", result.Machine)
fmt.Fprintf(ctx.Stdout, "created on host: %q\n", result.Hostname)
fmt.Fprintf(ctx.Stdout, "juju version: %v\n", result.Version)
} | [
"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... | // dumpMetadata writes the formatted backup metadata to stdout. | [
"dumpMetadata",
"writes",
"the",
"formatted",
"backup",
"metadata",
"to",
"stdout",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/backups/backups.go#L102-L120 |
5,186 | juju/juju | provider/azure/environprovider.go | Validate | 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 cfg.GenerateSSHKey == nil {
return errors.NotValidf("nil GenerateSSHKey")
}
if cfg.ServicePrincipalCreator == nil {
return errors.NotValidf("nil ServicePrincipalCreator")
}
if cfg.AzureCLI == nil {
return errors.NotValidf("nil AzureCLI")
}
return nil
} | go | 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 cfg.GenerateSSHKey == nil {
return errors.NotValidf("nil GenerateSSHKey")
}
if cfg.ServicePrincipalCreator == nil {
return errors.NotValidf("nil ServicePrincipalCreator")
}
if cfg.AzureCLI == nil {
return errors.NotValidf("nil AzureCLI")
}
return nil
} | [
"func",
"(",
"cfg",
"ProviderConfig",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"cfg",
".",
"NewStorageClient",
"==",
"nil",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"RetryClock",
"==",
... | // Validate validates the Azure provider configuration. | [
"Validate",
"validates",
"the",
"Azure",
"provider",
"configuration",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/azure/environprovider.go#L71-L91 |
5,187 | juju/juju | provider/azure/environprovider.go | NewEnvironProvider | 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{
servicePrincipalCreator: config.ServicePrincipalCreator,
azureCLI: config.AzureCLI,
},
config: config,
}, nil
} | go | 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{
servicePrincipalCreator: config.ServicePrincipalCreator,
azureCLI: config.AzureCLI,
},
config: config,
}, nil
} | [
"func",
"NewEnvironProvider",
"(",
"config",
"ProviderConfig",
")",
"(",
"*",
"azureEnvironProvider",
",",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Anno... | // NewEnvironProvider returns a new EnvironProvider for Azure. | [
"NewEnvironProvider",
"returns",
"a",
"new",
"EnvironProvider",
"for",
"Azure",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/azure/environprovider.go#L100-L111 |
5,188 | juju/juju | api/common/leadership.go | NewLeadershipPinningAPI | func NewLeadershipPinningAPI(caller base.APICaller) *LeadershipPinningAPI {
facadeCaller := base.NewFacadeCaller(
caller,
leadershipFacade,
)
return NewLeadershipPinningAPIFromFacade(facadeCaller)
} | go | func NewLeadershipPinningAPI(caller base.APICaller) *LeadershipPinningAPI {
facadeCaller := base.NewFacadeCaller(
caller,
leadershipFacade,
)
return NewLeadershipPinningAPIFromFacade(facadeCaller)
} | [
"func",
"NewLeadershipPinningAPI",
"(",
"caller",
"base",
".",
"APICaller",
")",
"*",
"LeadershipPinningAPI",
"{",
"facadeCaller",
":=",
"base",
".",
"NewFacadeCaller",
"(",
"caller",
",",
"leadershipFacade",
",",
")",
"\n",
"return",
"NewLeadershipPinningAPIFromFacad... | // NewLeadershipPinningAPI creates and returns a new leadership API client. | [
"NewLeadershipPinningAPI",
"creates",
"and",
"returns",
"a",
"new",
"leadership",
"API",
"client",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/common/leadership.go#L23-L29 |
5,189 | juju/juju | api/common/leadership.go | PinnedLeadership | 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 app, entities := range callResult.Result {
entityTags := make([]names.Tag, len(entities))
for i, e := range entities {
tag, err := names.ParseTag(e)
if err != nil {
return nil, errors.Trace(err)
}
entityTags[i] = tag
}
pinned[app] = entityTags
}
return pinned, nil
} | go | 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 app, entities := range callResult.Result {
entityTags := make([]names.Tag, len(entities))
for i, e := range entities {
tag, err := names.ParseTag(e)
if err != nil {
return nil, errors.Trace(err)
}
entityTags[i] = tag
}
pinned[app] = entityTags
}
return pinned, nil
} | [
"func",
"(",
"a",
"*",
"LeadershipPinningAPI",
")",
"PinnedLeadership",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"names",
".",
"Tag",
",",
"error",
")",
"{",
"var",
"callResult",
"params",
".",
"PinnedLeadershipResult",
"\n",
"err",
":=",
"a",... | // PinnedLeadership returns a collection of application names for which
// leadership is currently pinned, with the entities requiring each
// application's pinned behaviour. | [
"PinnedLeadership",
"returns",
"a",
"collection",
"of",
"application",
"names",
"for",
"which",
"leadership",
"is",
"currently",
"pinned",
"with",
"the",
"entities",
"requiring",
"each",
"application",
"s",
"pinned",
"behaviour",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/common/leadership.go#L42-L63 |
5,190 | juju/juju | api/common/leadership.go | PinMachineApplications | func (a *LeadershipPinningAPI) PinMachineApplications() (map[string]error, error) {
res, err := a.pinMachineAppsOps("PinMachineApplications")
return res, errors.Trace(err)
} | go | func (a *LeadershipPinningAPI) PinMachineApplications() (map[string]error, error) {
res, err := a.pinMachineAppsOps("PinMachineApplications")
return res, errors.Trace(err)
} | [
"func",
"(",
"a",
"*",
"LeadershipPinningAPI",
")",
"PinMachineApplications",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"error",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"a",
".",
"pinMachineAppsOps",
"(",
"\"",
"\"",
")",
"\n",
"return",
"res"... | // PinMachineApplications pins leadership for applications represented by units
// running on the local machine.
// If the caller is not a machine agent, an error will be returned.
// The return is a collection of applications determined to be running on the
// machine, with the result of each individual pin operation. | [
"PinMachineApplications",
"pins",
"leadership",
"for",
"applications",
"represented",
"by",
"units",
"running",
"on",
"the",
"local",
"machine",
".",
"If",
"the",
"caller",
"is",
"not",
"a",
"machine",
"agent",
"an",
"error",
"will",
"be",
"returned",
".",
"Th... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/common/leadership.go#L70-L73 |
5,191 | juju/juju | api/common/leadership.go | pinMachineAppsOps | 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, len(callResults))
for _, res := range callResults {
var appErr error
if res.Error != nil {
appErr = res.Error
}
result[res.ApplicationName] = appErr
}
return result, nil
} | go | 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, len(callResults))
for _, res := range callResults {
var appErr error
if res.Error != nil {
appErr = res.Error
}
result[res.ApplicationName] = appErr
}
return result, nil
} | [
"func",
"(",
"a",
"*",
"LeadershipPinningAPI",
")",
"pinMachineAppsOps",
"(",
"callName",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"error",
",",
"error",
")",
"{",
"var",
"callResult",
"params",
".",
"PinApplicationsResults",
"\n",
"err",
":=",
"a",
... | // pinMachineAppsOps makes a facade call to the input method name and
// transforms the response into map. | [
"pinMachineAppsOps",
"makes",
"a",
"facade",
"call",
"to",
"the",
"input",
"method",
"name",
"and",
"transforms",
"the",
"response",
"into",
"map",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/common/leadership.go#L87-L104 |
5,192 | juju/juju | worker/uniter/resolver.go | NewUniterResolver | func NewUniterResolver(cfg ResolverConfig) resolver.Resolver {
return &uniterResolver{
config: cfg,
retryHookTimerStarted: false,
}
} | go | func NewUniterResolver(cfg ResolverConfig) resolver.Resolver {
return &uniterResolver{
config: cfg,
retryHookTimerStarted: false,
}
} | [
"func",
"NewUniterResolver",
"(",
"cfg",
"ResolverConfig",
")",
"resolver",
".",
"Resolver",
"{",
"return",
"&",
"uniterResolver",
"{",
"config",
":",
"cfg",
",",
"retryHookTimerStarted",
":",
"false",
",",
"}",
"\n",
"}"
] | // NewUniterResolver returns a new resolver.Resolver for the uniter. | [
"NewUniterResolver",
"returns",
"a",
"new",
"resolver",
".",
"Resolver",
"for",
"the",
"uniter",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/uniter/resolver.go#L40-L45 |
5,193 | juju/juju | worker/uniter/resolver.go | nextOpConflicted | 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)
}
return opFactory.NewResolvedUpgrade(localState.CharmURL)
}
if remoteState.ForceCharmUpgrade && charmModified(localState, remoteState) {
return opFactory.NewRevertUpgrade(remoteState.CharmURL)
}
return nil, resolver.ErrWaiting
} | go | 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)
}
return opFactory.NewResolvedUpgrade(localState.CharmURL)
}
if remoteState.ForceCharmUpgrade && charmModified(localState, remoteState) {
return opFactory.NewRevertUpgrade(remoteState.CharmURL)
}
return nil, resolver.ErrWaiting
} | [
"func",
"(",
"s",
"*",
"uniterResolver",
")",
"nextOpConflicted",
"(",
"localState",
"resolver",
".",
"LocalState",
",",
"remoteState",
"remotestate",
".",
"Snapshot",
",",
"opFactory",
"operation",
".",
"Factory",
",",
")",
"(",
"operation",
".",
"Operation",
... | // nextOpConflicted is called after an upgrade operation has failed, and hasn't
// yet been resolved or reverted. When in this mode, the resolver will only
// consider those two possibilities for progressing. | [
"nextOpConflicted",
"is",
"called",
"after",
"an",
"upgrade",
"operation",
"has",
"failed",
"and",
"hasn",
"t",
"yet",
"been",
"resolved",
"or",
"reverted",
".",
"When",
"in",
"this",
"mode",
"the",
"resolver",
"will",
"only",
"consider",
"those",
"two",
"po... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/uniter/resolver.go#L147-L162 |
5,194 | juju/juju | worker/uniter/resolver.go | NextOp | func (NopResolver) NextOp(resolver.LocalState, remotestate.Snapshot, operation.Factory) (operation.Operation, error) {
return nil, resolver.ErrNoOperation
} | go | func (NopResolver) NextOp(resolver.LocalState, remotestate.Snapshot, operation.Factory) (operation.Operation, error) {
return nil, resolver.ErrNoOperation
} | [
"func",
"(",
"NopResolver",
")",
"NextOp",
"(",
"resolver",
".",
"LocalState",
",",
"remotestate",
".",
"Snapshot",
",",
"operation",
".",
"Factory",
")",
"(",
"operation",
".",
"Operation",
",",
"error",
")",
"{",
"return",
"nil",
",",
"resolver",
".",
... | // The NopResolver's NextOp operation should always return the no operation error. | [
"The",
"NopResolver",
"s",
"NextOp",
"operation",
"should",
"always",
"return",
"the",
"no",
"operation",
"error",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/uniter/resolver.go#L311-L313 |
5,195 | juju/juju | worker/fortress/fortress.go | Lockdown | func (f *fortress) Lockdown(abort Abort) error {
return f.allowGuests(false, abort)
} | go | func (f *fortress) Lockdown(abort Abort) error {
return f.allowGuests(false, abort)
} | [
"func",
"(",
"f",
"*",
"fortress",
")",
"Lockdown",
"(",
"abort",
"Abort",
")",
"error",
"{",
"return",
"f",
".",
"allowGuests",
"(",
"false",
",",
"abort",
")",
"\n",
"}"
] | // Lockdown is part of the Guard interface. | [
"Lockdown",
"is",
"part",
"of",
"the",
"Guard",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/fortress/fortress.go#L47-L49 |
5,196 | juju/juju | worker/fortress/fortress.go | Visit | 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 | 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
}
} | [
"func",
"(",
"f",
"*",
"fortress",
")",
"Visit",
"(",
"visit",
"Visit",
",",
"abort",
"Abort",
")",
"error",
"{",
"result",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"select",
"{",
"case",
"<-",
"f",
".",
"tomb",
".",
"Dying",
"(",
")",
":",... | // Visit is part of the Guest interface. | [
"Visit",
"is",
"part",
"of",
"the",
"Guest",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/fortress/fortress.go#L52-L62 |
5,197 | juju/juju | worker/fortress/fortress.go | allowGuests | 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 | 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
}
} | [
"func",
"(",
"f",
"*",
"fortress",
")",
"allowGuests",
"(",
"allowGuests",
"bool",
",",
"abort",
"Abort",
")",
"error",
"{",
"result",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"select",
"{",
"case",
"<-",
"f",
".",
"tomb",
".",
"Dying",
"(",
... | // allowGuests communicates Guard-interface requests to the main loop. | [
"allowGuests",
"communicates",
"Guard",
"-",
"interface",
"requests",
"to",
"the",
"main",
"loop",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/fortress/fortress.go#L65-L73 |
5,198 | juju/juju | worker/fortress/fortress.go | loop | 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 ticket.complete(active.Done)
case ticket := <-f.guardTickets:
// guard ticket requests are idempotent; it's not worth building
// the extra mechanism needed to (1) complain about abuse but
// (2) remain comprehensible and functional in the face of aborted
// Lockdowns.
if ticket.allowGuests {
guestTickets = f.guestTickets
} else {
guestTickets = nil
}
go ticket.complete(active.Wait)
}
}
} | go | 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 ticket.complete(active.Done)
case ticket := <-f.guardTickets:
// guard ticket requests are idempotent; it's not worth building
// the extra mechanism needed to (1) complain about abuse but
// (2) remain comprehensible and functional in the face of aborted
// Lockdowns.
if ticket.allowGuests {
guestTickets = f.guestTickets
} else {
guestTickets = nil
}
go ticket.complete(active.Wait)
}
}
} | [
"func",
"(",
"f",
"*",
"fortress",
")",
"loop",
"(",
")",
"error",
"{",
"var",
"active",
"sync",
".",
"WaitGroup",
"\n",
"defer",
"active",
".",
"Wait",
"(",
")",
"\n\n",
"// guestTickets will be set on Unlock and cleared at the start of Lockdown.",
"var",
"guestT... | // loop waits for a Guard to unlock the fortress, and then runs visit funcs in
// parallel until a Guard locks it down again; at which point, it waits for all
// outstanding visits to complete, and reverts to its original state. | [
"loop",
"waits",
"for",
"a",
"Guard",
"to",
"unlock",
"the",
"fortress",
"and",
"then",
"runs",
"visit",
"funcs",
"in",
"parallel",
"until",
"a",
"Guard",
"locks",
"it",
"down",
"again",
";",
"at",
"which",
"point",
"it",
"waits",
"for",
"all",
"outstand... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/fortress/fortress.go#L78-L104 |
5,199 | juju/juju | container/lxd/certificate.go | GenerateClientCertificate | func GenerateClientCertificate() (*Certificate, error) {
cert, key, err := shared.GenerateMemCert(true)
if err != nil {
return nil, errors.Trace(err)
}
return NewCertificate(cert, key), nil
} | go | func GenerateClientCertificate() (*Certificate, error) {
cert, key, err := shared.GenerateMemCert(true)
if err != nil {
return nil, errors.Trace(err)
}
return NewCertificate(cert, key), nil
} | [
"func",
"GenerateClientCertificate",
"(",
")",
"(",
"*",
"Certificate",
",",
"error",
")",
"{",
"cert",
",",
"key",
",",
"err",
":=",
"shared",
".",
"GenerateMemCert",
"(",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors... | // GenerateClientCertificate creates and returns a new certificate for client
// communication with an LXD server. | [
"GenerateClientCertificate",
"creates",
"and",
"returns",
"a",
"new",
"certificate",
"for",
"client",
"communication",
"with",
"an",
"LXD",
"server",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/certificate.go#L32-L38 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.