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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
154,300 |
juju/juju
|
provider/gce/google/conn.go
|
AvailabilityZones
|
func (gc *Connection) AvailabilityZones(region string) ([]AvailabilityZone, error) {
rawZones, err := gc.raw.ListAvailabilityZones(gc.projectID, region)
if err != nil {
return nil, errors.Trace(err)
}
var zones []AvailabilityZone
for _, rawZone := range rawZones {
zones = append(zones, AvailabilityZone{rawZone})
}
return zones, nil
}
|
go
|
func (gc *Connection) AvailabilityZones(region string) ([]AvailabilityZone, error) {
rawZones, err := gc.raw.ListAvailabilityZones(gc.projectID, region)
if err != nil {
return nil, errors.Trace(err)
}
var zones []AvailabilityZone
for _, rawZone := range rawZones {
zones = append(zones, AvailabilityZone{rawZone})
}
return zones, nil
}
|
[
"func",
"(",
"gc",
"*",
"Connection",
")",
"AvailabilityZones",
"(",
"region",
"string",
")",
"(",
"[",
"]",
"AvailabilityZone",
",",
"error",
")",
"{",
"rawZones",
",",
"err",
":=",
"gc",
".",
"raw",
".",
"ListAvailabilityZones",
"(",
"gc",
".",
"projectID",
",",
"region",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"zones",
"[",
"]",
"AvailabilityZone",
"\n",
"for",
"_",
",",
"rawZone",
":=",
"range",
"rawZones",
"{",
"zones",
"=",
"append",
"(",
"zones",
",",
"AvailabilityZone",
"{",
"rawZone",
"}",
")",
"\n",
"}",
"\n",
"return",
"zones",
",",
"nil",
"\n",
"}"
] |
// AvailabilityZones returns the list of availability zones for a given
// GCE region. If none are found the the list is empty. Any failure in
// the low-level request is returned as an error.
|
[
"AvailabilityZones",
"returns",
"the",
"list",
"of",
"availability",
"zones",
"for",
"a",
"given",
"GCE",
"region",
".",
"If",
"none",
"are",
"found",
"the",
"the",
"list",
"is",
"empty",
".",
"Any",
"failure",
"in",
"the",
"low",
"-",
"level",
"request",
"is",
"returned",
"as",
"an",
"error",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/gce/google/conn.go#L164-L175
|
154,301 |
juju/juju
|
worker/common/charmrunner/logger.go
|
NewHookLogger
|
func NewHookLogger(logger loggo.Logger, outReader io.ReadCloser) *HookLogger {
return &HookLogger{
r: outReader,
done: make(chan struct{}),
logger: logger,
}
}
|
go
|
func NewHookLogger(logger loggo.Logger, outReader io.ReadCloser) *HookLogger {
return &HookLogger{
r: outReader,
done: make(chan struct{}),
logger: logger,
}
}
|
[
"func",
"NewHookLogger",
"(",
"logger",
"loggo",
".",
"Logger",
",",
"outReader",
"io",
".",
"ReadCloser",
")",
"*",
"HookLogger",
"{",
"return",
"&",
"HookLogger",
"{",
"r",
":",
"outReader",
",",
"done",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"logger",
":",
"logger",
",",
"}",
"\n",
"}"
] |
// NewHookLogger creates a new hook logger.
|
[
"NewHookLogger",
"creates",
"a",
"new",
"hook",
"logger",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/common/charmrunner/logger.go#L18-L24
|
154,302 |
juju/juju
|
worker/common/charmrunner/logger.go
|
Run
|
func (l *HookLogger) Run() {
defer close(l.done)
defer l.r.Close()
br := bufio.NewReaderSize(l.r, 4096)
for {
line, _, err := br.ReadLine()
if err != nil {
if err != io.EOF {
logger.Errorf("cannot read hook output: %v", err)
}
break
}
l.mu.Lock()
if l.stopped {
l.mu.Unlock()
return
}
l.logger.Debugf("%s", line)
l.mu.Unlock()
}
}
|
go
|
func (l *HookLogger) Run() {
defer close(l.done)
defer l.r.Close()
br := bufio.NewReaderSize(l.r, 4096)
for {
line, _, err := br.ReadLine()
if err != nil {
if err != io.EOF {
logger.Errorf("cannot read hook output: %v", err)
}
break
}
l.mu.Lock()
if l.stopped {
l.mu.Unlock()
return
}
l.logger.Debugf("%s", line)
l.mu.Unlock()
}
}
|
[
"func",
"(",
"l",
"*",
"HookLogger",
")",
"Run",
"(",
")",
"{",
"defer",
"close",
"(",
"l",
".",
"done",
")",
"\n",
"defer",
"l",
".",
"r",
".",
"Close",
"(",
")",
"\n",
"br",
":=",
"bufio",
".",
"NewReaderSize",
"(",
"l",
".",
"r",
",",
"4096",
")",
"\n",
"for",
"{",
"line",
",",
"_",
",",
"err",
":=",
"br",
".",
"ReadLine",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"!=",
"io",
".",
"EOF",
"{",
"logger",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"l",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"l",
".",
"stopped",
"{",
"l",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"line",
")",
"\n",
"l",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// Run starts the hook logger.
|
[
"Run",
"starts",
"the",
"hook",
"logger",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/common/charmrunner/logger.go#L36-L56
|
154,303 |
juju/juju
|
worker/common/charmrunner/logger.go
|
Stop
|
func (l *HookLogger) Stop() {
// We can see the process exit before the logger has processed
// all its output, so allow a moment for the data buffered
// in the pipe to be processed. We don't wait indefinitely though,
// because the hook may have started a background process
// that keeps the pipe open.
select {
case <-l.done:
case <-time.After(100 * time.Millisecond):
}
// We can't close the pipe asynchronously, so just
// stifle output instead.
l.mu.Lock()
l.stopped = true
l.mu.Unlock()
}
|
go
|
func (l *HookLogger) Stop() {
// We can see the process exit before the logger has processed
// all its output, so allow a moment for the data buffered
// in the pipe to be processed. We don't wait indefinitely though,
// because the hook may have started a background process
// that keeps the pipe open.
select {
case <-l.done:
case <-time.After(100 * time.Millisecond):
}
// We can't close the pipe asynchronously, so just
// stifle output instead.
l.mu.Lock()
l.stopped = true
l.mu.Unlock()
}
|
[
"func",
"(",
"l",
"*",
"HookLogger",
")",
"Stop",
"(",
")",
"{",
"// We can see the process exit before the logger has processed",
"// all its output, so allow a moment for the data buffered",
"// in the pipe to be processed. We don't wait indefinitely though,",
"// because the hook may have started a background process",
"// that keeps the pipe open.",
"select",
"{",
"case",
"<-",
"l",
".",
"done",
":",
"case",
"<-",
"time",
".",
"After",
"(",
"100",
"*",
"time",
".",
"Millisecond",
")",
":",
"}",
"\n",
"// We can't close the pipe asynchronously, so just",
"// stifle output instead.",
"l",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"l",
".",
"stopped",
"=",
"true",
"\n",
"l",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// Stop stops the hook logger.
|
[
"Stop",
"stops",
"the",
"hook",
"logger",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/common/charmrunner/logger.go#L59-L74
|
154,304 |
juju/juju
|
core/life/life.go
|
Validate
|
func (v Value) Validate() error {
switch v {
case Alive, Dying, Dead:
return nil
}
return errors.NotValidf("life value %q", v)
}
|
go
|
func (v Value) Validate() error {
switch v {
case Alive, Dying, Dead:
return nil
}
return errors.NotValidf("life value %q", v)
}
|
[
"func",
"(",
"v",
"Value",
")",
"Validate",
"(",
")",
"error",
"{",
"switch",
"v",
"{",
"case",
"Alive",
",",
"Dying",
",",
"Dead",
":",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
",",
"v",
")",
"\n",
"}"
] |
// Validate returns an error if the value is not known.
|
[
"Validate",
"returns",
"an",
"error",
"if",
"the",
"value",
"is",
"not",
"known",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/life/life.go#L26-L32
|
154,305 |
juju/juju
|
cmd/juju/application/suspendrelation.go
|
NewSuspendRelationCommand
|
func NewSuspendRelationCommand() cmd.Command {
cmd := &suspendRelationCommand{}
cmd.newAPIFunc = func() (SetRelationSuspendedAPI, error) {
root, err := cmd.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return application.NewClient(root), nil
}
return modelcmd.Wrap(cmd)
}
|
go
|
func NewSuspendRelationCommand() cmd.Command {
cmd := &suspendRelationCommand{}
cmd.newAPIFunc = func() (SetRelationSuspendedAPI, error) {
root, err := cmd.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return application.NewClient(root), nil
}
return modelcmd.Wrap(cmd)
}
|
[
"func",
"NewSuspendRelationCommand",
"(",
")",
"cmd",
".",
"Command",
"{",
"cmd",
":=",
"&",
"suspendRelationCommand",
"{",
"}",
"\n",
"cmd",
".",
"newAPIFunc",
"=",
"func",
"(",
")",
"(",
"SetRelationSuspendedAPI",
",",
"error",
")",
"{",
"root",
",",
"err",
":=",
"cmd",
".",
"NewAPIRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"application",
".",
"NewClient",
"(",
"root",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"modelcmd",
".",
"Wrap",
"(",
"cmd",
")",
"\n",
"}"
] |
// NewSuspendRelationCommand returns a command to suspend a relation.
|
[
"NewSuspendRelationCommand",
"returns",
"a",
"command",
"to",
"suspend",
"a",
"relation",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/application/suspendrelation.go#L40-L50
|
154,306 |
juju/juju
|
api/machiner/machine.go
|
Refresh
|
func (m *Machine) Refresh() error {
life, err := m.st.machineLife(m.tag)
if err != nil {
return err
}
m.life = life
return nil
}
|
go
|
func (m *Machine) Refresh() error {
life, err := m.st.machineLife(m.tag)
if err != nil {
return err
}
m.life = life
return nil
}
|
[
"func",
"(",
"m",
"*",
"Machine",
")",
"Refresh",
"(",
")",
"error",
"{",
"life",
",",
"err",
":=",
"m",
".",
"st",
".",
"machineLife",
"(",
"m",
".",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"m",
".",
"life",
"=",
"life",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Refresh updates the cached local copy of the machine's data.
|
[
"Refresh",
"updates",
"the",
"cached",
"local",
"copy",
"of",
"the",
"machine",
"s",
"data",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/machiner/machine.go#L35-L42
|
154,307 |
juju/juju
|
api/machiner/machine.go
|
SetMachineAddresses
|
func (m *Machine) SetMachineAddresses(addresses []network.Address) error {
var result params.ErrorResults
args := params.SetMachinesAddresses{
MachineAddresses: []params.MachineAddresses{
{Tag: m.Tag().String(), Addresses: params.FromNetworkAddresses(addresses...)},
},
}
err := m.st.facade.FacadeCall("SetMachineAddresses", args, &result)
if err != nil {
return err
}
return result.OneError()
}
|
go
|
func (m *Machine) SetMachineAddresses(addresses []network.Address) error {
var result params.ErrorResults
args := params.SetMachinesAddresses{
MachineAddresses: []params.MachineAddresses{
{Tag: m.Tag().String(), Addresses: params.FromNetworkAddresses(addresses...)},
},
}
err := m.st.facade.FacadeCall("SetMachineAddresses", args, &result)
if err != nil {
return err
}
return result.OneError()
}
|
[
"func",
"(",
"m",
"*",
"Machine",
")",
"SetMachineAddresses",
"(",
"addresses",
"[",
"]",
"network",
".",
"Address",
")",
"error",
"{",
"var",
"result",
"params",
".",
"ErrorResults",
"\n",
"args",
":=",
"params",
".",
"SetMachinesAddresses",
"{",
"MachineAddresses",
":",
"[",
"]",
"params",
".",
"MachineAddresses",
"{",
"{",
"Tag",
":",
"m",
".",
"Tag",
"(",
")",
".",
"String",
"(",
")",
",",
"Addresses",
":",
"params",
".",
"FromNetworkAddresses",
"(",
"addresses",
"...",
")",
"}",
",",
"}",
",",
"}",
"\n",
"err",
":=",
"m",
".",
"st",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"args",
",",
"&",
"result",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"result",
".",
"OneError",
"(",
")",
"\n",
"}"
] |
// SetMachineAddresses sets the machine determined addresses of the machine.
|
[
"SetMachineAddresses",
"sets",
"the",
"machine",
"determined",
"addresses",
"of",
"the",
"machine",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/machiner/machine.go#L60-L72
|
154,308 |
juju/juju
|
api/machiner/machine.go
|
Watch
|
func (m *Machine) Watch() (watcher.NotifyWatcher, error) {
return common.Watch(m.st.facade, "Watch", m.tag)
}
|
go
|
func (m *Machine) Watch() (watcher.NotifyWatcher, error) {
return common.Watch(m.st.facade, "Watch", m.tag)
}
|
[
"func",
"(",
"m",
"*",
"Machine",
")",
"Watch",
"(",
")",
"(",
"watcher",
".",
"NotifyWatcher",
",",
"error",
")",
"{",
"return",
"common",
".",
"Watch",
"(",
"m",
".",
"st",
".",
"facade",
",",
"\"",
"\"",
",",
"m",
".",
"tag",
")",
"\n",
"}"
] |
// Watch returns a watcher for observing changes to the machine.
|
[
"Watch",
"returns",
"a",
"watcher",
"for",
"observing",
"changes",
"to",
"the",
"machine",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/machiner/machine.go#L89-L91
|
154,309 |
juju/juju
|
api/machiner/machine.go
|
Jobs
|
func (m *Machine) Jobs() (*params.JobsResult, error) {
var results params.JobsResults
args := params.Entities{
Entities: []params.Entity{{Tag: m.Tag().String()}},
}
err := m.st.facade.FacadeCall("Jobs", args, &results)
if err != nil {
return nil, errors.Annotate(err, "error from FacadeCall")
}
if len(results.Results) != 1 {
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
return &result, nil
}
|
go
|
func (m *Machine) Jobs() (*params.JobsResult, error) {
var results params.JobsResults
args := params.Entities{
Entities: []params.Entity{{Tag: m.Tag().String()}},
}
err := m.st.facade.FacadeCall("Jobs", args, &results)
if err != nil {
return nil, errors.Annotate(err, "error from FacadeCall")
}
if len(results.Results) != 1 {
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
return &result, nil
}
|
[
"func",
"(",
"m",
"*",
"Machine",
")",
"Jobs",
"(",
")",
"(",
"*",
"params",
".",
"JobsResult",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"JobsResults",
"\n",
"args",
":=",
"params",
".",
"Entities",
"{",
"Entities",
":",
"[",
"]",
"params",
".",
"Entity",
"{",
"{",
"Tag",
":",
"m",
".",
"Tag",
"(",
")",
".",
"String",
"(",
")",
"}",
"}",
",",
"}",
"\n",
"err",
":=",
"m",
".",
"st",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"args",
",",
"&",
"results",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"results",
".",
"Results",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"len",
"(",
"results",
".",
"Results",
")",
")",
"\n",
"}",
"\n",
"result",
":=",
"results",
".",
"Results",
"[",
"0",
"]",
"\n",
"if",
"result",
".",
"Error",
"!=",
"nil",
"{",
"return",
"nil",
",",
"result",
".",
"Error",
"\n",
"}",
"\n",
"return",
"&",
"result",
",",
"nil",
"\n",
"}"
] |
// Jobs returns a list of jobs for the machine.
|
[
"Jobs",
"returns",
"a",
"list",
"of",
"jobs",
"for",
"the",
"machine",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/machiner/machine.go#L94-L111
|
154,310 |
juju/juju
|
api/machiner/machine.go
|
SetObservedNetworkConfig
|
func (m *Machine) SetObservedNetworkConfig(netConfig []params.NetworkConfig) error {
args := params.SetMachineNetworkConfig{
Tag: m.Tag().String(),
Config: netConfig,
}
err := m.st.facade.FacadeCall("SetObservedNetworkConfig", args, nil)
if err != nil {
return errors.Trace(err)
}
return nil
}
|
go
|
func (m *Machine) SetObservedNetworkConfig(netConfig []params.NetworkConfig) error {
args := params.SetMachineNetworkConfig{
Tag: m.Tag().String(),
Config: netConfig,
}
err := m.st.facade.FacadeCall("SetObservedNetworkConfig", args, nil)
if err != nil {
return errors.Trace(err)
}
return nil
}
|
[
"func",
"(",
"m",
"*",
"Machine",
")",
"SetObservedNetworkConfig",
"(",
"netConfig",
"[",
"]",
"params",
".",
"NetworkConfig",
")",
"error",
"{",
"args",
":=",
"params",
".",
"SetMachineNetworkConfig",
"{",
"Tag",
":",
"m",
".",
"Tag",
"(",
")",
".",
"String",
"(",
")",
",",
"Config",
":",
"netConfig",
",",
"}",
"\n",
"err",
":=",
"m",
".",
"st",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"args",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SetObservedNetworkConfig sets the machine network config as observed on the
// machine.
|
[
"SetObservedNetworkConfig",
"sets",
"the",
"machine",
"network",
"config",
"as",
"observed",
"on",
"the",
"machine",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/machiner/machine.go#L115-L125
|
154,311 |
juju/juju
|
environs/cloudspec.go
|
Validate
|
func (cs CloudSpec) Validate() error {
if cs.Type == "" {
return errors.NotValidf("empty Type")
}
if !names.IsValidCloud(cs.Name) {
return errors.NotValidf("cloud name %q", cs.Name)
}
return nil
}
|
go
|
func (cs CloudSpec) Validate() error {
if cs.Type == "" {
return errors.NotValidf("empty Type")
}
if !names.IsValidCloud(cs.Name) {
return errors.NotValidf("cloud name %q", cs.Name)
}
return nil
}
|
[
"func",
"(",
"cs",
"CloudSpec",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"cs",
".",
"Type",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"names",
".",
"IsValidCloud",
"(",
"cs",
".",
"Name",
")",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
",",
"cs",
".",
"Name",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Validate validates that the CloudSpec is well-formed. It does
// not ensure that the cloud type and credentials are valid.
|
[
"Validate",
"validates",
"that",
"the",
"CloudSpec",
"is",
"well",
"-",
"formed",
".",
"It",
"does",
"not",
"ensure",
"that",
"the",
"cloud",
"type",
"and",
"credentials",
"are",
"valid",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/cloudspec.go#L49-L57
|
154,312 |
juju/juju
|
environs/cloudspec.go
|
MakeCloudSpec
|
func MakeCloudSpec(cloud jujucloud.Cloud, cloudRegionName string, credential *jujucloud.Credential) (CloudSpec, error) {
cloudSpec := CloudSpec{
Type: cloud.Type,
Name: cloud.Name,
Region: cloudRegionName,
Endpoint: cloud.Endpoint,
IdentityEndpoint: cloud.IdentityEndpoint,
StorageEndpoint: cloud.StorageEndpoint,
CACertificates: cloud.CACertificates,
Credential: credential,
}
if cloudRegionName != "" {
cloudRegion, err := jujucloud.RegionByName(cloud.Regions, cloudRegionName)
if err != nil {
return CloudSpec{}, errors.Annotate(err, "getting cloud region definition")
}
cloudSpec.Endpoint = cloudRegion.Endpoint
cloudSpec.IdentityEndpoint = cloudRegion.IdentityEndpoint
cloudSpec.StorageEndpoint = cloudRegion.StorageEndpoint
}
return cloudSpec, nil
}
|
go
|
func MakeCloudSpec(cloud jujucloud.Cloud, cloudRegionName string, credential *jujucloud.Credential) (CloudSpec, error) {
cloudSpec := CloudSpec{
Type: cloud.Type,
Name: cloud.Name,
Region: cloudRegionName,
Endpoint: cloud.Endpoint,
IdentityEndpoint: cloud.IdentityEndpoint,
StorageEndpoint: cloud.StorageEndpoint,
CACertificates: cloud.CACertificates,
Credential: credential,
}
if cloudRegionName != "" {
cloudRegion, err := jujucloud.RegionByName(cloud.Regions, cloudRegionName)
if err != nil {
return CloudSpec{}, errors.Annotate(err, "getting cloud region definition")
}
cloudSpec.Endpoint = cloudRegion.Endpoint
cloudSpec.IdentityEndpoint = cloudRegion.IdentityEndpoint
cloudSpec.StorageEndpoint = cloudRegion.StorageEndpoint
}
return cloudSpec, nil
}
|
[
"func",
"MakeCloudSpec",
"(",
"cloud",
"jujucloud",
".",
"Cloud",
",",
"cloudRegionName",
"string",
",",
"credential",
"*",
"jujucloud",
".",
"Credential",
")",
"(",
"CloudSpec",
",",
"error",
")",
"{",
"cloudSpec",
":=",
"CloudSpec",
"{",
"Type",
":",
"cloud",
".",
"Type",
",",
"Name",
":",
"cloud",
".",
"Name",
",",
"Region",
":",
"cloudRegionName",
",",
"Endpoint",
":",
"cloud",
".",
"Endpoint",
",",
"IdentityEndpoint",
":",
"cloud",
".",
"IdentityEndpoint",
",",
"StorageEndpoint",
":",
"cloud",
".",
"StorageEndpoint",
",",
"CACertificates",
":",
"cloud",
".",
"CACertificates",
",",
"Credential",
":",
"credential",
",",
"}",
"\n",
"if",
"cloudRegionName",
"!=",
"\"",
"\"",
"{",
"cloudRegion",
",",
"err",
":=",
"jujucloud",
".",
"RegionByName",
"(",
"cloud",
".",
"Regions",
",",
"cloudRegionName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"CloudSpec",
"{",
"}",
",",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"cloudSpec",
".",
"Endpoint",
"=",
"cloudRegion",
".",
"Endpoint",
"\n",
"cloudSpec",
".",
"IdentityEndpoint",
"=",
"cloudRegion",
".",
"IdentityEndpoint",
"\n",
"cloudSpec",
".",
"StorageEndpoint",
"=",
"cloudRegion",
".",
"StorageEndpoint",
"\n",
"}",
"\n",
"return",
"cloudSpec",
",",
"nil",
"\n",
"}"
] |
// MakeCloudSpec returns a CloudSpec from the given
// Cloud, cloud and region names, and credential.
|
[
"MakeCloudSpec",
"returns",
"a",
"CloudSpec",
"from",
"the",
"given",
"Cloud",
"cloud",
"and",
"region",
"names",
"and",
"credential",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/cloudspec.go#L61-L82
|
154,313 |
juju/juju
|
environs/cloudspec.go
|
NewCloudRegionSpec
|
func NewCloudRegionSpec(cloud, region string) (*CloudRegionSpec, error) {
if cloud == "" {
return nil, errors.New("cloud is required to be non empty")
}
return &CloudRegionSpec{Cloud: cloud, Region: region}, nil
}
|
go
|
func NewCloudRegionSpec(cloud, region string) (*CloudRegionSpec, error) {
if cloud == "" {
return nil, errors.New("cloud is required to be non empty")
}
return &CloudRegionSpec{Cloud: cloud, Region: region}, nil
}
|
[
"func",
"NewCloudRegionSpec",
"(",
"cloud",
",",
"region",
"string",
")",
"(",
"*",
"CloudRegionSpec",
",",
"error",
")",
"{",
"if",
"cloud",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"CloudRegionSpec",
"{",
"Cloud",
":",
"cloud",
",",
"Region",
":",
"region",
"}",
",",
"nil",
"\n",
"}"
] |
// NewCloudRegionSpec returns a CloudRegionSpec ensuring cloud arg is not empty.
|
[
"NewCloudRegionSpec",
"returns",
"a",
"CloudRegionSpec",
"ensuring",
"cloud",
"arg",
"is",
"not",
"empty",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/cloudspec.go#L96-L101
|
154,314 |
juju/juju
|
logfwd/syslog/config.go
|
Validate
|
func (cfg RawConfig) Validate() error {
if err := cfg.validateHost(); err != nil {
return errors.Trace(err)
}
if cfg.Enabled || cfg.ClientKey != "" || cfg.ClientCert != "" || cfg.CACert != "" {
if _, err := cfg.tlsConfig(); err != nil {
return errors.Annotate(err, "validating TLS config")
}
}
return nil
}
|
go
|
func (cfg RawConfig) Validate() error {
if err := cfg.validateHost(); err != nil {
return errors.Trace(err)
}
if cfg.Enabled || cfg.ClientKey != "" || cfg.ClientCert != "" || cfg.CACert != "" {
if _, err := cfg.tlsConfig(); err != nil {
return errors.Annotate(err, "validating TLS config")
}
}
return nil
}
|
[
"func",
"(",
"cfg",
"RawConfig",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"cfg",
".",
"validateHost",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"cfg",
".",
"Enabled",
"||",
"cfg",
".",
"ClientKey",
"!=",
"\"",
"\"",
"||",
"cfg",
".",
"ClientCert",
"!=",
"\"",
"\"",
"||",
"cfg",
".",
"CACert",
"!=",
"\"",
"\"",
"{",
"if",
"_",
",",
"err",
":=",
"cfg",
".",
"tlsConfig",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Validate ensures that the config is currently valid.
|
[
"Validate",
"ensures",
"that",
"the",
"config",
"is",
"currently",
"valid",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/logfwd/syslog/config.go#L43-L54
|
154,315 |
juju/juju
|
caas/kubernetes/provider/precheck.go
|
PrecheckInstance
|
func (k *kubernetesClient) PrecheckInstance(ctx context.ProviderCallContext, params environs.PrecheckInstanceParams) error {
// Ensure there are no unsupported constraints.
// Clouds generally don't enforce this but we will
// for Kubernetes deployments.
validator, err := k.ConstraintsValidator(ctx)
if err != nil {
return errors.Trace(err)
}
unsupported, err := validator.Validate(params.Constraints)
if err != nil {
return errors.NotValidf("constraints %q", params.Constraints.String())
}
if len(unsupported) > 0 {
return errors.NotSupportedf("constraints %v", strings.Join(unsupported, ","))
}
if params.Series != k8sSeries {
return errors.NotValidf("series %q", params.Series)
}
if params.Placement != "" {
return errors.NotValidf("placement directive %q", params.Placement)
}
if params.Constraints.Tags == nil {
return nil
}
affinityLabels := *params.Constraints.Tags
labelsString := strings.Join(affinityLabels, ",")
for _, labelPair := range affinityLabels {
parts := strings.Split(labelPair, "=")
if len(parts) != 2 {
return errors.Errorf("invalid node affinity constraints: %v", labelsString)
}
key := strings.Trim(parts[0], " ")
if strings.HasPrefix(key, "^") {
if len(key) == 1 {
return errors.Errorf("invalid node affinity constraints: %v", labelsString)
}
}
}
return nil
}
|
go
|
func (k *kubernetesClient) PrecheckInstance(ctx context.ProviderCallContext, params environs.PrecheckInstanceParams) error {
// Ensure there are no unsupported constraints.
// Clouds generally don't enforce this but we will
// for Kubernetes deployments.
validator, err := k.ConstraintsValidator(ctx)
if err != nil {
return errors.Trace(err)
}
unsupported, err := validator.Validate(params.Constraints)
if err != nil {
return errors.NotValidf("constraints %q", params.Constraints.String())
}
if len(unsupported) > 0 {
return errors.NotSupportedf("constraints %v", strings.Join(unsupported, ","))
}
if params.Series != k8sSeries {
return errors.NotValidf("series %q", params.Series)
}
if params.Placement != "" {
return errors.NotValidf("placement directive %q", params.Placement)
}
if params.Constraints.Tags == nil {
return nil
}
affinityLabels := *params.Constraints.Tags
labelsString := strings.Join(affinityLabels, ",")
for _, labelPair := range affinityLabels {
parts := strings.Split(labelPair, "=")
if len(parts) != 2 {
return errors.Errorf("invalid node affinity constraints: %v", labelsString)
}
key := strings.Trim(parts[0], " ")
if strings.HasPrefix(key, "^") {
if len(key) == 1 {
return errors.Errorf("invalid node affinity constraints: %v", labelsString)
}
}
}
return nil
}
|
[
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"PrecheckInstance",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"params",
"environs",
".",
"PrecheckInstanceParams",
")",
"error",
"{",
"// Ensure there are no unsupported constraints.",
"// Clouds generally don't enforce this but we will",
"// for Kubernetes deployments.",
"validator",
",",
"err",
":=",
"k",
".",
"ConstraintsValidator",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"unsupported",
",",
"err",
":=",
"validator",
".",
"Validate",
"(",
"params",
".",
"Constraints",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
",",
"params",
".",
"Constraints",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"unsupported",
")",
">",
"0",
"{",
"return",
"errors",
".",
"NotSupportedf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"unsupported",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n\n",
"if",
"params",
".",
"Series",
"!=",
"k8sSeries",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
",",
"params",
".",
"Series",
")",
"\n",
"}",
"\n\n",
"if",
"params",
".",
"Placement",
"!=",
"\"",
"\"",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
",",
"params",
".",
"Placement",
")",
"\n",
"}",
"\n",
"if",
"params",
".",
"Constraints",
".",
"Tags",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"affinityLabels",
":=",
"*",
"params",
".",
"Constraints",
".",
"Tags",
"\n",
"labelsString",
":=",
"strings",
".",
"Join",
"(",
"affinityLabels",
",",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"labelPair",
":=",
"range",
"affinityLabels",
"{",
"parts",
":=",
"strings",
".",
"Split",
"(",
"labelPair",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"labelsString",
")",
"\n",
"}",
"\n",
"key",
":=",
"strings",
".",
"Trim",
"(",
"parts",
"[",
"0",
"]",
",",
"\"",
"\"",
")",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"key",
",",
"\"",
"\"",
")",
"{",
"if",
"len",
"(",
"key",
")",
"==",
"1",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"labelsString",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// PrecheckInstance performs a preflight check on the specified
// series and constraints, ensuring that they are possibly valid for
// creating an instance in this model.
//
// PrecheckInstance is best effort, and not guaranteed to eliminate
// all invalid parameters. If PrecheckInstance returns nil, it is not
// guaranteed that the constraints are valid; if a non-nil error is
// returned, then the constraints are definitely invalid.
|
[
"PrecheckInstance",
"performs",
"a",
"preflight",
"check",
"on",
"the",
"specified",
"series",
"and",
"constraints",
"ensuring",
"that",
"they",
"are",
"possibly",
"valid",
"for",
"creating",
"an",
"instance",
"in",
"this",
"model",
".",
"PrecheckInstance",
"is",
"best",
"effort",
"and",
"not",
"guaranteed",
"to",
"eliminate",
"all",
"invalid",
"parameters",
".",
"If",
"PrecheckInstance",
"returns",
"nil",
"it",
"is",
"not",
"guaranteed",
"that",
"the",
"constraints",
"are",
"valid",
";",
"if",
"a",
"non",
"-",
"nil",
"error",
"is",
"returned",
"then",
"the",
"constraints",
"are",
"definitely",
"invalid",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/precheck.go#L24-L65
|
154,316 |
juju/juju
|
core/cache/controller.go
|
Validate
|
func (c *ControllerConfig) Validate() error {
if c.Changes == nil {
return errors.NotValidf("nil Changes")
}
return nil
}
|
go
|
func (c *ControllerConfig) Validate() error {
if c.Changes == nil {
return errors.NotValidf("nil Changes")
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"ControllerConfig",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"c",
".",
"Changes",
"==",
"nil",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Validate ensures the controller has the right values to be created.
|
[
"Validate",
"ensures",
"the",
"controller",
"has",
"the",
"right",
"values",
"to",
"be",
"created",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L32-L37
|
154,317 |
juju/juju
|
core/cache/controller.go
|
NewController
|
func NewController(config ControllerConfig) (*Controller, error) {
c, err := newController(config, newResidentManager(config.Changes))
return c, errors.Trace(err)
}
|
go
|
func NewController(config ControllerConfig) (*Controller, error) {
c, err := newController(config, newResidentManager(config.Changes))
return c, errors.Trace(err)
}
|
[
"func",
"NewController",
"(",
"config",
"ControllerConfig",
")",
"(",
"*",
"Controller",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"newController",
"(",
"config",
",",
"newResidentManager",
"(",
"config",
".",
"Changes",
")",
")",
"\n",
"return",
"c",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}"
] |
// NewController creates a new cached controller instance.
// The changes channel is what is used to supply the cache with the changes
// in order for the cache to be kept up to date.
|
[
"NewController",
"creates",
"a",
"new",
"cached",
"controller",
"instance",
".",
"The",
"changes",
"channel",
"is",
"what",
"is",
"used",
"to",
"supply",
"the",
"cache",
"with",
"the",
"changes",
"in",
"order",
"for",
"the",
"cache",
"to",
"be",
"kept",
"up",
"to",
"date",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L58-L61
|
154,318 |
juju/juju
|
core/cache/controller.go
|
newController
|
func newController(config ControllerConfig, manager *residentManager) (*Controller, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
c := &Controller{
manager: manager,
changes: config.Changes,
notify: config.Notify,
models: make(map[string]*Model),
hub: pubsub.NewSimpleHub(&pubsub.SimpleHubConfig{
// TODO: (thumper) add a get child method to loggers.
Logger: loggo.GetLogger("juju.core.cache.hub"),
}),
metrics: createControllerGauges(),
}
manager.dying = c.tomb.Dying()
c.tomb.Go(c.loop)
return c, nil
}
|
go
|
func newController(config ControllerConfig, manager *residentManager) (*Controller, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
c := &Controller{
manager: manager,
changes: config.Changes,
notify: config.Notify,
models: make(map[string]*Model),
hub: pubsub.NewSimpleHub(&pubsub.SimpleHubConfig{
// TODO: (thumper) add a get child method to loggers.
Logger: loggo.GetLogger("juju.core.cache.hub"),
}),
metrics: createControllerGauges(),
}
manager.dying = c.tomb.Dying()
c.tomb.Go(c.loop)
return c, nil
}
|
[
"func",
"newController",
"(",
"config",
"ControllerConfig",
",",
"manager",
"*",
"residentManager",
")",
"(",
"*",
"Controller",
",",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"c",
":=",
"&",
"Controller",
"{",
"manager",
":",
"manager",
",",
"changes",
":",
"config",
".",
"Changes",
",",
"notify",
":",
"config",
".",
"Notify",
",",
"models",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Model",
")",
",",
"hub",
":",
"pubsub",
".",
"NewSimpleHub",
"(",
"&",
"pubsub",
".",
"SimpleHubConfig",
"{",
"// TODO: (thumper) add a get child method to loggers.",
"Logger",
":",
"loggo",
".",
"GetLogger",
"(",
"\"",
"\"",
")",
",",
"}",
")",
",",
"metrics",
":",
"createControllerGauges",
"(",
")",
",",
"}",
"\n\n",
"manager",
".",
"dying",
"=",
"c",
".",
"tomb",
".",
"Dying",
"(",
")",
"\n",
"c",
".",
"tomb",
".",
"Go",
"(",
"c",
".",
"loop",
")",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] |
// newController is the internal constructor that allows supply of a manager.
|
[
"newController",
"is",
"the",
"internal",
"constructor",
"that",
"allows",
"supply",
"of",
"a",
"manager",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L64-L84
|
154,319 |
juju/juju
|
core/cache/controller.go
|
ModelUUIDs
|
func (c *Controller) ModelUUIDs() []string {
c.mu.Lock()
result := make([]string, 0, len(c.models))
for uuid := range c.models {
result = append(result, uuid)
}
c.mu.Unlock()
return result
}
|
go
|
func (c *Controller) ModelUUIDs() []string {
c.mu.Lock()
result := make([]string, 0, len(c.models))
for uuid := range c.models {
result = append(result, uuid)
}
c.mu.Unlock()
return result
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"ModelUUIDs",
"(",
")",
"[",
"]",
"string",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n\n",
"result",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"c",
".",
"models",
")",
")",
"\n",
"for",
"uuid",
":=",
"range",
"c",
".",
"models",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"uuid",
")",
"\n",
"}",
"\n\n",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"result",
"\n",
"}"
] |
// ModelUUIDs returns the UUIDs of the models in the cache.
|
[
"ModelUUIDs",
"returns",
"the",
"UUIDs",
"of",
"the",
"models",
"in",
"the",
"cache",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L155-L165
|
154,320 |
juju/juju
|
core/cache/controller.go
|
Model
|
func (c *Controller) Model(uuid string) (*Model, error) {
c.mu.Lock()
defer c.mu.Unlock()
model, found := c.models[uuid]
if !found {
return nil, errors.NotFoundf("model %q", uuid)
}
return model, nil
}
|
go
|
func (c *Controller) Model(uuid string) (*Model, error) {
c.mu.Lock()
defer c.mu.Unlock()
model, found := c.models[uuid]
if !found {
return nil, errors.NotFoundf("model %q", uuid)
}
return model, nil
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"Model",
"(",
"uuid",
"string",
")",
"(",
"*",
"Model",
",",
"error",
")",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"model",
",",
"found",
":=",
"c",
".",
"models",
"[",
"uuid",
"]",
"\n",
"if",
"!",
"found",
"{",
"return",
"nil",
",",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"uuid",
")",
"\n",
"}",
"\n",
"return",
"model",
",",
"nil",
"\n",
"}"
] |
// Model returns the model for the specified UUID.
// If the model isn't found, a NotFoundError is returned.
|
[
"Model",
"returns",
"the",
"model",
"for",
"the",
"specified",
"UUID",
".",
"If",
"the",
"model",
"isn",
"t",
"found",
"a",
"NotFoundError",
"is",
"returned",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L179-L188
|
154,321 |
juju/juju
|
core/cache/controller.go
|
updateModel
|
func (c *Controller) updateModel(ch ModelChange) {
c.ensureModel(ch.ModelUUID).setDetails(ch)
}
|
go
|
func (c *Controller) updateModel(ch ModelChange) {
c.ensureModel(ch.ModelUUID).setDetails(ch)
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"updateModel",
"(",
"ch",
"ModelChange",
")",
"{",
"c",
".",
"ensureModel",
"(",
"ch",
".",
"ModelUUID",
")",
".",
"setDetails",
"(",
"ch",
")",
"\n",
"}"
] |
// updateModel will add or update the model details as
// described in the ModelChange.
|
[
"updateModel",
"will",
"add",
"or",
"update",
"the",
"model",
"details",
"as",
"described",
"in",
"the",
"ModelChange",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L192-L194
|
154,322 |
juju/juju
|
core/cache/controller.go
|
removeModel
|
func (c *Controller) removeModel(ch RemoveModel) error {
c.mu.Lock()
defer c.mu.Unlock()
mod, ok := c.models[ch.ModelUUID]
if ok {
if err := mod.evict(); err != nil {
return errors.Trace(err)
}
delete(c.models, ch.ModelUUID)
}
return nil
}
|
go
|
func (c *Controller) removeModel(ch RemoveModel) error {
c.mu.Lock()
defer c.mu.Unlock()
mod, ok := c.models[ch.ModelUUID]
if ok {
if err := mod.evict(); err != nil {
return errors.Trace(err)
}
delete(c.models, ch.ModelUUID)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"removeModel",
"(",
"ch",
"RemoveModel",
")",
"error",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"mod",
",",
"ok",
":=",
"c",
".",
"models",
"[",
"ch",
".",
"ModelUUID",
"]",
"\n",
"if",
"ok",
"{",
"if",
"err",
":=",
"mod",
".",
"evict",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"delete",
"(",
"c",
".",
"models",
",",
"ch",
".",
"ModelUUID",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// removeModel removes the model from the cache.
|
[
"removeModel",
"removes",
"the",
"model",
"from",
"the",
"cache",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L197-L209
|
154,323 |
juju/juju
|
core/cache/controller.go
|
updateApplication
|
func (c *Controller) updateApplication(ch ApplicationChange) {
c.ensureModel(ch.ModelUUID).updateApplication(ch, c.manager)
}
|
go
|
func (c *Controller) updateApplication(ch ApplicationChange) {
c.ensureModel(ch.ModelUUID).updateApplication(ch, c.manager)
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"updateApplication",
"(",
"ch",
"ApplicationChange",
")",
"{",
"c",
".",
"ensureModel",
"(",
"ch",
".",
"ModelUUID",
")",
".",
"updateApplication",
"(",
"ch",
",",
"c",
".",
"manager",
")",
"\n",
"}"
] |
// updateApplication adds or updates the application in the specified model.
|
[
"updateApplication",
"adds",
"or",
"updates",
"the",
"application",
"in",
"the",
"specified",
"model",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L212-L214
|
154,324 |
juju/juju
|
core/cache/controller.go
|
removeApplication
|
func (c *Controller) removeApplication(ch RemoveApplication) error {
return errors.Trace(c.removeResident(ch.ModelUUID, func(m *Model) error { return m.removeApplication(ch) }))
}
|
go
|
func (c *Controller) removeApplication(ch RemoveApplication) error {
return errors.Trace(c.removeResident(ch.ModelUUID, func(m *Model) error { return m.removeApplication(ch) }))
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"removeApplication",
"(",
"ch",
"RemoveApplication",
")",
"error",
"{",
"return",
"errors",
".",
"Trace",
"(",
"c",
".",
"removeResident",
"(",
"ch",
".",
"ModelUUID",
",",
"func",
"(",
"m",
"*",
"Model",
")",
"error",
"{",
"return",
"m",
".",
"removeApplication",
"(",
"ch",
")",
"}",
")",
")",
"\n",
"}"
] |
// removeApplication removes the application for the cached model.
// If the cache does not have the model loaded for the application yet,
// then it will not have the application cached.
|
[
"removeApplication",
"removes",
"the",
"application",
"for",
"the",
"cached",
"model",
".",
"If",
"the",
"cache",
"does",
"not",
"have",
"the",
"model",
"loaded",
"for",
"the",
"application",
"yet",
"then",
"it",
"will",
"not",
"have",
"the",
"application",
"cached",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L219-L221
|
154,325 |
juju/juju
|
core/cache/controller.go
|
updateUnit
|
func (c *Controller) updateUnit(ch UnitChange) {
c.ensureModel(ch.ModelUUID).updateUnit(ch, c.manager)
}
|
go
|
func (c *Controller) updateUnit(ch UnitChange) {
c.ensureModel(ch.ModelUUID).updateUnit(ch, c.manager)
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"updateUnit",
"(",
"ch",
"UnitChange",
")",
"{",
"c",
".",
"ensureModel",
"(",
"ch",
".",
"ModelUUID",
")",
".",
"updateUnit",
"(",
"ch",
",",
"c",
".",
"manager",
")",
"\n",
"}"
] |
// updateUnit adds or updates the unit in the specified model.
|
[
"updateUnit",
"adds",
"or",
"updates",
"the",
"unit",
"in",
"the",
"specified",
"model",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L232-L234
|
154,326 |
juju/juju
|
core/cache/controller.go
|
removeUnit
|
func (c *Controller) removeUnit(ch RemoveUnit) error {
return errors.Trace(c.removeResident(ch.ModelUUID, func(m *Model) error { return m.removeUnit(ch) }))
}
|
go
|
func (c *Controller) removeUnit(ch RemoveUnit) error {
return errors.Trace(c.removeResident(ch.ModelUUID, func(m *Model) error { return m.removeUnit(ch) }))
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"removeUnit",
"(",
"ch",
"RemoveUnit",
")",
"error",
"{",
"return",
"errors",
".",
"Trace",
"(",
"c",
".",
"removeResident",
"(",
"ch",
".",
"ModelUUID",
",",
"func",
"(",
"m",
"*",
"Model",
")",
"error",
"{",
"return",
"m",
".",
"removeUnit",
"(",
"ch",
")",
"}",
")",
")",
"\n",
"}"
] |
// removeUnit removes the unit from the cached model.
// If the cache does not have the model loaded for the unit yet,
// then it will not have the unit cached.
|
[
"removeUnit",
"removes",
"the",
"unit",
"from",
"the",
"cached",
"model",
".",
"If",
"the",
"cache",
"does",
"not",
"have",
"the",
"model",
"loaded",
"for",
"the",
"unit",
"yet",
"then",
"it",
"will",
"not",
"have",
"the",
"unit",
"cached",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L239-L241
|
154,327 |
juju/juju
|
core/cache/controller.go
|
updateMachine
|
func (c *Controller) updateMachine(ch MachineChange) {
c.ensureModel(ch.ModelUUID).updateMachine(ch, c.manager)
}
|
go
|
func (c *Controller) updateMachine(ch MachineChange) {
c.ensureModel(ch.ModelUUID).updateMachine(ch, c.manager)
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"updateMachine",
"(",
"ch",
"MachineChange",
")",
"{",
"c",
".",
"ensureModel",
"(",
"ch",
".",
"ModelUUID",
")",
".",
"updateMachine",
"(",
"ch",
",",
"c",
".",
"manager",
")",
"\n",
"}"
] |
// updateMachine adds or updates the machine in the specified model.
|
[
"updateMachine",
"adds",
"or",
"updates",
"the",
"machine",
"in",
"the",
"specified",
"model",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L244-L246
|
154,328 |
juju/juju
|
core/cache/controller.go
|
removeMachine
|
func (c *Controller) removeMachine(ch RemoveMachine) error {
return errors.Trace(c.removeResident(ch.ModelUUID, func(m *Model) error { return m.removeMachine(ch) }))
}
|
go
|
func (c *Controller) removeMachine(ch RemoveMachine) error {
return errors.Trace(c.removeResident(ch.ModelUUID, func(m *Model) error { return m.removeMachine(ch) }))
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"removeMachine",
"(",
"ch",
"RemoveMachine",
")",
"error",
"{",
"return",
"errors",
".",
"Trace",
"(",
"c",
".",
"removeResident",
"(",
"ch",
".",
"ModelUUID",
",",
"func",
"(",
"m",
"*",
"Model",
")",
"error",
"{",
"return",
"m",
".",
"removeMachine",
"(",
"ch",
")",
"}",
")",
")",
"\n",
"}"
] |
// removeMachine removes the machine from the cached model.
// If the cache does not have the model loaded for the machine yet,
// then it will not have the machine cached.
|
[
"removeMachine",
"removes",
"the",
"machine",
"from",
"the",
"cached",
"model",
".",
"If",
"the",
"cache",
"does",
"not",
"have",
"the",
"model",
"loaded",
"for",
"the",
"machine",
"yet",
"then",
"it",
"will",
"not",
"have",
"the",
"machine",
"cached",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L251-L253
|
154,329 |
juju/juju
|
core/cache/controller.go
|
ensureModel
|
func (c *Controller) ensureModel(modelUUID string) *Model {
c.mu.Lock()
model, found := c.models[modelUUID]
if !found {
model = newModel(c.metrics, c.hub, c.manager.new())
c.models[modelUUID] = model
} else {
model.setStale(false)
}
c.mu.Unlock()
return model
}
|
go
|
func (c *Controller) ensureModel(modelUUID string) *Model {
c.mu.Lock()
model, found := c.models[modelUUID]
if !found {
model = newModel(c.metrics, c.hub, c.manager.new())
c.models[modelUUID] = model
} else {
model.setStale(false)
}
c.mu.Unlock()
return model
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"ensureModel",
"(",
"modelUUID",
"string",
")",
"*",
"Model",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n\n",
"model",
",",
"found",
":=",
"c",
".",
"models",
"[",
"modelUUID",
"]",
"\n",
"if",
"!",
"found",
"{",
"model",
"=",
"newModel",
"(",
"c",
".",
"metrics",
",",
"c",
".",
"hub",
",",
"c",
".",
"manager",
".",
"new",
"(",
")",
")",
"\n",
"c",
".",
"models",
"[",
"modelUUID",
"]",
"=",
"model",
"\n",
"}",
"else",
"{",
"model",
".",
"setStale",
"(",
"false",
")",
"\n",
"}",
"\n\n",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"model",
"\n",
"}"
] |
// ensureModel retrieves the cached model for the input UUID,
// or adds it if not found.
// It is likely that we will receive a change update for the model before we
// get an update for one of its entities, but the cache needs to be resilient
// enough to make sure that we can handle when this is not the case.
// No model returned by this method is ever considered to be stale.
|
[
"ensureModel",
"retrieves",
"the",
"cached",
"model",
"for",
"the",
"input",
"UUID",
"or",
"adds",
"it",
"if",
"not",
"found",
".",
"It",
"is",
"likely",
"that",
"we",
"will",
"receive",
"a",
"change",
"update",
"for",
"the",
"model",
"before",
"we",
"get",
"an",
"update",
"for",
"one",
"of",
"its",
"entities",
"but",
"the",
"cache",
"needs",
"to",
"be",
"resilient",
"enough",
"to",
"make",
"sure",
"that",
"we",
"can",
"handle",
"when",
"this",
"is",
"not",
"the",
"case",
".",
"No",
"model",
"returned",
"by",
"this",
"method",
"is",
"ever",
"considered",
"to",
"be",
"stale",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/controller.go#L273-L286
|
154,330 |
juju/juju
|
cmd/juju/common/cloud.go
|
IsChooseCloudRegionError
|
func IsChooseCloudRegionError(err error) bool {
_, ok := errors.Cause(err).(chooseCloudRegionError)
return ok
}
|
go
|
func IsChooseCloudRegionError(err error) bool {
_, ok := errors.Cause(err).(chooseCloudRegionError)
return ok
}
|
[
"func",
"IsChooseCloudRegionError",
"(",
"err",
"error",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"errors",
".",
"Cause",
"(",
"err",
")",
".",
"(",
"chooseCloudRegionError",
")",
"\n",
"return",
"ok",
"\n",
"}"
] |
// IsChooseCloudRegionError reports whether or not the given
// error was returned from ChooseCloudRegion.
|
[
"IsChooseCloudRegionError",
"reports",
"whether",
"or",
"not",
"the",
"given",
"error",
"was",
"returned",
"from",
"ChooseCloudRegion",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/common/cloud.go#L24-L27
|
154,331 |
juju/juju
|
cmd/juju/common/cloud.go
|
CloudOrProvider
|
func CloudOrProvider(cloudName string, cloudByNameFunc func(string) (*jujucloud.Cloud, error)) (cloud *jujucloud.Cloud, err error) {
if cloud, err = cloudByNameFunc(cloudName); err != nil {
if !errors.IsNotFound(err) {
return nil, err
}
builtInClouds, err := BuiltInClouds()
if err != nil {
return nil, errors.Trace(err)
}
if builtIn, ok := builtInClouds[cloudName]; !ok {
return nil, errors.NotValidf("cloud %v", cloudName)
} else {
cloud = &builtIn
}
}
return cloud, nil
}
|
go
|
func CloudOrProvider(cloudName string, cloudByNameFunc func(string) (*jujucloud.Cloud, error)) (cloud *jujucloud.Cloud, err error) {
if cloud, err = cloudByNameFunc(cloudName); err != nil {
if !errors.IsNotFound(err) {
return nil, err
}
builtInClouds, err := BuiltInClouds()
if err != nil {
return nil, errors.Trace(err)
}
if builtIn, ok := builtInClouds[cloudName]; !ok {
return nil, errors.NotValidf("cloud %v", cloudName)
} else {
cloud = &builtIn
}
}
return cloud, nil
}
|
[
"func",
"CloudOrProvider",
"(",
"cloudName",
"string",
",",
"cloudByNameFunc",
"func",
"(",
"string",
")",
"(",
"*",
"jujucloud",
".",
"Cloud",
",",
"error",
")",
")",
"(",
"cloud",
"*",
"jujucloud",
".",
"Cloud",
",",
"err",
"error",
")",
"{",
"if",
"cloud",
",",
"err",
"=",
"cloudByNameFunc",
"(",
"cloudName",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"!",
"errors",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"builtInClouds",
",",
"err",
":=",
"BuiltInClouds",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"builtIn",
",",
"ok",
":=",
"builtInClouds",
"[",
"cloudName",
"]",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
",",
"cloudName",
")",
"\n",
"}",
"else",
"{",
"cloud",
"=",
"&",
"builtIn",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"cloud",
",",
"nil",
"\n",
"}"
] |
// CloudOrProvider finds and returns cloud or provider.
|
[
"CloudOrProvider",
"finds",
"and",
"returns",
"cloud",
"or",
"provider",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/common/cloud.go#L30-L46
|
154,332 |
juju/juju
|
cmd/juju/common/cloud.go
|
ChooseCloudRegion
|
func ChooseCloudRegion(cloud jujucloud.Cloud, regionName string) (jujucloud.Region, error) {
if regionName != "" {
region, err := jujucloud.RegionByName(cloud.Regions, regionName)
if err != nil {
return jujucloud.Region{}, errors.Trace(chooseCloudRegionError{err})
}
return *region, nil
}
if len(cloud.Regions) > 0 {
// No region was specified, use the first region in the list.
return cloud.Regions[0], nil
}
return jujucloud.Region{
"", // no region name
cloud.Endpoint,
cloud.IdentityEndpoint,
cloud.StorageEndpoint,
}, nil
}
|
go
|
func ChooseCloudRegion(cloud jujucloud.Cloud, regionName string) (jujucloud.Region, error) {
if regionName != "" {
region, err := jujucloud.RegionByName(cloud.Regions, regionName)
if err != nil {
return jujucloud.Region{}, errors.Trace(chooseCloudRegionError{err})
}
return *region, nil
}
if len(cloud.Regions) > 0 {
// No region was specified, use the first region in the list.
return cloud.Regions[0], nil
}
return jujucloud.Region{
"", // no region name
cloud.Endpoint,
cloud.IdentityEndpoint,
cloud.StorageEndpoint,
}, nil
}
|
[
"func",
"ChooseCloudRegion",
"(",
"cloud",
"jujucloud",
".",
"Cloud",
",",
"regionName",
"string",
")",
"(",
"jujucloud",
".",
"Region",
",",
"error",
")",
"{",
"if",
"regionName",
"!=",
"\"",
"\"",
"{",
"region",
",",
"err",
":=",
"jujucloud",
".",
"RegionByName",
"(",
"cloud",
".",
"Regions",
",",
"regionName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"jujucloud",
".",
"Region",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"chooseCloudRegionError",
"{",
"err",
"}",
")",
"\n",
"}",
"\n",
"return",
"*",
"region",
",",
"nil",
"\n",
"}",
"\n",
"if",
"len",
"(",
"cloud",
".",
"Regions",
")",
">",
"0",
"{",
"// No region was specified, use the first region in the list.",
"return",
"cloud",
".",
"Regions",
"[",
"0",
"]",
",",
"nil",
"\n",
"}",
"\n",
"return",
"jujucloud",
".",
"Region",
"{",
"\"",
"\"",
",",
"// no region name",
"cloud",
".",
"Endpoint",
",",
"cloud",
".",
"IdentityEndpoint",
",",
"cloud",
".",
"StorageEndpoint",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// ChooseCloudRegion returns the cloud.Region to use, based on the specified
// region name. If no region name is specified, and there is at least one
// region, we use the first region in the list. If there are no regions, then
// we return a region with no name, having the same endpoints as the cloud.
|
[
"ChooseCloudRegion",
"returns",
"the",
"cloud",
".",
"Region",
"to",
"use",
"based",
"on",
"the",
"specified",
"region",
"name",
".",
"If",
"no",
"region",
"name",
"is",
"specified",
"and",
"there",
"is",
"at",
"least",
"one",
"region",
"we",
"use",
"the",
"first",
"region",
"in",
"the",
"list",
".",
"If",
"there",
"are",
"no",
"regions",
"then",
"we",
"return",
"a",
"region",
"with",
"no",
"name",
"having",
"the",
"same",
"endpoints",
"as",
"the",
"cloud",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/common/cloud.go#L52-L70
|
154,333 |
juju/juju
|
cmd/juju/common/cloud.go
|
BuiltInClouds
|
func BuiltInClouds() (map[string]jujucloud.Cloud, error) {
allClouds := make(map[string]jujucloud.Cloud)
for _, providerType := range environs.RegisteredProviders() {
p, err := environs.Provider(providerType)
if err != nil {
return nil, errors.Trace(err)
}
detector, ok := p.(environs.CloudDetector)
if !ok {
continue
}
clouds, err := detector.DetectClouds()
if err != nil {
return nil, errors.Annotatef(
err, "detecting clouds for provider %q",
providerType,
)
}
for _, cloud := range clouds {
allClouds[cloud.Name] = cloud
}
}
return allClouds, nil
}
|
go
|
func BuiltInClouds() (map[string]jujucloud.Cloud, error) {
allClouds := make(map[string]jujucloud.Cloud)
for _, providerType := range environs.RegisteredProviders() {
p, err := environs.Provider(providerType)
if err != nil {
return nil, errors.Trace(err)
}
detector, ok := p.(environs.CloudDetector)
if !ok {
continue
}
clouds, err := detector.DetectClouds()
if err != nil {
return nil, errors.Annotatef(
err, "detecting clouds for provider %q",
providerType,
)
}
for _, cloud := range clouds {
allClouds[cloud.Name] = cloud
}
}
return allClouds, nil
}
|
[
"func",
"BuiltInClouds",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"jujucloud",
".",
"Cloud",
",",
"error",
")",
"{",
"allClouds",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"jujucloud",
".",
"Cloud",
")",
"\n",
"for",
"_",
",",
"providerType",
":=",
"range",
"environs",
".",
"RegisteredProviders",
"(",
")",
"{",
"p",
",",
"err",
":=",
"environs",
".",
"Provider",
"(",
"providerType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"detector",
",",
"ok",
":=",
"p",
".",
"(",
"environs",
".",
"CloudDetector",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"clouds",
",",
"err",
":=",
"detector",
".",
"DetectClouds",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"providerType",
",",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"cloud",
":=",
"range",
"clouds",
"{",
"allClouds",
"[",
"cloud",
".",
"Name",
"]",
"=",
"cloud",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"allClouds",
",",
"nil",
"\n",
"}"
] |
// BuiltInClouds returns cloud information for those
// providers which are built in to Juju.
|
[
"BuiltInClouds",
"returns",
"cloud",
"information",
"for",
"those",
"providers",
"which",
"are",
"built",
"in",
"to",
"Juju",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/common/cloud.go#L74-L97
|
154,334 |
juju/juju
|
cmd/juju/common/cloud.go
|
CloudByName
|
func CloudByName(cloudName string) (*jujucloud.Cloud, error) {
cloud, err := jujucloud.CloudByName(cloudName)
if err != nil {
if errors.IsNotFound(err) {
// Check built in clouds like localhost (lxd).
builtinClouds, err := BuiltInClouds()
if err != nil {
return nil, errors.Trace(err)
}
aCloud, found := builtinClouds[cloudName]
if !found {
return nil, errors.NotFoundf("cloud %s", cloudName)
}
return &aCloud, nil
}
return nil, errors.Trace(err)
}
return cloud, nil
}
|
go
|
func CloudByName(cloudName string) (*jujucloud.Cloud, error) {
cloud, err := jujucloud.CloudByName(cloudName)
if err != nil {
if errors.IsNotFound(err) {
// Check built in clouds like localhost (lxd).
builtinClouds, err := BuiltInClouds()
if err != nil {
return nil, errors.Trace(err)
}
aCloud, found := builtinClouds[cloudName]
if !found {
return nil, errors.NotFoundf("cloud %s", cloudName)
}
return &aCloud, nil
}
return nil, errors.Trace(err)
}
return cloud, nil
}
|
[
"func",
"CloudByName",
"(",
"cloudName",
"string",
")",
"(",
"*",
"jujucloud",
".",
"Cloud",
",",
"error",
")",
"{",
"cloud",
",",
"err",
":=",
"jujucloud",
".",
"CloudByName",
"(",
"cloudName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"errors",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"// Check built in clouds like localhost (lxd).",
"builtinClouds",
",",
"err",
":=",
"BuiltInClouds",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"aCloud",
",",
"found",
":=",
"builtinClouds",
"[",
"cloudName",
"]",
"\n",
"if",
"!",
"found",
"{",
"return",
"nil",
",",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"cloudName",
")",
"\n",
"}",
"\n",
"return",
"&",
"aCloud",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cloud",
",",
"nil",
"\n",
"}"
] |
// CloudByName returns a cloud for given name
// regardless of whether it's public, private or builtin cloud.
// Not to be confused with cloud.CloudByName which does not cater
// for built-in clouds like localhost.
|
[
"CloudByName",
"returns",
"a",
"cloud",
"for",
"given",
"name",
"regardless",
"of",
"whether",
"it",
"s",
"public",
"private",
"or",
"builtin",
"cloud",
".",
"Not",
"to",
"be",
"confused",
"with",
"cloud",
".",
"CloudByName",
"which",
"does",
"not",
"cater",
"for",
"built",
"-",
"in",
"clouds",
"like",
"localhost",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/common/cloud.go#L103-L121
|
154,335 |
juju/juju
|
cmd/juju/common/cloud.go
|
CloudSchemaByType
|
func CloudSchemaByType(cloudType string) (environschema.Fields, error) {
provider, err := environs.Provider(cloudType)
if err != nil {
return nil, err
}
ps, ok := provider.(environs.ProviderSchema)
if !ok {
return nil, errors.NotImplementedf("environs.ProviderSchema")
}
providerSchema := ps.Schema()
if providerSchema == nil {
return nil, errors.New("Failed to retrieve Provider Schema")
}
return providerSchema, nil
}
|
go
|
func CloudSchemaByType(cloudType string) (environschema.Fields, error) {
provider, err := environs.Provider(cloudType)
if err != nil {
return nil, err
}
ps, ok := provider.(environs.ProviderSchema)
if !ok {
return nil, errors.NotImplementedf("environs.ProviderSchema")
}
providerSchema := ps.Schema()
if providerSchema == nil {
return nil, errors.New("Failed to retrieve Provider Schema")
}
return providerSchema, nil
}
|
[
"func",
"CloudSchemaByType",
"(",
"cloudType",
"string",
")",
"(",
"environschema",
".",
"Fields",
",",
"error",
")",
"{",
"provider",
",",
"err",
":=",
"environs",
".",
"Provider",
"(",
"cloudType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ps",
",",
"ok",
":=",
"provider",
".",
"(",
"environs",
".",
"ProviderSchema",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"NotImplementedf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"providerSchema",
":=",
"ps",
".",
"Schema",
"(",
")",
"\n",
"if",
"providerSchema",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"providerSchema",
",",
"nil",
"\n",
"}"
] |
// CloudSchemaByType returns the Schema for a given cloud type.
// If the ProviderSchema is not implemented for the given cloud
// type, a NotFound error is returned.
|
[
"CloudSchemaByType",
"returns",
"the",
"Schema",
"for",
"a",
"given",
"cloud",
"type",
".",
"If",
"the",
"ProviderSchema",
"is",
"not",
"implemented",
"for",
"the",
"given",
"cloud",
"type",
"a",
"NotFound",
"error",
"is",
"returned",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/common/cloud.go#L126-L140
|
154,336 |
juju/juju
|
cmd/juju/common/cloud.go
|
ProviderConfigSchemaSourceByType
|
func ProviderConfigSchemaSourceByType(cloudType string) (config.ConfigSchemaSource, error) {
provider, err := environs.Provider(cloudType)
if err != nil {
return nil, err
}
if cs, ok := provider.(config.ConfigSchemaSource); ok {
return cs, nil
}
return nil, errors.NotImplementedf("config.ConfigSource")
}
|
go
|
func ProviderConfigSchemaSourceByType(cloudType string) (config.ConfigSchemaSource, error) {
provider, err := environs.Provider(cloudType)
if err != nil {
return nil, err
}
if cs, ok := provider.(config.ConfigSchemaSource); ok {
return cs, nil
}
return nil, errors.NotImplementedf("config.ConfigSource")
}
|
[
"func",
"ProviderConfigSchemaSourceByType",
"(",
"cloudType",
"string",
")",
"(",
"config",
".",
"ConfigSchemaSource",
",",
"error",
")",
"{",
"provider",
",",
"err",
":=",
"environs",
".",
"Provider",
"(",
"cloudType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"cs",
",",
"ok",
":=",
"provider",
".",
"(",
"config",
".",
"ConfigSchemaSource",
")",
";",
"ok",
"{",
"return",
"cs",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"NotImplementedf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// ProviderConfigSchemaSourceByType returns a config.ConfigSchemaSource
// for the environ provider, found for the given cloud type, or an error.
|
[
"ProviderConfigSchemaSourceByType",
"returns",
"a",
"config",
".",
"ConfigSchemaSource",
"for",
"the",
"environ",
"provider",
"found",
"for",
"the",
"given",
"cloud",
"type",
"or",
"an",
"error",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/common/cloud.go#L144-L153
|
154,337 |
juju/juju
|
worker/gate/manifold.go
|
Unlock
|
func (l *lock) Unlock() {
l.mu.Lock()
defer l.mu.Unlock()
select {
case <-l.ch:
default:
close(l.ch)
}
}
|
go
|
func (l *lock) Unlock() {
l.mu.Lock()
defer l.mu.Unlock()
select {
case <-l.ch:
default:
close(l.ch)
}
}
|
[
"func",
"(",
"l",
"*",
"lock",
")",
"Unlock",
"(",
")",
"{",
"l",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"l",
".",
"ch",
":",
"default",
":",
"close",
"(",
"l",
".",
"ch",
")",
"\n",
"}",
"\n",
"}"
] |
// Unlock implements Unlocker.
|
[
"Unlock",
"implements",
"Unlocker",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/gate/manifold.go#L82-L90
|
154,338 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumeParams
|
func VolumeParams(
v state.Volume,
storageInstance state.StorageInstance,
modelUUID, controllerUUID string,
environConfig *config.Config,
poolManager poolmanager.PoolManager,
registry storage.ProviderRegistry,
) (params.VolumeParams, error) {
var pool string
var size uint64
if stateVolumeParams, ok := v.Params(); ok {
pool = stateVolumeParams.Pool
size = stateVolumeParams.Size
} else {
volumeInfo, err := v.Info()
if err != nil {
return params.VolumeParams{}, errors.Trace(err)
}
pool = volumeInfo.Pool
size = volumeInfo.Size
}
volumeTags, err := StorageTags(storageInstance, modelUUID, controllerUUID, environConfig)
if err != nil {
return params.VolumeParams{}, errors.Annotate(err, "computing storage tags")
}
providerType, cfg, err := StoragePoolConfig(pool, poolManager, registry)
if err != nil {
return params.VolumeParams{}, errors.Trace(err)
}
return params.VolumeParams{
v.Tag().String(),
size,
string(providerType),
cfg.Attrs(),
volumeTags,
nil, // attachment params set by the caller
}, nil
}
|
go
|
func VolumeParams(
v state.Volume,
storageInstance state.StorageInstance,
modelUUID, controllerUUID string,
environConfig *config.Config,
poolManager poolmanager.PoolManager,
registry storage.ProviderRegistry,
) (params.VolumeParams, error) {
var pool string
var size uint64
if stateVolumeParams, ok := v.Params(); ok {
pool = stateVolumeParams.Pool
size = stateVolumeParams.Size
} else {
volumeInfo, err := v.Info()
if err != nil {
return params.VolumeParams{}, errors.Trace(err)
}
pool = volumeInfo.Pool
size = volumeInfo.Size
}
volumeTags, err := StorageTags(storageInstance, modelUUID, controllerUUID, environConfig)
if err != nil {
return params.VolumeParams{}, errors.Annotate(err, "computing storage tags")
}
providerType, cfg, err := StoragePoolConfig(pool, poolManager, registry)
if err != nil {
return params.VolumeParams{}, errors.Trace(err)
}
return params.VolumeParams{
v.Tag().String(),
size,
string(providerType),
cfg.Attrs(),
volumeTags,
nil, // attachment params set by the caller
}, nil
}
|
[
"func",
"VolumeParams",
"(",
"v",
"state",
".",
"Volume",
",",
"storageInstance",
"state",
".",
"StorageInstance",
",",
"modelUUID",
",",
"controllerUUID",
"string",
",",
"environConfig",
"*",
"config",
".",
"Config",
",",
"poolManager",
"poolmanager",
".",
"PoolManager",
",",
"registry",
"storage",
".",
"ProviderRegistry",
",",
")",
"(",
"params",
".",
"VolumeParams",
",",
"error",
")",
"{",
"var",
"pool",
"string",
"\n",
"var",
"size",
"uint64",
"\n",
"if",
"stateVolumeParams",
",",
"ok",
":=",
"v",
".",
"Params",
"(",
")",
";",
"ok",
"{",
"pool",
"=",
"stateVolumeParams",
".",
"Pool",
"\n",
"size",
"=",
"stateVolumeParams",
".",
"Size",
"\n",
"}",
"else",
"{",
"volumeInfo",
",",
"err",
":=",
"v",
".",
"Info",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"VolumeParams",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"pool",
"=",
"volumeInfo",
".",
"Pool",
"\n",
"size",
"=",
"volumeInfo",
".",
"Size",
"\n",
"}",
"\n\n",
"volumeTags",
",",
"err",
":=",
"StorageTags",
"(",
"storageInstance",
",",
"modelUUID",
",",
"controllerUUID",
",",
"environConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"VolumeParams",
"{",
"}",
",",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"providerType",
",",
"cfg",
",",
"err",
":=",
"StoragePoolConfig",
"(",
"pool",
",",
"poolManager",
",",
"registry",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"VolumeParams",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"params",
".",
"VolumeParams",
"{",
"v",
".",
"Tag",
"(",
")",
".",
"String",
"(",
")",
",",
"size",
",",
"string",
"(",
"providerType",
")",
",",
"cfg",
".",
"Attrs",
"(",
")",
",",
"volumeTags",
",",
"nil",
",",
"// attachment params set by the caller",
"}",
",",
"nil",
"\n",
"}"
] |
// VolumeParams returns the parameters for creating or destroying
// the given volume.
|
[
"VolumeParams",
"returns",
"the",
"parameters",
"for",
"creating",
"or",
"destroying",
"the",
"given",
"volume",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L19-L59
|
154,339 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
StoragePoolConfig
|
func StoragePoolConfig(name string, poolManager poolmanager.PoolManager, registry storage.ProviderRegistry) (storage.ProviderType, *storage.Config, error) {
pool, err := poolManager.Get(name)
if errors.IsNotFound(err) {
// If not a storage pool, then maybe a provider type.
providerType := storage.ProviderType(name)
if _, err1 := registry.StorageProvider(providerType); err1 != nil {
return "", nil, errors.Trace(err)
}
return providerType, &storage.Config{}, nil
} else if err != nil {
return "", nil, errors.Annotatef(err, "getting pool %q", name)
}
return pool.Provider(), pool, nil
}
|
go
|
func StoragePoolConfig(name string, poolManager poolmanager.PoolManager, registry storage.ProviderRegistry) (storage.ProviderType, *storage.Config, error) {
pool, err := poolManager.Get(name)
if errors.IsNotFound(err) {
// If not a storage pool, then maybe a provider type.
providerType := storage.ProviderType(name)
if _, err1 := registry.StorageProvider(providerType); err1 != nil {
return "", nil, errors.Trace(err)
}
return providerType, &storage.Config{}, nil
} else if err != nil {
return "", nil, errors.Annotatef(err, "getting pool %q", name)
}
return pool.Provider(), pool, nil
}
|
[
"func",
"StoragePoolConfig",
"(",
"name",
"string",
",",
"poolManager",
"poolmanager",
".",
"PoolManager",
",",
"registry",
"storage",
".",
"ProviderRegistry",
")",
"(",
"storage",
".",
"ProviderType",
",",
"*",
"storage",
".",
"Config",
",",
"error",
")",
"{",
"pool",
",",
"err",
":=",
"poolManager",
".",
"Get",
"(",
"name",
")",
"\n",
"if",
"errors",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"// If not a storage pool, then maybe a provider type.",
"providerType",
":=",
"storage",
".",
"ProviderType",
"(",
"name",
")",
"\n",
"if",
"_",
",",
"err1",
":=",
"registry",
".",
"StorageProvider",
"(",
"providerType",
")",
";",
"err1",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"providerType",
",",
"&",
"storage",
".",
"Config",
"{",
"}",
",",
"nil",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"pool",
".",
"Provider",
"(",
")",
",",
"pool",
",",
"nil",
"\n",
"}"
] |
// StoragePoolConfig returns the storage provider type and
// configuration for a named storage pool. If there is no
// such pool with the specified name, but it identifies a
// storage provider, then that type will be returned with a
// nil configuration.
|
[
"StoragePoolConfig",
"returns",
"the",
"storage",
"provider",
"type",
"and",
"configuration",
"for",
"a",
"named",
"storage",
"pool",
".",
"If",
"there",
"is",
"no",
"such",
"pool",
"with",
"the",
"specified",
"name",
"but",
"it",
"identifies",
"a",
"storage",
"provider",
"then",
"that",
"type",
"will",
"be",
"returned",
"with",
"a",
"nil",
"configuration",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L66-L79
|
154,340 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumesToState
|
func VolumesToState(in []params.Volume) (map[names.VolumeTag]state.VolumeInfo, error) {
m := make(map[names.VolumeTag]state.VolumeInfo)
for _, v := range in {
tag, volumeInfo, err := VolumeToState(v)
if err != nil {
return nil, errors.Trace(err)
}
m[tag] = volumeInfo
}
return m, nil
}
|
go
|
func VolumesToState(in []params.Volume) (map[names.VolumeTag]state.VolumeInfo, error) {
m := make(map[names.VolumeTag]state.VolumeInfo)
for _, v := range in {
tag, volumeInfo, err := VolumeToState(v)
if err != nil {
return nil, errors.Trace(err)
}
m[tag] = volumeInfo
}
return m, nil
}
|
[
"func",
"VolumesToState",
"(",
"in",
"[",
"]",
"params",
".",
"Volume",
")",
"(",
"map",
"[",
"names",
".",
"VolumeTag",
"]",
"state",
".",
"VolumeInfo",
",",
"error",
")",
"{",
"m",
":=",
"make",
"(",
"map",
"[",
"names",
".",
"VolumeTag",
"]",
"state",
".",
"VolumeInfo",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"in",
"{",
"tag",
",",
"volumeInfo",
",",
"err",
":=",
"VolumeToState",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"m",
"[",
"tag",
"]",
"=",
"volumeInfo",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// VolumesToState converts a slice of params.Volume to a mapping
// of volume tags to state.VolumeInfo.
|
[
"VolumesToState",
"converts",
"a",
"slice",
"of",
"params",
".",
"Volume",
"to",
"a",
"mapping",
"of",
"volume",
"tags",
"to",
"state",
".",
"VolumeInfo",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L83-L93
|
154,341 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumeToState
|
func VolumeToState(v params.Volume) (names.VolumeTag, state.VolumeInfo, error) {
if v.VolumeTag == "" {
return names.VolumeTag{}, state.VolumeInfo{}, errors.New("Tag is empty")
}
volumeTag, err := names.ParseVolumeTag(v.VolumeTag)
if err != nil {
return names.VolumeTag{}, state.VolumeInfo{}, errors.Trace(err)
}
return volumeTag, state.VolumeInfo{
v.Info.HardwareId,
v.Info.WWN,
v.Info.Size,
"", // pool is set by state
v.Info.VolumeId,
v.Info.Persistent,
}, nil
}
|
go
|
func VolumeToState(v params.Volume) (names.VolumeTag, state.VolumeInfo, error) {
if v.VolumeTag == "" {
return names.VolumeTag{}, state.VolumeInfo{}, errors.New("Tag is empty")
}
volumeTag, err := names.ParseVolumeTag(v.VolumeTag)
if err != nil {
return names.VolumeTag{}, state.VolumeInfo{}, errors.Trace(err)
}
return volumeTag, state.VolumeInfo{
v.Info.HardwareId,
v.Info.WWN,
v.Info.Size,
"", // pool is set by state
v.Info.VolumeId,
v.Info.Persistent,
}, nil
}
|
[
"func",
"VolumeToState",
"(",
"v",
"params",
".",
"Volume",
")",
"(",
"names",
".",
"VolumeTag",
",",
"state",
".",
"VolumeInfo",
",",
"error",
")",
"{",
"if",
"v",
".",
"VolumeTag",
"==",
"\"",
"\"",
"{",
"return",
"names",
".",
"VolumeTag",
"{",
"}",
",",
"state",
".",
"VolumeInfo",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"volumeTag",
",",
"err",
":=",
"names",
".",
"ParseVolumeTag",
"(",
"v",
".",
"VolumeTag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"names",
".",
"VolumeTag",
"{",
"}",
",",
"state",
".",
"VolumeInfo",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"volumeTag",
",",
"state",
".",
"VolumeInfo",
"{",
"v",
".",
"Info",
".",
"HardwareId",
",",
"v",
".",
"Info",
".",
"WWN",
",",
"v",
".",
"Info",
".",
"Size",
",",
"\"",
"\"",
",",
"// pool is set by state",
"v",
".",
"Info",
".",
"VolumeId",
",",
"v",
".",
"Info",
".",
"Persistent",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// VolumeToState converts a params.Volume to state.VolumeInfo
// and names.VolumeTag.
|
[
"VolumeToState",
"converts",
"a",
"params",
".",
"Volume",
"to",
"state",
".",
"VolumeInfo",
"and",
"names",
".",
"VolumeTag",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L97-L113
|
154,342 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumeFromState
|
func VolumeFromState(v state.Volume) (params.Volume, error) {
info, err := v.Info()
if err != nil {
return params.Volume{}, errors.Trace(err)
}
return params.Volume{
v.VolumeTag().String(),
VolumeInfoFromState(info),
}, nil
}
|
go
|
func VolumeFromState(v state.Volume) (params.Volume, error) {
info, err := v.Info()
if err != nil {
return params.Volume{}, errors.Trace(err)
}
return params.Volume{
v.VolumeTag().String(),
VolumeInfoFromState(info),
}, nil
}
|
[
"func",
"VolumeFromState",
"(",
"v",
"state",
".",
"Volume",
")",
"(",
"params",
".",
"Volume",
",",
"error",
")",
"{",
"info",
",",
"err",
":=",
"v",
".",
"Info",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"Volume",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"params",
".",
"Volume",
"{",
"v",
".",
"VolumeTag",
"(",
")",
".",
"String",
"(",
")",
",",
"VolumeInfoFromState",
"(",
"info",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// VolumeFromState converts a state.Volume to params.Volume.
|
[
"VolumeFromState",
"converts",
"a",
"state",
".",
"Volume",
"to",
"params",
".",
"Volume",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L116-L125
|
154,343 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumeInfoFromState
|
func VolumeInfoFromState(info state.VolumeInfo) params.VolumeInfo {
return params.VolumeInfo{
info.VolumeId,
info.HardwareId,
info.WWN,
info.Pool,
info.Size,
info.Persistent,
}
}
|
go
|
func VolumeInfoFromState(info state.VolumeInfo) params.VolumeInfo {
return params.VolumeInfo{
info.VolumeId,
info.HardwareId,
info.WWN,
info.Pool,
info.Size,
info.Persistent,
}
}
|
[
"func",
"VolumeInfoFromState",
"(",
"info",
"state",
".",
"VolumeInfo",
")",
"params",
".",
"VolumeInfo",
"{",
"return",
"params",
".",
"VolumeInfo",
"{",
"info",
".",
"VolumeId",
",",
"info",
".",
"HardwareId",
",",
"info",
".",
"WWN",
",",
"info",
".",
"Pool",
",",
"info",
".",
"Size",
",",
"info",
".",
"Persistent",
",",
"}",
"\n",
"}"
] |
// VolumeInfoFromState converts a state.VolumeInfo to params.VolumeInfo.
|
[
"VolumeInfoFromState",
"converts",
"a",
"state",
".",
"VolumeInfo",
"to",
"params",
".",
"VolumeInfo",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L128-L137
|
154,344 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumeAttachmentPlanFromState
|
func VolumeAttachmentPlanFromState(v state.VolumeAttachmentPlan) (params.VolumeAttachmentPlan, error) {
planInfo, err := v.PlanInfo()
if err != nil {
return params.VolumeAttachmentPlan{}, errors.Trace(err)
}
blockInfo, err := v.BlockDeviceInfo()
if err != nil {
if !errors.IsNotFound(err) {
return params.VolumeAttachmentPlan{}, errors.Trace(err)
}
}
return params.VolumeAttachmentPlan{
VolumeTag: v.Volume().String(),
MachineTag: v.Machine().String(),
Life: params.Life(v.Life().String()),
PlanInfo: VolumeAttachmentPlanInfoFromState(planInfo),
BlockDevice: VolumeAttachmentPlanBlockInfoFromState(blockInfo),
}, nil
}
|
go
|
func VolumeAttachmentPlanFromState(v state.VolumeAttachmentPlan) (params.VolumeAttachmentPlan, error) {
planInfo, err := v.PlanInfo()
if err != nil {
return params.VolumeAttachmentPlan{}, errors.Trace(err)
}
blockInfo, err := v.BlockDeviceInfo()
if err != nil {
if !errors.IsNotFound(err) {
return params.VolumeAttachmentPlan{}, errors.Trace(err)
}
}
return params.VolumeAttachmentPlan{
VolumeTag: v.Volume().String(),
MachineTag: v.Machine().String(),
Life: params.Life(v.Life().String()),
PlanInfo: VolumeAttachmentPlanInfoFromState(planInfo),
BlockDevice: VolumeAttachmentPlanBlockInfoFromState(blockInfo),
}, nil
}
|
[
"func",
"VolumeAttachmentPlanFromState",
"(",
"v",
"state",
".",
"VolumeAttachmentPlan",
")",
"(",
"params",
".",
"VolumeAttachmentPlan",
",",
"error",
")",
"{",
"planInfo",
",",
"err",
":=",
"v",
".",
"PlanInfo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"VolumeAttachmentPlan",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"blockInfo",
",",
"err",
":=",
"v",
".",
"BlockDeviceInfo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"errors",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"params",
".",
"VolumeAttachmentPlan",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"params",
".",
"VolumeAttachmentPlan",
"{",
"VolumeTag",
":",
"v",
".",
"Volume",
"(",
")",
".",
"String",
"(",
")",
",",
"MachineTag",
":",
"v",
".",
"Machine",
"(",
")",
".",
"String",
"(",
")",
",",
"Life",
":",
"params",
".",
"Life",
"(",
"v",
".",
"Life",
"(",
")",
".",
"String",
"(",
")",
")",
",",
"PlanInfo",
":",
"VolumeAttachmentPlanInfoFromState",
"(",
"planInfo",
")",
",",
"BlockDevice",
":",
"VolumeAttachmentPlanBlockInfoFromState",
"(",
"blockInfo",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// VolumeAttachmentPlanFromState converts a state.VolumeAttachmentPlan to params.VolumeAttachmentPlan.
|
[
"VolumeAttachmentPlanFromState",
"converts",
"a",
"state",
".",
"VolumeAttachmentPlan",
"to",
"params",
".",
"VolumeAttachmentPlan",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L140-L159
|
154,345 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumeAttachmentFromState
|
func VolumeAttachmentFromState(v state.VolumeAttachment) (params.VolumeAttachment, error) {
info, err := v.Info()
if err != nil {
return params.VolumeAttachment{}, errors.Trace(err)
}
return params.VolumeAttachment{
v.Volume().String(),
v.Host().String(),
VolumeAttachmentInfoFromState(info),
}, nil
}
|
go
|
func VolumeAttachmentFromState(v state.VolumeAttachment) (params.VolumeAttachment, error) {
info, err := v.Info()
if err != nil {
return params.VolumeAttachment{}, errors.Trace(err)
}
return params.VolumeAttachment{
v.Volume().String(),
v.Host().String(),
VolumeAttachmentInfoFromState(info),
}, nil
}
|
[
"func",
"VolumeAttachmentFromState",
"(",
"v",
"state",
".",
"VolumeAttachment",
")",
"(",
"params",
".",
"VolumeAttachment",
",",
"error",
")",
"{",
"info",
",",
"err",
":=",
"v",
".",
"Info",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"VolumeAttachment",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"params",
".",
"VolumeAttachment",
"{",
"v",
".",
"Volume",
"(",
")",
".",
"String",
"(",
")",
",",
"v",
".",
"Host",
"(",
")",
".",
"String",
"(",
")",
",",
"VolumeAttachmentInfoFromState",
"(",
"info",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// VolumeAttachmentFromState converts a state.VolumeAttachment to params.VolumeAttachment.
|
[
"VolumeAttachmentFromState",
"converts",
"a",
"state",
".",
"VolumeAttachment",
"to",
"params",
".",
"VolumeAttachment",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L185-L195
|
154,346 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumeAttachmentInfoFromState
|
func VolumeAttachmentInfoFromState(info state.VolumeAttachmentInfo) params.VolumeAttachmentInfo {
planInfo := ¶ms.VolumeAttachmentPlanInfo{}
if info.PlanInfo != nil {
planInfo.DeviceType = info.PlanInfo.DeviceType
planInfo.DeviceAttributes = info.PlanInfo.DeviceAttributes
} else {
planInfo = nil
}
return params.VolumeAttachmentInfo{
info.DeviceName,
info.DeviceLink,
info.BusAddress,
info.ReadOnly,
planInfo,
}
}
|
go
|
func VolumeAttachmentInfoFromState(info state.VolumeAttachmentInfo) params.VolumeAttachmentInfo {
planInfo := ¶ms.VolumeAttachmentPlanInfo{}
if info.PlanInfo != nil {
planInfo.DeviceType = info.PlanInfo.DeviceType
planInfo.DeviceAttributes = info.PlanInfo.DeviceAttributes
} else {
planInfo = nil
}
return params.VolumeAttachmentInfo{
info.DeviceName,
info.DeviceLink,
info.BusAddress,
info.ReadOnly,
planInfo,
}
}
|
[
"func",
"VolumeAttachmentInfoFromState",
"(",
"info",
"state",
".",
"VolumeAttachmentInfo",
")",
"params",
".",
"VolumeAttachmentInfo",
"{",
"planInfo",
":=",
"&",
"params",
".",
"VolumeAttachmentPlanInfo",
"{",
"}",
"\n",
"if",
"info",
".",
"PlanInfo",
"!=",
"nil",
"{",
"planInfo",
".",
"DeviceType",
"=",
"info",
".",
"PlanInfo",
".",
"DeviceType",
"\n",
"planInfo",
".",
"DeviceAttributes",
"=",
"info",
".",
"PlanInfo",
".",
"DeviceAttributes",
"\n",
"}",
"else",
"{",
"planInfo",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"params",
".",
"VolumeAttachmentInfo",
"{",
"info",
".",
"DeviceName",
",",
"info",
".",
"DeviceLink",
",",
"info",
".",
"BusAddress",
",",
"info",
".",
"ReadOnly",
",",
"planInfo",
",",
"}",
"\n",
"}"
] |
// VolumeAttachmentInfoFromState converts a state.VolumeAttachmentInfo to params.VolumeAttachmentInfo.
|
[
"VolumeAttachmentInfoFromState",
"converts",
"a",
"state",
".",
"VolumeAttachmentInfo",
"to",
"params",
".",
"VolumeAttachmentInfo",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L198-L213
|
154,347 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumeAttachmentInfosToState
|
func VolumeAttachmentInfosToState(in map[string]params.VolumeAttachmentInfo) (map[names.VolumeTag]state.VolumeAttachmentInfo, error) {
m := make(map[names.VolumeTag]state.VolumeAttachmentInfo)
for k, v := range in {
volumeTag, err := names.ParseVolumeTag(k)
if err != nil {
return nil, errors.Trace(err)
}
m[volumeTag] = VolumeAttachmentInfoToState(v)
}
return m, nil
}
|
go
|
func VolumeAttachmentInfosToState(in map[string]params.VolumeAttachmentInfo) (map[names.VolumeTag]state.VolumeAttachmentInfo, error) {
m := make(map[names.VolumeTag]state.VolumeAttachmentInfo)
for k, v := range in {
volumeTag, err := names.ParseVolumeTag(k)
if err != nil {
return nil, errors.Trace(err)
}
m[volumeTag] = VolumeAttachmentInfoToState(v)
}
return m, nil
}
|
[
"func",
"VolumeAttachmentInfosToState",
"(",
"in",
"map",
"[",
"string",
"]",
"params",
".",
"VolumeAttachmentInfo",
")",
"(",
"map",
"[",
"names",
".",
"VolumeTag",
"]",
"state",
".",
"VolumeAttachmentInfo",
",",
"error",
")",
"{",
"m",
":=",
"make",
"(",
"map",
"[",
"names",
".",
"VolumeTag",
"]",
"state",
".",
"VolumeAttachmentInfo",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"in",
"{",
"volumeTag",
",",
"err",
":=",
"names",
".",
"ParseVolumeTag",
"(",
"k",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"m",
"[",
"volumeTag",
"]",
"=",
"VolumeAttachmentInfoToState",
"(",
"v",
")",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// VolumeAttachmentInfosToState converts a map of volume tags to
// params.VolumeAttachmentInfo to a map of volume tags to
// state.VolumeAttachmentInfo.
|
[
"VolumeAttachmentInfosToState",
"converts",
"a",
"map",
"of",
"volume",
"tags",
"to",
"params",
".",
"VolumeAttachmentInfo",
"to",
"a",
"map",
"of",
"volume",
"tags",
"to",
"state",
".",
"VolumeAttachmentInfo",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L218-L228
|
154,348 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumeAttachmentToState
|
func VolumeAttachmentToState(in params.VolumeAttachment) (names.MachineTag, names.VolumeTag, state.VolumeAttachmentInfo, error) {
machineTag, err := names.ParseMachineTag(in.MachineTag)
if err != nil {
return names.MachineTag{}, names.VolumeTag{}, state.VolumeAttachmentInfo{}, err
}
volumeTag, err := names.ParseVolumeTag(in.VolumeTag)
if err != nil {
return names.MachineTag{}, names.VolumeTag{}, state.VolumeAttachmentInfo{}, err
}
info := VolumeAttachmentInfoToState(in.Info)
return machineTag, volumeTag, info, nil
}
|
go
|
func VolumeAttachmentToState(in params.VolumeAttachment) (names.MachineTag, names.VolumeTag, state.VolumeAttachmentInfo, error) {
machineTag, err := names.ParseMachineTag(in.MachineTag)
if err != nil {
return names.MachineTag{}, names.VolumeTag{}, state.VolumeAttachmentInfo{}, err
}
volumeTag, err := names.ParseVolumeTag(in.VolumeTag)
if err != nil {
return names.MachineTag{}, names.VolumeTag{}, state.VolumeAttachmentInfo{}, err
}
info := VolumeAttachmentInfoToState(in.Info)
return machineTag, volumeTag, info, nil
}
|
[
"func",
"VolumeAttachmentToState",
"(",
"in",
"params",
".",
"VolumeAttachment",
")",
"(",
"names",
".",
"MachineTag",
",",
"names",
".",
"VolumeTag",
",",
"state",
".",
"VolumeAttachmentInfo",
",",
"error",
")",
"{",
"machineTag",
",",
"err",
":=",
"names",
".",
"ParseMachineTag",
"(",
"in",
".",
"MachineTag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"names",
".",
"MachineTag",
"{",
"}",
",",
"names",
".",
"VolumeTag",
"{",
"}",
",",
"state",
".",
"VolumeAttachmentInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"volumeTag",
",",
"err",
":=",
"names",
".",
"ParseVolumeTag",
"(",
"in",
".",
"VolumeTag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"names",
".",
"MachineTag",
"{",
"}",
",",
"names",
".",
"VolumeTag",
"{",
"}",
",",
"state",
".",
"VolumeAttachmentInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"info",
":=",
"VolumeAttachmentInfoToState",
"(",
"in",
".",
"Info",
")",
"\n",
"return",
"machineTag",
",",
"volumeTag",
",",
"info",
",",
"nil",
"\n",
"}"
] |
// VolumeAttachmentToState converts a params.VolumeAttachment
// to a state.VolumeAttachmentInfo and tags.
|
[
"VolumeAttachmentToState",
"converts",
"a",
"params",
".",
"VolumeAttachment",
"to",
"a",
"state",
".",
"VolumeAttachmentInfo",
"and",
"tags",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L262-L273
|
154,349 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
VolumeAttachmentInfoToState
|
func VolumeAttachmentInfoToState(in params.VolumeAttachmentInfo) state.VolumeAttachmentInfo {
planInfo := &state.VolumeAttachmentPlanInfo{}
if in.PlanInfo != nil {
planInfo.DeviceAttributes = in.PlanInfo.DeviceAttributes
planInfo.DeviceType = in.PlanInfo.DeviceType
} else {
planInfo = nil
}
return state.VolumeAttachmentInfo{
in.DeviceName,
in.DeviceLink,
in.BusAddress,
in.ReadOnly,
planInfo,
}
}
|
go
|
func VolumeAttachmentInfoToState(in params.VolumeAttachmentInfo) state.VolumeAttachmentInfo {
planInfo := &state.VolumeAttachmentPlanInfo{}
if in.PlanInfo != nil {
planInfo.DeviceAttributes = in.PlanInfo.DeviceAttributes
planInfo.DeviceType = in.PlanInfo.DeviceType
} else {
planInfo = nil
}
return state.VolumeAttachmentInfo{
in.DeviceName,
in.DeviceLink,
in.BusAddress,
in.ReadOnly,
planInfo,
}
}
|
[
"func",
"VolumeAttachmentInfoToState",
"(",
"in",
"params",
".",
"VolumeAttachmentInfo",
")",
"state",
".",
"VolumeAttachmentInfo",
"{",
"planInfo",
":=",
"&",
"state",
".",
"VolumeAttachmentPlanInfo",
"{",
"}",
"\n",
"if",
"in",
".",
"PlanInfo",
"!=",
"nil",
"{",
"planInfo",
".",
"DeviceAttributes",
"=",
"in",
".",
"PlanInfo",
".",
"DeviceAttributes",
"\n",
"planInfo",
".",
"DeviceType",
"=",
"in",
".",
"PlanInfo",
".",
"DeviceType",
"\n",
"}",
"else",
"{",
"planInfo",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"state",
".",
"VolumeAttachmentInfo",
"{",
"in",
".",
"DeviceName",
",",
"in",
".",
"DeviceLink",
",",
"in",
".",
"BusAddress",
",",
"in",
".",
"ReadOnly",
",",
"planInfo",
",",
"}",
"\n",
"}"
] |
// VolumeAttachmentInfoToState converts a params.VolumeAttachmentInfo
// to a state.VolumeAttachmentInfo.
|
[
"VolumeAttachmentInfoToState",
"converts",
"a",
"params",
".",
"VolumeAttachmentInfo",
"to",
"a",
"state",
".",
"VolumeAttachmentInfo",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L289-L304
|
154,350 |
juju/juju
|
apiserver/common/storagecommon/volumes.go
|
ParseVolumeAttachmentIds
|
func ParseVolumeAttachmentIds(stringIds []string) ([]params.MachineStorageId, error) {
ids := make([]params.MachineStorageId, len(stringIds))
for i, s := range stringIds {
m, v, err := state.ParseVolumeAttachmentId(s)
if err != nil {
return nil, err
}
ids[i] = params.MachineStorageId{
MachineTag: m.String(),
AttachmentTag: v.String(),
}
}
return ids, nil
}
|
go
|
func ParseVolumeAttachmentIds(stringIds []string) ([]params.MachineStorageId, error) {
ids := make([]params.MachineStorageId, len(stringIds))
for i, s := range stringIds {
m, v, err := state.ParseVolumeAttachmentId(s)
if err != nil {
return nil, err
}
ids[i] = params.MachineStorageId{
MachineTag: m.String(),
AttachmentTag: v.String(),
}
}
return ids, nil
}
|
[
"func",
"ParseVolumeAttachmentIds",
"(",
"stringIds",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"params",
".",
"MachineStorageId",
",",
"error",
")",
"{",
"ids",
":=",
"make",
"(",
"[",
"]",
"params",
".",
"MachineStorageId",
",",
"len",
"(",
"stringIds",
")",
")",
"\n",
"for",
"i",
",",
"s",
":=",
"range",
"stringIds",
"{",
"m",
",",
"v",
",",
"err",
":=",
"state",
".",
"ParseVolumeAttachmentId",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ids",
"[",
"i",
"]",
"=",
"params",
".",
"MachineStorageId",
"{",
"MachineTag",
":",
"m",
".",
"String",
"(",
")",
",",
"AttachmentTag",
":",
"v",
".",
"String",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"ids",
",",
"nil",
"\n",
"}"
] |
// ParseVolumeAttachmentIds parses the strings, returning machine storage IDs.
|
[
"ParseVolumeAttachmentIds",
"parses",
"the",
"strings",
"returning",
"machine",
"storage",
"IDs",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/storagecommon/volumes.go#L307-L320
|
154,351 |
juju/juju
|
upgrades/steps_222.go
|
stateStepsFor222
|
func stateStepsFor222() []Step {
return []Step{
&upgradeStep{
description: "add environ-version to model docs",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().AddModelEnvironVersion()
},
},
}
}
|
go
|
func stateStepsFor222() []Step {
return []Step{
&upgradeStep{
description: "add environ-version to model docs",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().AddModelEnvironVersion()
},
},
}
}
|
[
"func",
"stateStepsFor222",
"(",
")",
"[",
"]",
"Step",
"{",
"return",
"[",
"]",
"Step",
"{",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"DatabaseMaster",
"}",
",",
"run",
":",
"func",
"(",
"context",
"Context",
")",
"error",
"{",
"return",
"context",
".",
"State",
"(",
")",
".",
"AddModelEnvironVersion",
"(",
")",
"\n",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] |
// stateStepsFor222 returns upgrade steps for Juju 2.2.2 that manipulate state directly.
|
[
"stateStepsFor222",
"returns",
"upgrade",
"steps",
"for",
"Juju",
"2",
".",
"2",
".",
"2",
"that",
"manipulate",
"state",
"directly",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/upgrades/steps_222.go#L7-L17
|
154,352 |
juju/juju
|
provider/vsphere/environ_network.go
|
OpenPorts
|
func (*environ) OpenPorts(rules []network.IngressRule) error {
return errors.Trace(errors.NotSupportedf("ClosePorts"))
}
|
go
|
func (*environ) OpenPorts(rules []network.IngressRule) error {
return errors.Trace(errors.NotSupportedf("ClosePorts"))
}
|
[
"func",
"(",
"*",
"environ",
")",
"OpenPorts",
"(",
"rules",
"[",
"]",
"network",
".",
"IngressRule",
")",
"error",
"{",
"return",
"errors",
".",
"Trace",
"(",
"errors",
".",
"NotSupportedf",
"(",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// OpenPorts is part of the environs.Firewaller interface.
|
[
"OpenPorts",
"is",
"part",
"of",
"the",
"environs",
".",
"Firewaller",
"interface",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/vsphere/environ_network.go#L13-L15
|
154,353 |
juju/juju
|
provider/vsphere/environ_network.go
|
IngressRules
|
func (*environ) IngressRules() ([]network.IngressRule, error) {
return nil, errors.Trace(errors.NotSupportedf("Ports"))
}
|
go
|
func (*environ) IngressRules() ([]network.IngressRule, error) {
return nil, errors.Trace(errors.NotSupportedf("Ports"))
}
|
[
"func",
"(",
"*",
"environ",
")",
"IngressRules",
"(",
")",
"(",
"[",
"]",
"network",
".",
"IngressRule",
",",
"error",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"errors",
".",
"NotSupportedf",
"(",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// IngressPorts is part of the environs.Firewaller interface.
|
[
"IngressPorts",
"is",
"part",
"of",
"the",
"environs",
".",
"Firewaller",
"interface",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/vsphere/environ_network.go#L23-L25
|
154,354 |
juju/juju
|
state/life_ns.go
|
destroyOp
|
func (nsLife_) destroyOp(entities mongo.Collection, docID string, update bson.D) (txn.Op, error) {
op, err := nsLife.aliveOp(entities, docID)
if err != nil {
return txn.Op{}, errors.Trace(err)
}
setDying := bson.D{{"$set", bson.D{{"life", Dying}}}}
op.Update = append(setDying, update...)
return op, nil
}
|
go
|
func (nsLife_) destroyOp(entities mongo.Collection, docID string, update bson.D) (txn.Op, error) {
op, err := nsLife.aliveOp(entities, docID)
if err != nil {
return txn.Op{}, errors.Trace(err)
}
setDying := bson.D{{"$set", bson.D{{"life", Dying}}}}
op.Update = append(setDying, update...)
return op, nil
}
|
[
"func",
"(",
"nsLife_",
")",
"destroyOp",
"(",
"entities",
"mongo",
".",
"Collection",
",",
"docID",
"string",
",",
"update",
"bson",
".",
"D",
")",
"(",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"op",
",",
"err",
":=",
"nsLife",
".",
"aliveOp",
"(",
"entities",
",",
"docID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"setDying",
":=",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"Dying",
"}",
"}",
"}",
"}",
"\n",
"op",
".",
"Update",
"=",
"append",
"(",
"setDying",
",",
"update",
"...",
")",
"\n",
"return",
"op",
",",
"nil",
"\n",
"}"
] |
// destroyOp returns errNotAlive if the identified entity is not Alive;
// or a txn.Op that will fail if the condition no longer holds, and
// otherwise set Life to Dying and make any other updates supplied in
// update.
|
[
"destroyOp",
"returns",
"errNotAlive",
"if",
"the",
"identified",
"entity",
"is",
"not",
"Alive",
";",
"or",
"a",
"txn",
".",
"Op",
"that",
"will",
"fail",
"if",
"the",
"condition",
"no",
"longer",
"holds",
"and",
"otherwise",
"set",
"Life",
"to",
"Dying",
"and",
"make",
"any",
"other",
"updates",
"supplied",
"in",
"update",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/life_ns.go#L31-L39
|
154,355 |
juju/juju
|
state/life_ns.go
|
dieOp
|
func (nsLife_) dieOp(entities mongo.Collection, docID string, update bson.D) (txn.Op, error) {
life, err := nsLife.read(entities, docID)
if errors.IsNotFound(err) {
return txn.Op{}, errAlreadyDead
} else if err != nil {
return txn.Op{}, errors.Trace(err)
}
switch life {
case Alive:
return txn.Op{}, errNotDying
case Dead:
return txn.Op{}, errAlreadyDead
}
setDead := bson.D{{"$set", bson.D{{"life", Dead}}}}
return txn.Op{
C: entities.Name(),
Id: docID,
Assert: nsLife.dying(),
Update: append(setDead, update...),
}, nil
}
|
go
|
func (nsLife_) dieOp(entities mongo.Collection, docID string, update bson.D) (txn.Op, error) {
life, err := nsLife.read(entities, docID)
if errors.IsNotFound(err) {
return txn.Op{}, errAlreadyDead
} else if err != nil {
return txn.Op{}, errors.Trace(err)
}
switch life {
case Alive:
return txn.Op{}, errNotDying
case Dead:
return txn.Op{}, errAlreadyDead
}
setDead := bson.D{{"$set", bson.D{{"life", Dead}}}}
return txn.Op{
C: entities.Name(),
Id: docID,
Assert: nsLife.dying(),
Update: append(setDead, update...),
}, nil
}
|
[
"func",
"(",
"nsLife_",
")",
"dieOp",
"(",
"entities",
"mongo",
".",
"Collection",
",",
"docID",
"string",
",",
"update",
"bson",
".",
"D",
")",
"(",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"life",
",",
"err",
":=",
"nsLife",
".",
"read",
"(",
"entities",
",",
"docID",
")",
"\n",
"if",
"errors",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"errAlreadyDead",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"life",
"{",
"case",
"Alive",
":",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"errNotDying",
"\n",
"case",
"Dead",
":",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"errAlreadyDead",
"\n",
"}",
"\n",
"setDead",
":=",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"Dead",
"}",
"}",
"}",
"}",
"\n",
"return",
"txn",
".",
"Op",
"{",
"C",
":",
"entities",
".",
"Name",
"(",
")",
",",
"Id",
":",
"docID",
",",
"Assert",
":",
"nsLife",
".",
"dying",
"(",
")",
",",
"Update",
":",
"append",
"(",
"setDead",
",",
"update",
"...",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// dieOp returns errNotDying if the identified entity is Alive, or
// errAlreadyDead if the entity is Dead or gone; or a txn.Op that will
// fail if the condition no longer holds, and otherwise set Life to
// Dead, and make any other updates supplied in update.
|
[
"dieOp",
"returns",
"errNotDying",
"if",
"the",
"identified",
"entity",
"is",
"Alive",
"or",
"errAlreadyDead",
"if",
"the",
"entity",
"is",
"Dead",
"or",
"gone",
";",
"or",
"a",
"txn",
".",
"Op",
"that",
"will",
"fail",
"if",
"the",
"condition",
"no",
"longer",
"holds",
"and",
"otherwise",
"set",
"Life",
"to",
"Dead",
"and",
"make",
"any",
"other",
"updates",
"supplied",
"in",
"update",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/life_ns.go#L45-L65
|
154,356 |
juju/juju
|
state/life_ns.go
|
aliveOp
|
func (nsLife_) aliveOp(entities mongo.Collection, docID string) (txn.Op, error) {
op, err := nsLife.checkOp(entities, docID, nsLife.alive())
switch errors.Cause(err) {
case nil:
case errCheckFailed:
return txn.Op{}, notAliveErr
default:
return txn.Op{}, errors.Trace(err)
}
return op, nil
}
|
go
|
func (nsLife_) aliveOp(entities mongo.Collection, docID string) (txn.Op, error) {
op, err := nsLife.checkOp(entities, docID, nsLife.alive())
switch errors.Cause(err) {
case nil:
case errCheckFailed:
return txn.Op{}, notAliveErr
default:
return txn.Op{}, errors.Trace(err)
}
return op, nil
}
|
[
"func",
"(",
"nsLife_",
")",
"aliveOp",
"(",
"entities",
"mongo",
".",
"Collection",
",",
"docID",
"string",
")",
"(",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"op",
",",
"err",
":=",
"nsLife",
".",
"checkOp",
"(",
"entities",
",",
"docID",
",",
"nsLife",
".",
"alive",
"(",
")",
")",
"\n",
"switch",
"errors",
".",
"Cause",
"(",
"err",
")",
"{",
"case",
"nil",
":",
"case",
"errCheckFailed",
":",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"notAliveErr",
"\n",
"default",
":",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"op",
",",
"nil",
"\n",
"}"
] |
// aliveOp returns errNotAlive if the identified entity is not Alive; or
// a txn.Op that will fail if the condition no longer holds.
|
[
"aliveOp",
"returns",
"errNotAlive",
"if",
"the",
"identified",
"entity",
"is",
"not",
"Alive",
";",
"or",
"a",
"txn",
".",
"Op",
"that",
"will",
"fail",
"if",
"the",
"condition",
"no",
"longer",
"holds",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/life_ns.go#L69-L79
|
154,357 |
juju/juju
|
state/life_ns.go
|
dyingOp
|
func (nsLife_) dyingOp(entities mongo.Collection, docID string) (txn.Op, error) {
op, err := nsLife.checkOp(entities, docID, nsLife.dying())
switch errors.Cause(err) {
case nil:
case errCheckFailed:
return txn.Op{}, errNotDying
default:
return txn.Op{}, errors.Trace(err)
}
return op, nil
}
|
go
|
func (nsLife_) dyingOp(entities mongo.Collection, docID string) (txn.Op, error) {
op, err := nsLife.checkOp(entities, docID, nsLife.dying())
switch errors.Cause(err) {
case nil:
case errCheckFailed:
return txn.Op{}, errNotDying
default:
return txn.Op{}, errors.Trace(err)
}
return op, nil
}
|
[
"func",
"(",
"nsLife_",
")",
"dyingOp",
"(",
"entities",
"mongo",
".",
"Collection",
",",
"docID",
"string",
")",
"(",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"op",
",",
"err",
":=",
"nsLife",
".",
"checkOp",
"(",
"entities",
",",
"docID",
",",
"nsLife",
".",
"dying",
"(",
")",
")",
"\n",
"switch",
"errors",
".",
"Cause",
"(",
"err",
")",
"{",
"case",
"nil",
":",
"case",
"errCheckFailed",
":",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"errNotDying",
"\n",
"default",
":",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"op",
",",
"nil",
"\n",
"}"
] |
// dyingOp returns errNotDying if the identified entity is not Dying; or
// a txn.Op that will fail if the condition no longer holds.
|
[
"dyingOp",
"returns",
"errNotDying",
"if",
"the",
"identified",
"entity",
"is",
"not",
"Dying",
";",
"or",
"a",
"txn",
".",
"Op",
"that",
"will",
"fail",
"if",
"the",
"condition",
"no",
"longer",
"holds",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/life_ns.go#L83-L93
|
154,358 |
juju/juju
|
state/life_ns.go
|
notDeadOp
|
func (nsLife_) notDeadOp(entities mongo.Collection, docID string) (txn.Op, error) {
op, err := nsLife.checkOp(entities, docID, nsLife.notDead())
switch errors.Cause(err) {
case nil:
case errCheckFailed:
return txn.Op{}, errDeadOrGone
default:
return txn.Op{}, errors.Trace(err)
}
return op, nil
}
|
go
|
func (nsLife_) notDeadOp(entities mongo.Collection, docID string) (txn.Op, error) {
op, err := nsLife.checkOp(entities, docID, nsLife.notDead())
switch errors.Cause(err) {
case nil:
case errCheckFailed:
return txn.Op{}, errDeadOrGone
default:
return txn.Op{}, errors.Trace(err)
}
return op, nil
}
|
[
"func",
"(",
"nsLife_",
")",
"notDeadOp",
"(",
"entities",
"mongo",
".",
"Collection",
",",
"docID",
"string",
")",
"(",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"op",
",",
"err",
":=",
"nsLife",
".",
"checkOp",
"(",
"entities",
",",
"docID",
",",
"nsLife",
".",
"notDead",
"(",
")",
")",
"\n",
"switch",
"errors",
".",
"Cause",
"(",
"err",
")",
"{",
"case",
"nil",
":",
"case",
"errCheckFailed",
":",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"errDeadOrGone",
"\n",
"default",
":",
"return",
"txn",
".",
"Op",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"op",
",",
"nil",
"\n",
"}"
] |
// notDeadOp returns errDeadOrGone if the identified entity is not Alive
// or Dying, or a txn.Op that will fail if the condition no longer
// holds.
|
[
"notDeadOp",
"returns",
"errDeadOrGone",
"if",
"the",
"identified",
"entity",
"is",
"not",
"Alive",
"or",
"Dying",
"or",
"a",
"txn",
".",
"Op",
"that",
"will",
"fail",
"if",
"the",
"condition",
"no",
"longer",
"holds",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/life_ns.go#L98-L108
|
154,359 |
juju/juju
|
upgrades/steps_20.go
|
stateStepsFor20
|
func stateStepsFor20() []Step {
return []Step{
&upgradeStep{
description: "strip @local from local user names",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().StripLocalUserDomain()
},
},
&upgradeStep{
description: "rename addmodel permission to add-model",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().RenameAddModelPermission()
},
},
}
}
|
go
|
func stateStepsFor20() []Step {
return []Step{
&upgradeStep{
description: "strip @local from local user names",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().StripLocalUserDomain()
},
},
&upgradeStep{
description: "rename addmodel permission to add-model",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().RenameAddModelPermission()
},
},
}
}
|
[
"func",
"stateStepsFor20",
"(",
")",
"[",
"]",
"Step",
"{",
"return",
"[",
"]",
"Step",
"{",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"DatabaseMaster",
"}",
",",
"run",
":",
"func",
"(",
"context",
"Context",
")",
"error",
"{",
"return",
"context",
".",
"State",
"(",
")",
".",
"StripLocalUserDomain",
"(",
")",
"\n",
"}",
",",
"}",
",",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"DatabaseMaster",
"}",
",",
"run",
":",
"func",
"(",
"context",
"Context",
")",
"error",
"{",
"return",
"context",
".",
"State",
"(",
")",
".",
"RenameAddModelPermission",
"(",
")",
"\n",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] |
// stateStepsFor20 returns upgrade steps for Juju 2.0 that manipulate state directly.
|
[
"stateStepsFor20",
"returns",
"upgrade",
"steps",
"for",
"Juju",
"2",
".",
"0",
"that",
"manipulate",
"state",
"directly",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/upgrades/steps_20.go#L12-L29
|
154,360 |
juju/juju
|
upgrades/steps_20.go
|
stepsFor20
|
func stepsFor20() []Step {
return []Step{
&upgradeStep{
description: "remove apiserver charm get cache",
targets: []Target{Controller},
run: removeCharmGetCache,
},
}
}
|
go
|
func stepsFor20() []Step {
return []Step{
&upgradeStep{
description: "remove apiserver charm get cache",
targets: []Target{Controller},
run: removeCharmGetCache,
},
}
}
|
[
"func",
"stepsFor20",
"(",
")",
"[",
"]",
"Step",
"{",
"return",
"[",
"]",
"Step",
"{",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"Controller",
"}",
",",
"run",
":",
"removeCharmGetCache",
",",
"}",
",",
"}",
"\n",
"}"
] |
// stepsFor20 returns upgrade steps for Juju 2.0 that only need the API.
|
[
"stepsFor20",
"returns",
"upgrade",
"steps",
"for",
"Juju",
"2",
".",
"0",
"that",
"only",
"need",
"the",
"API",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/upgrades/steps_20.go#L32-L40
|
154,361 |
juju/juju
|
upgrades/steps_20.go
|
removeCharmGetCache
|
func removeCharmGetCache(context Context) error {
dataDir := context.AgentConfig().DataDir()
cacheDir := filepath.Join(dataDir, "charm-get-cache")
return os.RemoveAll(cacheDir)
}
|
go
|
func removeCharmGetCache(context Context) error {
dataDir := context.AgentConfig().DataDir()
cacheDir := filepath.Join(dataDir, "charm-get-cache")
return os.RemoveAll(cacheDir)
}
|
[
"func",
"removeCharmGetCache",
"(",
"context",
"Context",
")",
"error",
"{",
"dataDir",
":=",
"context",
".",
"AgentConfig",
"(",
")",
".",
"DataDir",
"(",
")",
"\n",
"cacheDir",
":=",
"filepath",
".",
"Join",
"(",
"dataDir",
",",
"\"",
"\"",
")",
"\n",
"return",
"os",
".",
"RemoveAll",
"(",
"cacheDir",
")",
"\n",
"}"
] |
// removeCharmGetCache removes the cache directory that was previously
// used by the charms API endpoint. It is no longer necessary.
|
[
"removeCharmGetCache",
"removes",
"the",
"cache",
"directory",
"that",
"was",
"previously",
"used",
"by",
"the",
"charms",
"API",
"endpoint",
".",
"It",
"is",
"no",
"longer",
"necessary",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/upgrades/steps_20.go#L44-L48
|
154,362 |
juju/juju
|
state/cloudcredentials.go
|
CloudCredential
|
func (st *State) CloudCredential(tag names.CloudCredentialTag) (Credential, error) {
coll, cleanup := st.db().GetCollection(cloudCredentialsC)
defer cleanup()
var doc cloudCredentialDoc
err := coll.FindId(cloudCredentialDocID(tag)).One(&doc)
if err == mgo.ErrNotFound {
return Credential{}, errors.NotFoundf(
"cloud credential %q", tag.Id(),
)
} else if err != nil {
return Credential{}, errors.Annotatef(
err, "getting cloud credential %q", tag.Id(),
)
}
return Credential{doc}, nil
}
|
go
|
func (st *State) CloudCredential(tag names.CloudCredentialTag) (Credential, error) {
coll, cleanup := st.db().GetCollection(cloudCredentialsC)
defer cleanup()
var doc cloudCredentialDoc
err := coll.FindId(cloudCredentialDocID(tag)).One(&doc)
if err == mgo.ErrNotFound {
return Credential{}, errors.NotFoundf(
"cloud credential %q", tag.Id(),
)
} else if err != nil {
return Credential{}, errors.Annotatef(
err, "getting cloud credential %q", tag.Id(),
)
}
return Credential{doc}, nil
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"CloudCredential",
"(",
"tag",
"names",
".",
"CloudCredentialTag",
")",
"(",
"Credential",
",",
"error",
")",
"{",
"coll",
",",
"cleanup",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"cloudCredentialsC",
")",
"\n",
"defer",
"cleanup",
"(",
")",
"\n\n",
"var",
"doc",
"cloudCredentialDoc",
"\n",
"err",
":=",
"coll",
".",
"FindId",
"(",
"cloudCredentialDocID",
"(",
"tag",
")",
")",
".",
"One",
"(",
"&",
"doc",
")",
"\n",
"if",
"err",
"==",
"mgo",
".",
"ErrNotFound",
"{",
"return",
"Credential",
"{",
"}",
",",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Id",
"(",
")",
",",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Credential",
"{",
"}",
",",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"tag",
".",
"Id",
"(",
")",
",",
")",
"\n",
"}",
"\n",
"return",
"Credential",
"{",
"doc",
"}",
",",
"nil",
"\n",
"}"
] |
// CloudCredential returns the cloud credential for the given tag.
|
[
"CloudCredential",
"returns",
"the",
"cloud",
"credential",
"for",
"the",
"given",
"tag",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L65-L81
|
154,363 |
juju/juju
|
state/cloudcredentials.go
|
CloudCredentials
|
func (st *State) CloudCredentials(user names.UserTag, cloudName string) (map[string]Credential, error) {
coll, cleanup := st.db().GetCollection(cloudCredentialsC)
defer cleanup()
credentials := make(map[string]Credential)
iter := coll.Find(bson.D{
{"owner", user.Id()},
{"cloud", cloudName},
}).Iter()
defer iter.Close()
var doc cloudCredentialDoc
for iter.Next(&doc) {
tag, err := doc.cloudCredentialTag()
if err != nil {
return nil, errors.Trace(err)
}
credentials[tag.Id()] = Credential{doc}
}
if err := iter.Close(); err != nil {
return nil, errors.Annotatef(
err, "cannot get cloud credentials for user %q, cloud %q",
user.Id(), cloudName,
)
}
return credentials, nil
}
|
go
|
func (st *State) CloudCredentials(user names.UserTag, cloudName string) (map[string]Credential, error) {
coll, cleanup := st.db().GetCollection(cloudCredentialsC)
defer cleanup()
credentials := make(map[string]Credential)
iter := coll.Find(bson.D{
{"owner", user.Id()},
{"cloud", cloudName},
}).Iter()
defer iter.Close()
var doc cloudCredentialDoc
for iter.Next(&doc) {
tag, err := doc.cloudCredentialTag()
if err != nil {
return nil, errors.Trace(err)
}
credentials[tag.Id()] = Credential{doc}
}
if err := iter.Close(); err != nil {
return nil, errors.Annotatef(
err, "cannot get cloud credentials for user %q, cloud %q",
user.Id(), cloudName,
)
}
return credentials, nil
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"CloudCredentials",
"(",
"user",
"names",
".",
"UserTag",
",",
"cloudName",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"Credential",
",",
"error",
")",
"{",
"coll",
",",
"cleanup",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"cloudCredentialsC",
")",
"\n",
"defer",
"cleanup",
"(",
")",
"\n\n",
"credentials",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"Credential",
")",
"\n",
"iter",
":=",
"coll",
".",
"Find",
"(",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"user",
".",
"Id",
"(",
")",
"}",
",",
"{",
"\"",
"\"",
",",
"cloudName",
"}",
",",
"}",
")",
".",
"Iter",
"(",
")",
"\n",
"defer",
"iter",
".",
"Close",
"(",
")",
"\n\n",
"var",
"doc",
"cloudCredentialDoc",
"\n",
"for",
"iter",
".",
"Next",
"(",
"&",
"doc",
")",
"{",
"tag",
",",
"err",
":=",
"doc",
".",
"cloudCredentialTag",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"credentials",
"[",
"tag",
".",
"Id",
"(",
")",
"]",
"=",
"Credential",
"{",
"doc",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"iter",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"user",
".",
"Id",
"(",
")",
",",
"cloudName",
",",
")",
"\n",
"}",
"\n",
"return",
"credentials",
",",
"nil",
"\n",
"}"
] |
// CloudCredentials returns the user's cloud credentials for a given cloud,
// keyed by credential name.
|
[
"CloudCredentials",
"returns",
"the",
"user",
"s",
"cloud",
"credentials",
"for",
"a",
"given",
"cloud",
"keyed",
"by",
"credential",
"name",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L85-L111
|
154,364 |
juju/juju
|
state/cloudcredentials.go
|
UpdateCloudCredential
|
func (st *State) UpdateCloudCredential(tag names.CloudCredentialTag, credential cloud.Credential) error {
credentials := map[names.CloudCredentialTag]Credential{
tag: convertCloudCredentialToState(tag, credential),
}
annotationMsg := "updating cloud credentials"
buildTxn := func(attempt int) ([]txn.Op, error) {
cloudName := tag.Cloud().Id()
cloud, err := st.Cloud(cloudName)
if err != nil {
return nil, errors.Trace(err)
}
ops, err := validateCloudCredentials(cloud, credentials)
if err != nil {
return nil, errors.Trace(err)
}
_, err = st.CloudCredential(tag)
if err != nil && !errors.IsNotFound(err) {
return nil, errors.Maskf(err, "fetching cloud credentials")
}
if err == nil {
ops = append(ops, updateCloudCredentialOp(tag, credential))
} else {
annotationMsg = "creating cloud credential"
if credential.Invalid || credential.InvalidReason != "" {
return nil, errors.NotSupportedf("adding invalid credential")
}
ops = append(ops, createCloudCredentialOp(tag, credential))
}
return ops, nil
}
if err := st.db().Run(buildTxn); err != nil {
return errors.Annotate(err, annotationMsg)
}
return nil
}
|
go
|
func (st *State) UpdateCloudCredential(tag names.CloudCredentialTag, credential cloud.Credential) error {
credentials := map[names.CloudCredentialTag]Credential{
tag: convertCloudCredentialToState(tag, credential),
}
annotationMsg := "updating cloud credentials"
buildTxn := func(attempt int) ([]txn.Op, error) {
cloudName := tag.Cloud().Id()
cloud, err := st.Cloud(cloudName)
if err != nil {
return nil, errors.Trace(err)
}
ops, err := validateCloudCredentials(cloud, credentials)
if err != nil {
return nil, errors.Trace(err)
}
_, err = st.CloudCredential(tag)
if err != nil && !errors.IsNotFound(err) {
return nil, errors.Maskf(err, "fetching cloud credentials")
}
if err == nil {
ops = append(ops, updateCloudCredentialOp(tag, credential))
} else {
annotationMsg = "creating cloud credential"
if credential.Invalid || credential.InvalidReason != "" {
return nil, errors.NotSupportedf("adding invalid credential")
}
ops = append(ops, createCloudCredentialOp(tag, credential))
}
return ops, nil
}
if err := st.db().Run(buildTxn); err != nil {
return errors.Annotate(err, annotationMsg)
}
return nil
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"UpdateCloudCredential",
"(",
"tag",
"names",
".",
"CloudCredentialTag",
",",
"credential",
"cloud",
".",
"Credential",
")",
"error",
"{",
"credentials",
":=",
"map",
"[",
"names",
".",
"CloudCredentialTag",
"]",
"Credential",
"{",
"tag",
":",
"convertCloudCredentialToState",
"(",
"tag",
",",
"credential",
")",
",",
"}",
"\n",
"annotationMsg",
":=",
"\"",
"\"",
"\n",
"buildTxn",
":=",
"func",
"(",
"attempt",
"int",
")",
"(",
"[",
"]",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"cloudName",
":=",
"tag",
".",
"Cloud",
"(",
")",
".",
"Id",
"(",
")",
"\n",
"cloud",
",",
"err",
":=",
"st",
".",
"Cloud",
"(",
"cloudName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"ops",
",",
"err",
":=",
"validateCloudCredentials",
"(",
"cloud",
",",
"credentials",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"st",
".",
"CloudCredential",
"(",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"!",
"errors",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"Maskf",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
"==",
"nil",
"{",
"ops",
"=",
"append",
"(",
"ops",
",",
"updateCloudCredentialOp",
"(",
"tag",
",",
"credential",
")",
")",
"\n",
"}",
"else",
"{",
"annotationMsg",
"=",
"\"",
"\"",
"\n",
"if",
"credential",
".",
"Invalid",
"||",
"credential",
".",
"InvalidReason",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"NotSupportedf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"ops",
"=",
"append",
"(",
"ops",
",",
"createCloudCredentialOp",
"(",
"tag",
",",
"credential",
")",
")",
"\n",
"}",
"\n",
"return",
"ops",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"st",
".",
"db",
"(",
")",
".",
"Run",
"(",
"buildTxn",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"annotationMsg",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UpdateCloudCredential adds or updates a cloud credential with the given tag.
|
[
"UpdateCloudCredential",
"adds",
"or",
"updates",
"a",
"cloud",
"credential",
"with",
"the",
"given",
"tag",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L114-L148
|
154,365 |
juju/juju
|
state/cloudcredentials.go
|
InvalidateCloudCredential
|
func (st *State) InvalidateCloudCredential(tag names.CloudCredentialTag, reason string) error {
buildTxn := func(attempt int) ([]txn.Op, error) {
_, err := st.CloudCredential(tag)
if err != nil {
return nil, errors.Trace(err)
}
ops := []txn.Op{{
C: cloudCredentialsC,
Id: cloudCredentialDocID(tag),
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{
{"invalid", true},
{"invalid-reason", reason},
}}},
}}
return ops, nil
}
if err := st.db().Run(buildTxn); err != nil {
return errors.Annotatef(err, "invalidating cloud credential %v", tag.Id())
}
return nil
}
|
go
|
func (st *State) InvalidateCloudCredential(tag names.CloudCredentialTag, reason string) error {
buildTxn := func(attempt int) ([]txn.Op, error) {
_, err := st.CloudCredential(tag)
if err != nil {
return nil, errors.Trace(err)
}
ops := []txn.Op{{
C: cloudCredentialsC,
Id: cloudCredentialDocID(tag),
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{
{"invalid", true},
{"invalid-reason", reason},
}}},
}}
return ops, nil
}
if err := st.db().Run(buildTxn); err != nil {
return errors.Annotatef(err, "invalidating cloud credential %v", tag.Id())
}
return nil
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"InvalidateCloudCredential",
"(",
"tag",
"names",
".",
"CloudCredentialTag",
",",
"reason",
"string",
")",
"error",
"{",
"buildTxn",
":=",
"func",
"(",
"attempt",
"int",
")",
"(",
"[",
"]",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"st",
".",
"CloudCredential",
"(",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"ops",
":=",
"[",
"]",
"txn",
".",
"Op",
"{",
"{",
"C",
":",
"cloudCredentialsC",
",",
"Id",
":",
"cloudCredentialDocID",
"(",
"tag",
")",
",",
"Assert",
":",
"txn",
".",
"DocExists",
",",
"Update",
":",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"true",
"}",
",",
"{",
"\"",
"\"",
",",
"reason",
"}",
",",
"}",
"}",
"}",
",",
"}",
"}",
"\n",
"return",
"ops",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"st",
".",
"db",
"(",
")",
".",
"Run",
"(",
"buildTxn",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"tag",
".",
"Id",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// InvalidateCloudCredential marks a cloud credential with the given tag as invalid.
|
[
"InvalidateCloudCredential",
"marks",
"a",
"cloud",
"credential",
"with",
"the",
"given",
"tag",
"as",
"invalid",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L151-L173
|
154,366 |
juju/juju
|
state/cloudcredentials.go
|
RemoveCloudCredential
|
func (st *State) RemoveCloudCredential(tag names.CloudCredentialTag) error {
buildTxn := func(attempt int) ([]txn.Op, error) {
_, err := st.CloudCredential(tag)
if errors.IsNotFound(err) {
return nil, jujutxn.ErrNoOperations
}
if err != nil {
return nil, errors.Trace(err)
}
return removeCloudCredentialOps(tag), nil
}
if err := st.db().Run(buildTxn); err != nil {
return errors.Annotate(err, "removing cloud credential")
}
return nil
}
|
go
|
func (st *State) RemoveCloudCredential(tag names.CloudCredentialTag) error {
buildTxn := func(attempt int) ([]txn.Op, error) {
_, err := st.CloudCredential(tag)
if errors.IsNotFound(err) {
return nil, jujutxn.ErrNoOperations
}
if err != nil {
return nil, errors.Trace(err)
}
return removeCloudCredentialOps(tag), nil
}
if err := st.db().Run(buildTxn); err != nil {
return errors.Annotate(err, "removing cloud credential")
}
return nil
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"RemoveCloudCredential",
"(",
"tag",
"names",
".",
"CloudCredentialTag",
")",
"error",
"{",
"buildTxn",
":=",
"func",
"(",
"attempt",
"int",
")",
"(",
"[",
"]",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"st",
".",
"CloudCredential",
"(",
"tag",
")",
"\n",
"if",
"errors",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"jujutxn",
".",
"ErrNoOperations",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"removeCloudCredentialOps",
"(",
"tag",
")",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"st",
".",
"db",
"(",
")",
".",
"Run",
"(",
"buildTxn",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// RemoveCloudCredential removes a cloud credential with the given tag.
|
[
"RemoveCloudCredential",
"removes",
"a",
"cloud",
"credential",
"with",
"the",
"given",
"tag",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L176-L191
|
154,367 |
juju/juju
|
state/cloudcredentials.go
|
createCloudCredentialOp
|
func createCloudCredentialOp(tag names.CloudCredentialTag, cred cloud.Credential) txn.Op {
return txn.Op{
C: cloudCredentialsC,
Id: cloudCredentialDocID(tag),
Assert: txn.DocMissing,
Insert: &cloudCredentialDoc{
Owner: tag.Owner().Id(),
Cloud: tag.Cloud().Id(),
Name: tag.Name(),
AuthType: string(cred.AuthType()),
Attributes: cred.Attributes(),
Revoked: cred.Revoked,
},
}
}
|
go
|
func createCloudCredentialOp(tag names.CloudCredentialTag, cred cloud.Credential) txn.Op {
return txn.Op{
C: cloudCredentialsC,
Id: cloudCredentialDocID(tag),
Assert: txn.DocMissing,
Insert: &cloudCredentialDoc{
Owner: tag.Owner().Id(),
Cloud: tag.Cloud().Id(),
Name: tag.Name(),
AuthType: string(cred.AuthType()),
Attributes: cred.Attributes(),
Revoked: cred.Revoked,
},
}
}
|
[
"func",
"createCloudCredentialOp",
"(",
"tag",
"names",
".",
"CloudCredentialTag",
",",
"cred",
"cloud",
".",
"Credential",
")",
"txn",
".",
"Op",
"{",
"return",
"txn",
".",
"Op",
"{",
"C",
":",
"cloudCredentialsC",
",",
"Id",
":",
"cloudCredentialDocID",
"(",
"tag",
")",
",",
"Assert",
":",
"txn",
".",
"DocMissing",
",",
"Insert",
":",
"&",
"cloudCredentialDoc",
"{",
"Owner",
":",
"tag",
".",
"Owner",
"(",
")",
".",
"Id",
"(",
")",
",",
"Cloud",
":",
"tag",
".",
"Cloud",
"(",
")",
".",
"Id",
"(",
")",
",",
"Name",
":",
"tag",
".",
"Name",
"(",
")",
",",
"AuthType",
":",
"string",
"(",
"cred",
".",
"AuthType",
"(",
")",
")",
",",
"Attributes",
":",
"cred",
".",
"Attributes",
"(",
")",
",",
"Revoked",
":",
"cred",
".",
"Revoked",
",",
"}",
",",
"}",
"\n",
"}"
] |
// createCloudCredentialOp returns a txn.Op that will create
// a cloud credential.
|
[
"createCloudCredentialOp",
"returns",
"a",
"txn",
".",
"Op",
"that",
"will",
"create",
"a",
"cloud",
"credential",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L195-L209
|
154,368 |
juju/juju
|
state/cloudcredentials.go
|
updateCloudCredentialOp
|
func updateCloudCredentialOp(tag names.CloudCredentialTag, cred cloud.Credential) txn.Op {
return txn.Op{
C: cloudCredentialsC,
Id: cloudCredentialDocID(tag),
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{
{"auth-type", string(cred.AuthType())},
{"attributes", cred.Attributes()},
{"revoked", cred.Revoked},
{"invalid", cred.Invalid},
{"invalid-reason", cred.InvalidReason},
}}},
}
}
|
go
|
func updateCloudCredentialOp(tag names.CloudCredentialTag, cred cloud.Credential) txn.Op {
return txn.Op{
C: cloudCredentialsC,
Id: cloudCredentialDocID(tag),
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{
{"auth-type", string(cred.AuthType())},
{"attributes", cred.Attributes()},
{"revoked", cred.Revoked},
{"invalid", cred.Invalid},
{"invalid-reason", cred.InvalidReason},
}}},
}
}
|
[
"func",
"updateCloudCredentialOp",
"(",
"tag",
"names",
".",
"CloudCredentialTag",
",",
"cred",
"cloud",
".",
"Credential",
")",
"txn",
".",
"Op",
"{",
"return",
"txn",
".",
"Op",
"{",
"C",
":",
"cloudCredentialsC",
",",
"Id",
":",
"cloudCredentialDocID",
"(",
"tag",
")",
",",
"Assert",
":",
"txn",
".",
"DocExists",
",",
"Update",
":",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"string",
"(",
"cred",
".",
"AuthType",
"(",
")",
")",
"}",
",",
"{",
"\"",
"\"",
",",
"cred",
".",
"Attributes",
"(",
")",
"}",
",",
"{",
"\"",
"\"",
",",
"cred",
".",
"Revoked",
"}",
",",
"{",
"\"",
"\"",
",",
"cred",
".",
"Invalid",
"}",
",",
"{",
"\"",
"\"",
",",
"cred",
".",
"InvalidReason",
"}",
",",
"}",
"}",
"}",
",",
"}",
"\n",
"}"
] |
// updateCloudCredentialOp returns a txn.Op that will update
// a cloud credential.
|
[
"updateCloudCredentialOp",
"returns",
"a",
"txn",
".",
"Op",
"that",
"will",
"update",
"a",
"cloud",
"credential",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L213-L226
|
154,369 |
juju/juju
|
state/cloudcredentials.go
|
removeCloudCredentialOps
|
func removeCloudCredentialOps(tag names.CloudCredentialTag) []txn.Op {
return []txn.Op{{
C: cloudCredentialsC,
Id: cloudCredentialDocID(tag),
Assert: txn.DocExists,
Remove: true,
}}
}
|
go
|
func removeCloudCredentialOps(tag names.CloudCredentialTag) []txn.Op {
return []txn.Op{{
C: cloudCredentialsC,
Id: cloudCredentialDocID(tag),
Assert: txn.DocExists,
Remove: true,
}}
}
|
[
"func",
"removeCloudCredentialOps",
"(",
"tag",
"names",
".",
"CloudCredentialTag",
")",
"[",
"]",
"txn",
".",
"Op",
"{",
"return",
"[",
"]",
"txn",
".",
"Op",
"{",
"{",
"C",
":",
"cloudCredentialsC",
",",
"Id",
":",
"cloudCredentialDocID",
"(",
"tag",
")",
",",
"Assert",
":",
"txn",
".",
"DocExists",
",",
"Remove",
":",
"true",
",",
"}",
"}",
"\n",
"}"
] |
// removeCloudCredentialOp returns a txn.Op that will remove
// a cloud credential.
|
[
"removeCloudCredentialOp",
"returns",
"a",
"txn",
".",
"Op",
"that",
"will",
"remove",
"a",
"cloud",
"credential",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L230-L237
|
154,370 |
juju/juju
|
state/cloudcredentials.go
|
WatchCredential
|
func (st *State) WatchCredential(cred names.CloudCredentialTag) NotifyWatcher {
filter := func(rawId interface{}) bool {
id, ok := rawId.(string)
if !ok {
return false
}
return id == cloudCredentialDocID(cred)
}
return newNotifyCollWatcher(st, cloudCredentialsC, filter)
}
|
go
|
func (st *State) WatchCredential(cred names.CloudCredentialTag) NotifyWatcher {
filter := func(rawId interface{}) bool {
id, ok := rawId.(string)
if !ok {
return false
}
return id == cloudCredentialDocID(cred)
}
return newNotifyCollWatcher(st, cloudCredentialsC, filter)
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"WatchCredential",
"(",
"cred",
"names",
".",
"CloudCredentialTag",
")",
"NotifyWatcher",
"{",
"filter",
":=",
"func",
"(",
"rawId",
"interface",
"{",
"}",
")",
"bool",
"{",
"id",
",",
"ok",
":=",
"rawId",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"id",
"==",
"cloudCredentialDocID",
"(",
"cred",
")",
"\n",
"}",
"\n",
"return",
"newNotifyCollWatcher",
"(",
"st",
",",
"cloudCredentialsC",
",",
"filter",
")",
"\n",
"}"
] |
// WatchCredential returns a new NotifyWatcher watching for
// changes to the specified credential.
|
[
"WatchCredential",
"returns",
"a",
"new",
"NotifyWatcher",
"watching",
"for",
"changes",
"to",
"the",
"specified",
"credential",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L309-L318
|
154,371 |
juju/juju
|
state/cloudcredentials.go
|
AllCloudCredentials
|
func (st *State) AllCloudCredentials(user names.UserTag) ([]Credential, error) {
coll, cleanup := st.db().GetCollection(cloudCredentialsC)
defer cleanup()
// There are 2 ways of getting a credential for a user:
// 1. user name stored in the credential tag (aka doc id);
// 2. look up using Owner field.
// We use Owner field below as credential tag or doc ID may be changed
// in the future to be a real Primary Key that has nothing to do with
// the data it identifies, i.e. no business meaning.
clause := bson.D{{"owner", user.Id()}}
var docs []cloudCredentialDoc
err := coll.Find(clause).Sort("cloud").All(&docs)
if err != nil {
return nil, errors.Annotatef(err, "getting cloud credentials for %q", user.Id())
}
if len(docs) == 0 {
return nil, errors.NotFoundf("cloud credentials for %q", user.Id())
}
credentials := make([]Credential, len(docs))
for i, doc := range docs {
credentials[i] = Credential{doc}
}
return credentials, nil
}
|
go
|
func (st *State) AllCloudCredentials(user names.UserTag) ([]Credential, error) {
coll, cleanup := st.db().GetCollection(cloudCredentialsC)
defer cleanup()
// There are 2 ways of getting a credential for a user:
// 1. user name stored in the credential tag (aka doc id);
// 2. look up using Owner field.
// We use Owner field below as credential tag or doc ID may be changed
// in the future to be a real Primary Key that has nothing to do with
// the data it identifies, i.e. no business meaning.
clause := bson.D{{"owner", user.Id()}}
var docs []cloudCredentialDoc
err := coll.Find(clause).Sort("cloud").All(&docs)
if err != nil {
return nil, errors.Annotatef(err, "getting cloud credentials for %q", user.Id())
}
if len(docs) == 0 {
return nil, errors.NotFoundf("cloud credentials for %q", user.Id())
}
credentials := make([]Credential, len(docs))
for i, doc := range docs {
credentials[i] = Credential{doc}
}
return credentials, nil
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"AllCloudCredentials",
"(",
"user",
"names",
".",
"UserTag",
")",
"(",
"[",
"]",
"Credential",
",",
"error",
")",
"{",
"coll",
",",
"cleanup",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"cloudCredentialsC",
")",
"\n",
"defer",
"cleanup",
"(",
")",
"\n\n",
"// There are 2 ways of getting a credential for a user:",
"// 1. user name stored in the credential tag (aka doc id);",
"// 2. look up using Owner field.",
"// We use Owner field below as credential tag or doc ID may be changed",
"// in the future to be a real Primary Key that has nothing to do with",
"// the data it identifies, i.e. no business meaning.",
"clause",
":=",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"user",
".",
"Id",
"(",
")",
"}",
"}",
"\n\n",
"var",
"docs",
"[",
"]",
"cloudCredentialDoc",
"\n",
"err",
":=",
"coll",
".",
"Find",
"(",
"clause",
")",
".",
"Sort",
"(",
"\"",
"\"",
")",
".",
"All",
"(",
"&",
"docs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"user",
".",
"Id",
"(",
")",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"docs",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"user",
".",
"Id",
"(",
")",
")",
"\n",
"}",
"\n\n",
"credentials",
":=",
"make",
"(",
"[",
"]",
"Credential",
",",
"len",
"(",
"docs",
")",
")",
"\n",
"for",
"i",
",",
"doc",
":=",
"range",
"docs",
"{",
"credentials",
"[",
"i",
"]",
"=",
"Credential",
"{",
"doc",
"}",
"\n",
"}",
"\n",
"return",
"credentials",
",",
"nil",
"\n",
"}"
] |
// AllCloudCredentials returns all cloud credentials stored on the controller
// for a given user.
|
[
"AllCloudCredentials",
"returns",
"all",
"cloud",
"credentials",
"stored",
"on",
"the",
"controller",
"for",
"a",
"given",
"user",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L322-L349
|
154,372 |
juju/juju
|
state/cloudcredentials.go
|
CredentialModels
|
func (st *State) CredentialModels(tag names.CloudCredentialTag) (map[string]string, error) {
coll, cleanup := st.db().GetCollection(modelsC)
defer cleanup()
sel := bson.D{
{"cloud-credential", tag.Id()},
{"life", bson.D{{"$ne", Dead}}},
}
var docs []modelDoc
err := coll.Find(sel).All(&docs)
if err != nil {
return nil, errors.Annotatef(err, "getting models that use cloud credential %q", tag.Id())
}
if len(docs) == 0 {
return nil, errors.NotFoundf("models that use cloud credentials %q", tag.Id())
}
results := make(map[string]string, len(docs))
for _, model := range docs {
results[model.UUID] = model.Name
}
return results, nil
}
|
go
|
func (st *State) CredentialModels(tag names.CloudCredentialTag) (map[string]string, error) {
coll, cleanup := st.db().GetCollection(modelsC)
defer cleanup()
sel := bson.D{
{"cloud-credential", tag.Id()},
{"life", bson.D{{"$ne", Dead}}},
}
var docs []modelDoc
err := coll.Find(sel).All(&docs)
if err != nil {
return nil, errors.Annotatef(err, "getting models that use cloud credential %q", tag.Id())
}
if len(docs) == 0 {
return nil, errors.NotFoundf("models that use cloud credentials %q", tag.Id())
}
results := make(map[string]string, len(docs))
for _, model := range docs {
results[model.UUID] = model.Name
}
return results, nil
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"CredentialModels",
"(",
"tag",
"names",
".",
"CloudCredentialTag",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"coll",
",",
"cleanup",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"modelsC",
")",
"\n",
"defer",
"cleanup",
"(",
")",
"\n\n",
"sel",
":=",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"tag",
".",
"Id",
"(",
")",
"}",
",",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"Dead",
"}",
"}",
"}",
",",
"}",
"\n\n",
"var",
"docs",
"[",
"]",
"modelDoc",
"\n",
"err",
":=",
"coll",
".",
"Find",
"(",
"sel",
")",
".",
"All",
"(",
"&",
"docs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"tag",
".",
"Id",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"docs",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Id",
"(",
")",
")",
"\n",
"}",
"\n\n",
"results",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"len",
"(",
"docs",
")",
")",
"\n",
"for",
"_",
",",
"model",
":=",
"range",
"docs",
"{",
"results",
"[",
"model",
".",
"UUID",
"]",
"=",
"model",
".",
"Name",
"\n",
"}",
"\n",
"return",
"results",
",",
"nil",
"\n",
"}"
] |
// CredentialModels returns all models that use given cloud credential.
|
[
"CredentialModels",
"returns",
"all",
"models",
"that",
"use",
"given",
"cloud",
"credential",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L352-L375
|
154,373 |
juju/juju
|
state/cloudcredentials.go
|
CredentialModelsAndOwnerAccess
|
func (st *State) CredentialModelsAndOwnerAccess(tag names.CloudCredentialTag) ([]CredentialOwnerModelAccess, error) {
models, err := st.CredentialModels(tag)
if err != nil {
return nil, errors.Trace(err)
}
var results []CredentialOwnerModelAccess
for uuid, name := range models {
ownerAccess, err := st.UserAccess(tag.Owner(), names.NewModelTag(uuid))
if err != nil {
if errors.IsNotFound(err) {
results = append(results, CredentialOwnerModelAccess{ModelName: name, ModelUUID: uuid, OwnerAccess: permission.NoAccess})
continue
}
results = append(results, CredentialOwnerModelAccess{ModelName: name, ModelUUID: uuid, Error: errors.Trace(err)})
continue
}
results = append(results, CredentialOwnerModelAccess{ModelName: name, ModelUUID: uuid, OwnerAccess: ownerAccess.Access})
}
return results, nil
}
|
go
|
func (st *State) CredentialModelsAndOwnerAccess(tag names.CloudCredentialTag) ([]CredentialOwnerModelAccess, error) {
models, err := st.CredentialModels(tag)
if err != nil {
return nil, errors.Trace(err)
}
var results []CredentialOwnerModelAccess
for uuid, name := range models {
ownerAccess, err := st.UserAccess(tag.Owner(), names.NewModelTag(uuid))
if err != nil {
if errors.IsNotFound(err) {
results = append(results, CredentialOwnerModelAccess{ModelName: name, ModelUUID: uuid, OwnerAccess: permission.NoAccess})
continue
}
results = append(results, CredentialOwnerModelAccess{ModelName: name, ModelUUID: uuid, Error: errors.Trace(err)})
continue
}
results = append(results, CredentialOwnerModelAccess{ModelName: name, ModelUUID: uuid, OwnerAccess: ownerAccess.Access})
}
return results, nil
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"CredentialModelsAndOwnerAccess",
"(",
"tag",
"names",
".",
"CloudCredentialTag",
")",
"(",
"[",
"]",
"CredentialOwnerModelAccess",
",",
"error",
")",
"{",
"models",
",",
"err",
":=",
"st",
".",
"CredentialModels",
"(",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"results",
"[",
"]",
"CredentialOwnerModelAccess",
"\n",
"for",
"uuid",
",",
"name",
":=",
"range",
"models",
"{",
"ownerAccess",
",",
"err",
":=",
"st",
".",
"UserAccess",
"(",
"tag",
".",
"Owner",
"(",
")",
",",
"names",
".",
"NewModelTag",
"(",
"uuid",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"errors",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"results",
"=",
"append",
"(",
"results",
",",
"CredentialOwnerModelAccess",
"{",
"ModelName",
":",
"name",
",",
"ModelUUID",
":",
"uuid",
",",
"OwnerAccess",
":",
"permission",
".",
"NoAccess",
"}",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"CredentialOwnerModelAccess",
"{",
"ModelName",
":",
"name",
",",
"ModelUUID",
":",
"uuid",
",",
"Error",
":",
"errors",
".",
"Trace",
"(",
"err",
")",
"}",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"CredentialOwnerModelAccess",
"{",
"ModelName",
":",
"name",
",",
"ModelUUID",
":",
"uuid",
",",
"OwnerAccess",
":",
"ownerAccess",
".",
"Access",
"}",
")",
"\n",
"}",
"\n",
"return",
"results",
",",
"nil",
"\n",
"}"
] |
// CredentialModelsAndOwnerAccess returns all models that use given cloud credential as well as
// what access the credential owner has on these models.
|
[
"CredentialModelsAndOwnerAccess",
"returns",
"all",
"models",
"that",
"use",
"given",
"cloud",
"credential",
"as",
"well",
"as",
"what",
"access",
"the",
"credential",
"owner",
"has",
"on",
"these",
"models",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/cloudcredentials.go#L388-L408
|
154,374 |
juju/juju
|
worker/proxyupdater/manifold.go
|
Manifold
|
func Manifold(config ManifoldConfig) dependency.Manifold {
return dependency.Manifold{
Inputs: []string{
config.AgentName,
config.APICallerName,
},
Start: func(context dependency.Context) (worker.Worker, error) {
if config.WorkerFunc == nil {
return nil, errors.NotValidf("missing WorkerFunc")
}
if config.InProcessUpdate == nil {
return nil, errors.NotValidf("missing InProcessUpdate")
}
var agent agent.Agent
if err := context.Get(config.AgentName, &agent); err != nil {
return nil, err
}
var apiCaller base.APICaller
if err := context.Get(config.APICallerName, &apiCaller); err != nil {
return nil, err
}
agentConfig := agent.CurrentConfig()
proxyAPI, err := proxyupdater.NewAPI(apiCaller, agentConfig.Tag())
if err != nil {
return nil, err
}
w, err := config.WorkerFunc(Config{
SystemdFiles: []string{"/etc/juju-proxy-systemd.conf"},
EnvFiles: []string{"/etc/juju-proxy.conf"},
RegistryPath: `HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings`,
API: proxyAPI,
ExternalUpdate: config.ExternalUpdate,
InProcessUpdate: config.InProcessUpdate,
Logger: config.Logger,
RunFunc: config.RunFunc,
})
if err != nil {
return nil, errors.Trace(err)
}
return w, nil
},
}
}
|
go
|
func Manifold(config ManifoldConfig) dependency.Manifold {
return dependency.Manifold{
Inputs: []string{
config.AgentName,
config.APICallerName,
},
Start: func(context dependency.Context) (worker.Worker, error) {
if config.WorkerFunc == nil {
return nil, errors.NotValidf("missing WorkerFunc")
}
if config.InProcessUpdate == nil {
return nil, errors.NotValidf("missing InProcessUpdate")
}
var agent agent.Agent
if err := context.Get(config.AgentName, &agent); err != nil {
return nil, err
}
var apiCaller base.APICaller
if err := context.Get(config.APICallerName, &apiCaller); err != nil {
return nil, err
}
agentConfig := agent.CurrentConfig()
proxyAPI, err := proxyupdater.NewAPI(apiCaller, agentConfig.Tag())
if err != nil {
return nil, err
}
w, err := config.WorkerFunc(Config{
SystemdFiles: []string{"/etc/juju-proxy-systemd.conf"},
EnvFiles: []string{"/etc/juju-proxy.conf"},
RegistryPath: `HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings`,
API: proxyAPI,
ExternalUpdate: config.ExternalUpdate,
InProcessUpdate: config.InProcessUpdate,
Logger: config.Logger,
RunFunc: config.RunFunc,
})
if err != nil {
return nil, errors.Trace(err)
}
return w, nil
},
}
}
|
[
"func",
"Manifold",
"(",
"config",
"ManifoldConfig",
")",
"dependency",
".",
"Manifold",
"{",
"return",
"dependency",
".",
"Manifold",
"{",
"Inputs",
":",
"[",
"]",
"string",
"{",
"config",
".",
"AgentName",
",",
"config",
".",
"APICallerName",
",",
"}",
",",
"Start",
":",
"func",
"(",
"context",
"dependency",
".",
"Context",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"if",
"config",
".",
"WorkerFunc",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"InProcessUpdate",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"var",
"agent",
"agent",
".",
"Agent",
"\n",
"if",
"err",
":=",
"context",
".",
"Get",
"(",
"config",
".",
"AgentName",
",",
"&",
"agent",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"apiCaller",
"base",
".",
"APICaller",
"\n",
"if",
"err",
":=",
"context",
".",
"Get",
"(",
"config",
".",
"APICallerName",
",",
"&",
"apiCaller",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"agentConfig",
":=",
"agent",
".",
"CurrentConfig",
"(",
")",
"\n",
"proxyAPI",
",",
"err",
":=",
"proxyupdater",
".",
"NewAPI",
"(",
"apiCaller",
",",
"agentConfig",
".",
"Tag",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"w",
",",
"err",
":=",
"config",
".",
"WorkerFunc",
"(",
"Config",
"{",
"SystemdFiles",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"EnvFiles",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"RegistryPath",
":",
"`HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings`",
",",
"API",
":",
"proxyAPI",
",",
"ExternalUpdate",
":",
"config",
".",
"ExternalUpdate",
",",
"InProcessUpdate",
":",
"config",
".",
"InProcessUpdate",
",",
"Logger",
":",
"config",
".",
"Logger",
",",
"RunFunc",
":",
"config",
".",
"RunFunc",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"w",
",",
"nil",
"\n",
"}",
",",
"}",
"\n",
"}"
] |
// Manifold returns a dependency manifold that runs a proxy updater worker,
// using the api connection resource named in the supplied config.
|
[
"Manifold",
"returns",
"a",
"dependency",
"manifold",
"that",
"runs",
"a",
"proxy",
"updater",
"worker",
"using",
"the",
"api",
"connection",
"resource",
"named",
"in",
"the",
"supplied",
"config",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/proxyupdater/manifold.go#L39-L82
|
154,375 |
juju/juju
|
provider/gce/google/conn_machines.go
|
ListMachineTypes
|
func (gce *Connection) ListMachineTypes(zone string) ([]MachineType, error) {
machines, err := gce.raw.ListMachineTypes(gce.projectID, zone)
if err != nil {
return nil, errors.Trace(err)
}
res := make([]MachineType, len(machines.Items))
for i, machine := range machines.Items {
deprecated := false
if machine.Deprecated != nil {
deprecated = machine.Deprecated.State != ""
}
res[i] = MachineType{
CreationTimestamp: machine.CreationTimestamp,
Deprecated: deprecated,
Description: machine.Description,
GuestCpus: machine.GuestCpus,
Id: machine.Id,
ImageSpaceGb: machine.ImageSpaceGb,
Kind: machine.Kind,
MaximumPersistentDisks: machine.MaximumPersistentDisks,
MaximumPersistentDisksSizeGb: machine.MaximumPersistentDisksSizeGb,
MemoryMb: machine.MemoryMb,
Name: machine.Name,
}
}
return res, nil
}
|
go
|
func (gce *Connection) ListMachineTypes(zone string) ([]MachineType, error) {
machines, err := gce.raw.ListMachineTypes(gce.projectID, zone)
if err != nil {
return nil, errors.Trace(err)
}
res := make([]MachineType, len(machines.Items))
for i, machine := range machines.Items {
deprecated := false
if machine.Deprecated != nil {
deprecated = machine.Deprecated.State != ""
}
res[i] = MachineType{
CreationTimestamp: machine.CreationTimestamp,
Deprecated: deprecated,
Description: machine.Description,
GuestCpus: machine.GuestCpus,
Id: machine.Id,
ImageSpaceGb: machine.ImageSpaceGb,
Kind: machine.Kind,
MaximumPersistentDisks: machine.MaximumPersistentDisks,
MaximumPersistentDisksSizeGb: machine.MaximumPersistentDisksSizeGb,
MemoryMb: machine.MemoryMb,
Name: machine.Name,
}
}
return res, nil
}
|
[
"func",
"(",
"gce",
"*",
"Connection",
")",
"ListMachineTypes",
"(",
"zone",
"string",
")",
"(",
"[",
"]",
"MachineType",
",",
"error",
")",
"{",
"machines",
",",
"err",
":=",
"gce",
".",
"raw",
".",
"ListMachineTypes",
"(",
"gce",
".",
"projectID",
",",
"zone",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"res",
":=",
"make",
"(",
"[",
"]",
"MachineType",
",",
"len",
"(",
"machines",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"machine",
":=",
"range",
"machines",
".",
"Items",
"{",
"deprecated",
":=",
"false",
"\n",
"if",
"machine",
".",
"Deprecated",
"!=",
"nil",
"{",
"deprecated",
"=",
"machine",
".",
"Deprecated",
".",
"State",
"!=",
"\"",
"\"",
"\n",
"}",
"\n",
"res",
"[",
"i",
"]",
"=",
"MachineType",
"{",
"CreationTimestamp",
":",
"machine",
".",
"CreationTimestamp",
",",
"Deprecated",
":",
"deprecated",
",",
"Description",
":",
"machine",
".",
"Description",
",",
"GuestCpus",
":",
"machine",
".",
"GuestCpus",
",",
"Id",
":",
"machine",
".",
"Id",
",",
"ImageSpaceGb",
":",
"machine",
".",
"ImageSpaceGb",
",",
"Kind",
":",
"machine",
".",
"Kind",
",",
"MaximumPersistentDisks",
":",
"machine",
".",
"MaximumPersistentDisks",
",",
"MaximumPersistentDisksSizeGb",
":",
"machine",
".",
"MaximumPersistentDisksSizeGb",
",",
"MemoryMb",
":",
"machine",
".",
"MemoryMb",
",",
"Name",
":",
"machine",
".",
"Name",
",",
"}",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// ListMachineTypes returns a list of MachineType available for the
// given zone.
|
[
"ListMachineTypes",
"returns",
"a",
"list",
"of",
"MachineType",
"available",
"for",
"the",
"given",
"zone",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/gce/google/conn_machines.go#L10-L36
|
154,376 |
juju/juju
|
worker/raft/raftforwarder/manifold.go
|
NewTarget
|
func NewTarget(st *state.State, logFile io.Writer, errorLog Logger) raftlease.NotifyTarget {
return st.LeaseNotifyTarget(logFile, errorLog)
}
|
go
|
func NewTarget(st *state.State, logFile io.Writer, errorLog Logger) raftlease.NotifyTarget {
return st.LeaseNotifyTarget(logFile, errorLog)
}
|
[
"func",
"NewTarget",
"(",
"st",
"*",
"state",
".",
"State",
",",
"logFile",
"io",
".",
"Writer",
",",
"errorLog",
"Logger",
")",
"raftlease",
".",
"NotifyTarget",
"{",
"return",
"st",
".",
"LeaseNotifyTarget",
"(",
"logFile",
",",
"errorLog",
")",
"\n",
"}"
] |
// NewTarget is a shim to construct a raftlease.NotifyTarget for testability.
|
[
"NewTarget",
"is",
"a",
"shim",
"to",
"construct",
"a",
"raftlease",
".",
"NotifyTarget",
"for",
"testability",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/raft/raftforwarder/manifold.go#L146-L148
|
154,377 |
juju/juju
|
api/bundle/client.go
|
ExportBundle
|
func (c *Client) ExportBundle() (string, error) {
var result params.StringResult
if bestVer := c.BestAPIVersion(); bestVer < 2 {
return "", errors.Errorf("this controller version does not support bundle export feature.")
}
if err := c.facade.FacadeCall("ExportBundle", nil, &result); err != nil {
return "", errors.Trace(err)
}
if result.Error != nil {
return "", errors.Trace(result.Error)
}
return result.Result, nil
}
|
go
|
func (c *Client) ExportBundle() (string, error) {
var result params.StringResult
if bestVer := c.BestAPIVersion(); bestVer < 2 {
return "", errors.Errorf("this controller version does not support bundle export feature.")
}
if err := c.facade.FacadeCall("ExportBundle", nil, &result); err != nil {
return "", errors.Trace(err)
}
if result.Error != nil {
return "", errors.Trace(result.Error)
}
return result.Result, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"ExportBundle",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"result",
"params",
".",
"StringResult",
"\n",
"if",
"bestVer",
":=",
"c",
".",
"BestAPIVersion",
"(",
")",
";",
"bestVer",
"<",
"2",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"nil",
",",
"&",
"result",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"result",
".",
"Error",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"Trace",
"(",
"result",
".",
"Error",
")",
"\n",
"}",
"\n\n",
"return",
"result",
".",
"Result",
",",
"nil",
"\n",
"}"
] |
// ExportBundle exports the current model configuration.
|
[
"ExportBundle",
"exports",
"the",
"current",
"model",
"configuration",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/bundle/client.go#L34-L49
|
154,378 |
juju/juju
|
state/user.go
|
AddUser
|
func (st *State) AddUser(name, displayName, password, creator string) (*User, error) {
return st.addUser(name, displayName, password, creator, nil)
}
|
go
|
func (st *State) AddUser(name, displayName, password, creator string) (*User, error) {
return st.addUser(name, displayName, password, creator, nil)
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"AddUser",
"(",
"name",
",",
"displayName",
",",
"password",
",",
"creator",
"string",
")",
"(",
"*",
"User",
",",
"error",
")",
"{",
"return",
"st",
".",
"addUser",
"(",
"name",
",",
"displayName",
",",
"password",
",",
"creator",
",",
"nil",
")",
"\n",
"}"
] |
// AddUser adds a user to the database.
|
[
"AddUser",
"adds",
"a",
"user",
"to",
"the",
"database",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L52-L54
|
154,379 |
juju/juju
|
state/user.go
|
AddUserWithSecretKey
|
func (st *State) AddUserWithSecretKey(name, displayName, creator string) (*User, error) {
secretKey, err := generateSecretKey()
if err != nil {
return nil, errors.Trace(err)
}
return st.addUser(name, displayName, "", creator, secretKey)
}
|
go
|
func (st *State) AddUserWithSecretKey(name, displayName, creator string) (*User, error) {
secretKey, err := generateSecretKey()
if err != nil {
return nil, errors.Trace(err)
}
return st.addUser(name, displayName, "", creator, secretKey)
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"AddUserWithSecretKey",
"(",
"name",
",",
"displayName",
",",
"creator",
"string",
")",
"(",
"*",
"User",
",",
"error",
")",
"{",
"secretKey",
",",
"err",
":=",
"generateSecretKey",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"st",
".",
"addUser",
"(",
"name",
",",
"displayName",
",",
"\"",
"\"",
",",
"creator",
",",
"secretKey",
")",
"\n",
"}"
] |
// AddUserWithSecretKey adds the user with the specified name, and assigns it
// a randomly generated secret key. This secret key may be used for the user
// and controller to mutually authenticate one another, without without relying
// on TLS certificates.
//
// The new user will not have a password. A password must be set, clearing the
// secret key in the process, before the user can login normally.
|
[
"AddUserWithSecretKey",
"adds",
"the",
"user",
"with",
"the",
"specified",
"name",
"and",
"assigns",
"it",
"a",
"randomly",
"generated",
"secret",
"key",
".",
"This",
"secret",
"key",
"may",
"be",
"used",
"for",
"the",
"user",
"and",
"controller",
"to",
"mutually",
"authenticate",
"one",
"another",
"without",
"without",
"relying",
"on",
"TLS",
"certificates",
".",
"The",
"new",
"user",
"will",
"not",
"have",
"a",
"password",
".",
"A",
"password",
"must",
"be",
"set",
"clearing",
"the",
"secret",
"key",
"in",
"the",
"process",
"before",
"the",
"user",
"can",
"login",
"normally",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L63-L69
|
154,380 |
juju/juju
|
state/user.go
|
RemoveUser
|
func (st *State) RemoveUser(tag names.UserTag) error {
name := strings.ToLower(tag.Name())
u, err := st.User(tag)
if err != nil {
return errors.Trace(err)
}
if u.IsDeleted() {
return nil
}
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
// If it is not our first attempt, refresh the user.
if err := u.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
ops := []txn.Op{{
Id: name,
C: usersC,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"deleted": true}},
}}
return ops, nil
}
return st.db().Run(buildTxn)
}
|
go
|
func (st *State) RemoveUser(tag names.UserTag) error {
name := strings.ToLower(tag.Name())
u, err := st.User(tag)
if err != nil {
return errors.Trace(err)
}
if u.IsDeleted() {
return nil
}
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
// If it is not our first attempt, refresh the user.
if err := u.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
ops := []txn.Op{{
Id: name,
C: usersC,
Assert: txn.DocExists,
Update: bson.M{"$set": bson.M{"deleted": true}},
}}
return ops, nil
}
return st.db().Run(buildTxn)
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"RemoveUser",
"(",
"tag",
"names",
".",
"UserTag",
")",
"error",
"{",
"name",
":=",
"strings",
".",
"ToLower",
"(",
"tag",
".",
"Name",
"(",
")",
")",
"\n\n",
"u",
",",
"err",
":=",
"st",
".",
"User",
"(",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"IsDeleted",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"buildTxn",
":=",
"func",
"(",
"attempt",
"int",
")",
"(",
"[",
"]",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"if",
"attempt",
">",
"0",
"{",
"// If it is not our first attempt, refresh the user.",
"if",
"err",
":=",
"u",
".",
"Refresh",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"ops",
":=",
"[",
"]",
"txn",
".",
"Op",
"{",
"{",
"Id",
":",
"name",
",",
"C",
":",
"usersC",
",",
"Assert",
":",
"txn",
".",
"DocExists",
",",
"Update",
":",
"bson",
".",
"M",
"{",
"\"",
"\"",
":",
"bson",
".",
"M",
"{",
"\"",
"\"",
":",
"true",
"}",
"}",
",",
"}",
"}",
"\n",
"return",
"ops",
",",
"nil",
"\n",
"}",
"\n",
"return",
"st",
".",
"db",
"(",
")",
".",
"Run",
"(",
"buildTxn",
")",
"\n",
"}"
] |
// RemoveUser marks the user as deleted. This obviates the ability of a user
// to function, but keeps the userDoc retaining provenance, i.e. auditing.
|
[
"RemoveUser",
"marks",
"the",
"user",
"as",
"deleted",
".",
"This",
"obviates",
"the",
"ability",
"of",
"a",
"user",
"to",
"function",
"but",
"keeps",
"the",
"userDoc",
"retaining",
"provenance",
"i",
".",
"e",
".",
"auditing",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L128-L155
|
154,381 |
juju/juju
|
state/user.go
|
getUser
|
func (st *State) getUser(name string, udoc *userDoc) error {
users, closer := st.db().GetCollection(usersC)
defer closer()
name = strings.ToLower(name)
err := users.Find(bson.D{{"_id", name}}).One(udoc)
if err == mgo.ErrNotFound {
err = errors.NotFoundf("user %q", name)
}
// DateCreated is inserted as UTC, but read out as local time. So we
// convert it back to UTC here.
udoc.DateCreated = udoc.DateCreated.UTC()
return err
}
|
go
|
func (st *State) getUser(name string, udoc *userDoc) error {
users, closer := st.db().GetCollection(usersC)
defer closer()
name = strings.ToLower(name)
err := users.Find(bson.D{{"_id", name}}).One(udoc)
if err == mgo.ErrNotFound {
err = errors.NotFoundf("user %q", name)
}
// DateCreated is inserted as UTC, but read out as local time. So we
// convert it back to UTC here.
udoc.DateCreated = udoc.DateCreated.UTC()
return err
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"getUser",
"(",
"name",
"string",
",",
"udoc",
"*",
"userDoc",
")",
"error",
"{",
"users",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"usersC",
")",
"\n",
"defer",
"closer",
"(",
")",
"\n\n",
"name",
"=",
"strings",
".",
"ToLower",
"(",
"name",
")",
"\n",
"err",
":=",
"users",
".",
"Find",
"(",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"name",
"}",
"}",
")",
".",
"One",
"(",
"udoc",
")",
"\n",
"if",
"err",
"==",
"mgo",
".",
"ErrNotFound",
"{",
"err",
"=",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"// DateCreated is inserted as UTC, but read out as local time. So we",
"// convert it back to UTC here.",
"udoc",
".",
"DateCreated",
"=",
"udoc",
".",
"DateCreated",
".",
"UTC",
"(",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// getUser fetches information about the user with the
// given name into the provided userDoc.
|
[
"getUser",
"fetches",
"information",
"about",
"the",
"user",
"with",
"the",
"given",
"name",
"into",
"the",
"provided",
"userDoc",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L189-L202
|
154,382 |
juju/juju
|
state/user.go
|
User
|
func (st *State) User(tag names.UserTag) (*User, error) {
if !tag.IsLocal() {
return nil, errors.NotFoundf("user %q", tag.Id())
}
user := &User{st: st}
if err := st.getUser(tag.Name(), &user.doc); err != nil {
return nil, errors.Trace(err)
}
if user.doc.Deleted {
// This error is returned to the apiserver and from there to the api
// client. So we don't annotate with information regarding deletion.
// TODO(redir): We'll return a deletedUserError in the future so we can
// return more appropriate errors, e.g. username not available.
return nil, DeletedUserError{UserName: user.Name()}
}
return user, nil
}
|
go
|
func (st *State) User(tag names.UserTag) (*User, error) {
if !tag.IsLocal() {
return nil, errors.NotFoundf("user %q", tag.Id())
}
user := &User{st: st}
if err := st.getUser(tag.Name(), &user.doc); err != nil {
return nil, errors.Trace(err)
}
if user.doc.Deleted {
// This error is returned to the apiserver and from there to the api
// client. So we don't annotate with information regarding deletion.
// TODO(redir): We'll return a deletedUserError in the future so we can
// return more appropriate errors, e.g. username not available.
return nil, DeletedUserError{UserName: user.Name()}
}
return user, nil
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"User",
"(",
"tag",
"names",
".",
"UserTag",
")",
"(",
"*",
"User",
",",
"error",
")",
"{",
"if",
"!",
"tag",
".",
"IsLocal",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Id",
"(",
")",
")",
"\n",
"}",
"\n",
"user",
":=",
"&",
"User",
"{",
"st",
":",
"st",
"}",
"\n",
"if",
"err",
":=",
"st",
".",
"getUser",
"(",
"tag",
".",
"Name",
"(",
")",
",",
"&",
"user",
".",
"doc",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"user",
".",
"doc",
".",
"Deleted",
"{",
"// This error is returned to the apiserver and from there to the api",
"// client. So we don't annotate with information regarding deletion.",
"// TODO(redir): We'll return a deletedUserError in the future so we can",
"// return more appropriate errors, e.g. username not available.",
"return",
"nil",
",",
"DeletedUserError",
"{",
"UserName",
":",
"user",
".",
"Name",
"(",
")",
"}",
"\n",
"}",
"\n",
"return",
"user",
",",
"nil",
"\n",
"}"
] |
// User returns the state User for the given name.
|
[
"User",
"returns",
"the",
"state",
"User",
"for",
"the",
"given",
"name",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L205-L221
|
154,383 |
juju/juju
|
state/user.go
|
AllUsers
|
func (st *State) AllUsers(includeDeactivated bool) ([]*User, error) {
var result []*User
users, closer := st.db().GetCollection(usersC)
defer closer()
var query bson.D
// TODO(redir): Provide option to retrieve deleted users in future PR.
// e.g. if !includeDelted.
// Ensure the query checks for users without the deleted attribute, and
// also that if it does that the value is not true. fwereade wanted to be
// sure we cannot miss users that previously existed without the deleted
// attr. Since this will only be in 2.0 that should never happen, but...
// belt and suspenders.
query = append(query, bson.DocElem{
"deleted", bson.D{{"$ne", true}},
})
// As above, in the case that a user previously existed and doesn't have a
// deactivated attribute, we make sure the query checks for the existence
// of the attribute, and if it exists that it is not true.
if !includeDeactivated {
query = append(query, bson.DocElem{
"deactivated", bson.D{{"$ne", true}},
})
}
iter := users.Find(query).Iter()
defer iter.Close()
var doc userDoc
for iter.Next(&doc) {
result = append(result, &User{st: st, doc: doc})
}
if err := iter.Close(); err != nil {
return nil, errors.Trace(err)
}
// Always return a predictable order, sort by Name.
sort.Sort(userList(result))
return result, nil
}
|
go
|
func (st *State) AllUsers(includeDeactivated bool) ([]*User, error) {
var result []*User
users, closer := st.db().GetCollection(usersC)
defer closer()
var query bson.D
// TODO(redir): Provide option to retrieve deleted users in future PR.
// e.g. if !includeDelted.
// Ensure the query checks for users without the deleted attribute, and
// also that if it does that the value is not true. fwereade wanted to be
// sure we cannot miss users that previously existed without the deleted
// attr. Since this will only be in 2.0 that should never happen, but...
// belt and suspenders.
query = append(query, bson.DocElem{
"deleted", bson.D{{"$ne", true}},
})
// As above, in the case that a user previously existed and doesn't have a
// deactivated attribute, we make sure the query checks for the existence
// of the attribute, and if it exists that it is not true.
if !includeDeactivated {
query = append(query, bson.DocElem{
"deactivated", bson.D{{"$ne", true}},
})
}
iter := users.Find(query).Iter()
defer iter.Close()
var doc userDoc
for iter.Next(&doc) {
result = append(result, &User{st: st, doc: doc})
}
if err := iter.Close(); err != nil {
return nil, errors.Trace(err)
}
// Always return a predictable order, sort by Name.
sort.Sort(userList(result))
return result, nil
}
|
[
"func",
"(",
"st",
"*",
"State",
")",
"AllUsers",
"(",
"includeDeactivated",
"bool",
")",
"(",
"[",
"]",
"*",
"User",
",",
"error",
")",
"{",
"var",
"result",
"[",
"]",
"*",
"User",
"\n\n",
"users",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"usersC",
")",
"\n",
"defer",
"closer",
"(",
")",
"\n\n",
"var",
"query",
"bson",
".",
"D",
"\n",
"// TODO(redir): Provide option to retrieve deleted users in future PR.",
"// e.g. if !includeDelted.",
"// Ensure the query checks for users without the deleted attribute, and",
"// also that if it does that the value is not true. fwereade wanted to be",
"// sure we cannot miss users that previously existed without the deleted",
"// attr. Since this will only be in 2.0 that should never happen, but...",
"// belt and suspenders.",
"query",
"=",
"append",
"(",
"query",
",",
"bson",
".",
"DocElem",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"true",
"}",
"}",
",",
"}",
")",
"\n\n",
"// As above, in the case that a user previously existed and doesn't have a",
"// deactivated attribute, we make sure the query checks for the existence",
"// of the attribute, and if it exists that it is not true.",
"if",
"!",
"includeDeactivated",
"{",
"query",
"=",
"append",
"(",
"query",
",",
"bson",
".",
"DocElem",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"true",
"}",
"}",
",",
"}",
")",
"\n",
"}",
"\n",
"iter",
":=",
"users",
".",
"Find",
"(",
"query",
")",
".",
"Iter",
"(",
")",
"\n",
"defer",
"iter",
".",
"Close",
"(",
")",
"\n\n",
"var",
"doc",
"userDoc",
"\n",
"for",
"iter",
".",
"Next",
"(",
"&",
"doc",
")",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"&",
"User",
"{",
"st",
":",
"st",
",",
"doc",
":",
"doc",
"}",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"iter",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"// Always return a predictable order, sort by Name.",
"sort",
".",
"Sort",
"(",
"userList",
"(",
"result",
")",
")",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] |
// AllUsers returns a slice of state.User. This includes all active users. If
// includeDeactivated is true it also returns inactive users. At this point it
// never returns deleted users.
|
[
"AllUsers",
"returns",
"a",
"slice",
"of",
"state",
".",
"User",
".",
"This",
"includes",
"all",
"active",
"users",
".",
"If",
"includeDeactivated",
"is",
"true",
"it",
"also",
"returns",
"inactive",
"users",
".",
"At",
"this",
"point",
"it",
"never",
"returns",
"deleted",
"users",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L226-L265
|
154,384 |
juju/juju
|
state/user.go
|
UserTag
|
func (u *User) UserTag() names.UserTag {
name := u.doc.Name
return names.NewLocalUserTag(name)
}
|
go
|
func (u *User) UserTag() names.UserTag {
name := u.doc.Name
return names.NewLocalUserTag(name)
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"UserTag",
"(",
")",
"names",
".",
"UserTag",
"{",
"name",
":=",
"u",
".",
"doc",
".",
"Name",
"\n",
"return",
"names",
".",
"NewLocalUserTag",
"(",
"name",
")",
"\n",
"}"
] |
// UserTag returns the Tag for the User.
|
[
"UserTag",
"returns",
"the",
"Tag",
"for",
"the",
"User",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L330-L333
|
154,385 |
juju/juju
|
state/user.go
|
LastLogin
|
func (u *User) LastLogin() (time.Time, error) {
lastLogins, closer := u.st.db().GetRawCollection(userLastLoginC)
defer closer()
var lastLogin userLastLoginDoc
err := lastLogins.FindId(u.doc.DocID).Select(bson.D{{"last-login", 1}}).One(&lastLogin)
if err != nil {
if err == mgo.ErrNotFound {
err = errors.Wrap(err, NeverLoggedInError(u.UserTag().Name()))
}
return time.Time{}, errors.Trace(err)
}
return lastLogin.LastLogin.UTC(), nil
}
|
go
|
func (u *User) LastLogin() (time.Time, error) {
lastLogins, closer := u.st.db().GetRawCollection(userLastLoginC)
defer closer()
var lastLogin userLastLoginDoc
err := lastLogins.FindId(u.doc.DocID).Select(bson.D{{"last-login", 1}}).One(&lastLogin)
if err != nil {
if err == mgo.ErrNotFound {
err = errors.Wrap(err, NeverLoggedInError(u.UserTag().Name()))
}
return time.Time{}, errors.Trace(err)
}
return lastLogin.LastLogin.UTC(), nil
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"LastLogin",
"(",
")",
"(",
"time",
".",
"Time",
",",
"error",
")",
"{",
"lastLogins",
",",
"closer",
":=",
"u",
".",
"st",
".",
"db",
"(",
")",
".",
"GetRawCollection",
"(",
"userLastLoginC",
")",
"\n",
"defer",
"closer",
"(",
")",
"\n\n",
"var",
"lastLogin",
"userLastLoginDoc",
"\n",
"err",
":=",
"lastLogins",
".",
"FindId",
"(",
"u",
".",
"doc",
".",
"DocID",
")",
".",
"Select",
"(",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"1",
"}",
"}",
")",
".",
"One",
"(",
"&",
"lastLogin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"mgo",
".",
"ErrNotFound",
"{",
"err",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"NeverLoggedInError",
"(",
"u",
".",
"UserTag",
"(",
")",
".",
"Name",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"time",
".",
"Time",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"lastLogin",
".",
"LastLogin",
".",
"UTC",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// LastLogin returns when this User last connected through the API in UTC.
// The resulting time will be nil if the user has never logged in. In the
// normal case, the LastLogin is the last time that the user connected through
// the API server.
|
[
"LastLogin",
"returns",
"when",
"this",
"User",
"last",
"connected",
"through",
"the",
"API",
"in",
"UTC",
".",
"The",
"resulting",
"time",
"will",
"be",
"nil",
"if",
"the",
"user",
"has",
"never",
"logged",
"in",
".",
"In",
"the",
"normal",
"case",
"the",
"LastLogin",
"is",
"the",
"last",
"time",
"that",
"the",
"user",
"connected",
"through",
"the",
"API",
"server",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L339-L353
|
154,386 |
juju/juju
|
state/user.go
|
IsNeverLoggedInError
|
func IsNeverLoggedInError(err error) bool {
_, ok := errors.Cause(err).(NeverLoggedInError)
return ok
}
|
go
|
func IsNeverLoggedInError(err error) bool {
_, ok := errors.Cause(err).(NeverLoggedInError)
return ok
}
|
[
"func",
"IsNeverLoggedInError",
"(",
"err",
"error",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"errors",
".",
"Cause",
"(",
"err",
")",
".",
"(",
"NeverLoggedInError",
")",
"\n",
"return",
"ok",
"\n",
"}"
] |
// IsNeverLoggedInError returns true if err is of type NeverLoggedInError.
|
[
"IsNeverLoggedInError",
"returns",
"true",
"if",
"err",
"is",
"of",
"type",
"NeverLoggedInError",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L365-L368
|
154,387 |
juju/juju
|
state/user.go
|
SetPassword
|
func (u *User) SetPassword(password string) error {
if err := u.ensureNotDeleted(); err != nil {
return errors.Annotate(err, "cannot set password")
}
salt, err := utils.RandomSalt()
if err != nil {
return err
}
return u.SetPasswordHash(utils.UserPasswordHash(password, salt), salt)
}
|
go
|
func (u *User) SetPassword(password string) error {
if err := u.ensureNotDeleted(); err != nil {
return errors.Annotate(err, "cannot set password")
}
salt, err := utils.RandomSalt()
if err != nil {
return err
}
return u.SetPasswordHash(utils.UserPasswordHash(password, salt), salt)
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"SetPassword",
"(",
"password",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"u",
".",
"ensureNotDeleted",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"salt",
",",
"err",
":=",
"utils",
".",
"RandomSalt",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"u",
".",
"SetPasswordHash",
"(",
"utils",
".",
"UserPasswordHash",
"(",
"password",
",",
"salt",
")",
",",
"salt",
")",
"\n",
"}"
] |
// SetPassword sets the password associated with the User.
|
[
"SetPassword",
"sets",
"the",
"password",
"associated",
"with",
"the",
"User",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L402-L411
|
154,388 |
juju/juju
|
state/user.go
|
SetPasswordHash
|
func (u *User) SetPasswordHash(pwHash string, pwSalt string) error {
if err := u.ensureNotDeleted(); err != nil {
// If we do get a late set of the password this is fine b/c we have an
// explicit check before login.
return errors.Annotate(err, "cannot set password hash")
}
update := bson.D{{"$set", bson.D{
{"passwordhash", pwHash},
{"passwordsalt", pwSalt},
}}}
if u.doc.SecretKey != nil {
update = append(update,
bson.DocElem{"$unset", bson.D{{"secretkey", ""}}},
)
}
ops := []txn.Op{{
C: usersC,
Id: u.Name(),
Assert: txn.DocExists,
Update: update,
}}
if err := u.st.db().RunTransaction(ops); err != nil {
return errors.Annotatef(err, "cannot set password of user %q", u.Name())
}
u.doc.PasswordHash = pwHash
u.doc.PasswordSalt = pwSalt
u.doc.SecretKey = nil
return nil
}
|
go
|
func (u *User) SetPasswordHash(pwHash string, pwSalt string) error {
if err := u.ensureNotDeleted(); err != nil {
// If we do get a late set of the password this is fine b/c we have an
// explicit check before login.
return errors.Annotate(err, "cannot set password hash")
}
update := bson.D{{"$set", bson.D{
{"passwordhash", pwHash},
{"passwordsalt", pwSalt},
}}}
if u.doc.SecretKey != nil {
update = append(update,
bson.DocElem{"$unset", bson.D{{"secretkey", ""}}},
)
}
ops := []txn.Op{{
C: usersC,
Id: u.Name(),
Assert: txn.DocExists,
Update: update,
}}
if err := u.st.db().RunTransaction(ops); err != nil {
return errors.Annotatef(err, "cannot set password of user %q", u.Name())
}
u.doc.PasswordHash = pwHash
u.doc.PasswordSalt = pwSalt
u.doc.SecretKey = nil
return nil
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"SetPasswordHash",
"(",
"pwHash",
"string",
",",
"pwSalt",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"u",
".",
"ensureNotDeleted",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"// If we do get a late set of the password this is fine b/c we have an",
"// explicit check before login.",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"update",
":=",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"pwHash",
"}",
",",
"{",
"\"",
"\"",
",",
"pwSalt",
"}",
",",
"}",
"}",
"}",
"\n",
"if",
"u",
".",
"doc",
".",
"SecretKey",
"!=",
"nil",
"{",
"update",
"=",
"append",
"(",
"update",
",",
"bson",
".",
"DocElem",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"}",
"}",
",",
")",
"\n",
"}",
"\n",
"ops",
":=",
"[",
"]",
"txn",
".",
"Op",
"{",
"{",
"C",
":",
"usersC",
",",
"Id",
":",
"u",
".",
"Name",
"(",
")",
",",
"Assert",
":",
"txn",
".",
"DocExists",
",",
"Update",
":",
"update",
",",
"}",
"}",
"\n",
"if",
"err",
":=",
"u",
".",
"st",
".",
"db",
"(",
")",
".",
"RunTransaction",
"(",
"ops",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"u",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"u",
".",
"doc",
".",
"PasswordHash",
"=",
"pwHash",
"\n",
"u",
".",
"doc",
".",
"PasswordSalt",
"=",
"pwSalt",
"\n",
"u",
".",
"doc",
".",
"SecretKey",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SetPasswordHash stores the hash and the salt of the
// password. If the User has a secret key set then it
// will be cleared.
|
[
"SetPasswordHash",
"stores",
"the",
"hash",
"and",
"the",
"salt",
"of",
"the",
"password",
".",
"If",
"the",
"User",
"has",
"a",
"secret",
"key",
"set",
"then",
"it",
"will",
"be",
"cleared",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L416-L444
|
154,389 |
juju/juju
|
state/user.go
|
PasswordValid
|
func (u *User) PasswordValid(password string) bool {
// If the User is deactivated or deleted, there is no point in carrying on.
// Since any authentication checks are done very soon after the user is
// read from the database, there is a very small timeframe where an user
// could be disabled after it has been read but prior to being checked, but
// in practice, this isn't a problem.
if u.IsDisabled() || u.IsDeleted() {
return false
}
if u.doc.PasswordSalt != "" {
return utils.UserPasswordHash(password, u.doc.PasswordSalt) == u.doc.PasswordHash
}
return false
}
|
go
|
func (u *User) PasswordValid(password string) bool {
// If the User is deactivated or deleted, there is no point in carrying on.
// Since any authentication checks are done very soon after the user is
// read from the database, there is a very small timeframe where an user
// could be disabled after it has been read but prior to being checked, but
// in practice, this isn't a problem.
if u.IsDisabled() || u.IsDeleted() {
return false
}
if u.doc.PasswordSalt != "" {
return utils.UserPasswordHash(password, u.doc.PasswordSalt) == u.doc.PasswordHash
}
return false
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"PasswordValid",
"(",
"password",
"string",
")",
"bool",
"{",
"// If the User is deactivated or deleted, there is no point in carrying on.",
"// Since any authentication checks are done very soon after the user is",
"// read from the database, there is a very small timeframe where an user",
"// could be disabled after it has been read but prior to being checked, but",
"// in practice, this isn't a problem.",
"if",
"u",
".",
"IsDisabled",
"(",
")",
"||",
"u",
".",
"IsDeleted",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"u",
".",
"doc",
".",
"PasswordSalt",
"!=",
"\"",
"\"",
"{",
"return",
"utils",
".",
"UserPasswordHash",
"(",
"password",
",",
"u",
".",
"doc",
".",
"PasswordSalt",
")",
"==",
"u",
".",
"doc",
".",
"PasswordHash",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// PasswordValid returns whether the given password is valid for the User. The
// caller should call user.Refresh before calling this.
|
[
"PasswordValid",
"returns",
"whether",
"the",
"given",
"password",
"is",
"valid",
"for",
"the",
"User",
".",
"The",
"caller",
"should",
"call",
"user",
".",
"Refresh",
"before",
"calling",
"this",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L448-L461
|
154,390 |
juju/juju
|
state/user.go
|
Refresh
|
func (u *User) Refresh() error {
var udoc userDoc
if err := u.st.getUser(u.Name(), &udoc); err != nil {
return err
}
u.doc = udoc
return nil
}
|
go
|
func (u *User) Refresh() error {
var udoc userDoc
if err := u.st.getUser(u.Name(), &udoc); err != nil {
return err
}
u.doc = udoc
return nil
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"Refresh",
"(",
")",
"error",
"{",
"var",
"udoc",
"userDoc",
"\n",
"if",
"err",
":=",
"u",
".",
"st",
".",
"getUser",
"(",
"u",
".",
"Name",
"(",
")",
",",
"&",
"udoc",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"u",
".",
"doc",
"=",
"udoc",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Refresh refreshes information about the User from the state.
|
[
"Refresh",
"refreshes",
"information",
"about",
"the",
"User",
"from",
"the",
"state",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L464-L471
|
154,391 |
juju/juju
|
state/user.go
|
Disable
|
func (u *User) Disable() error {
if err := u.ensureNotDeleted(); err != nil {
return errors.Annotate(err, "cannot disable")
}
owner, err := u.st.ControllerOwner()
if err != nil {
return errors.Trace(err)
}
if u.doc.Name == owner.Name() {
return errors.Unauthorizedf("cannot disable controller model owner")
}
return errors.Annotatef(u.setDeactivated(true), "cannot disable user %q", u.Name())
}
|
go
|
func (u *User) Disable() error {
if err := u.ensureNotDeleted(); err != nil {
return errors.Annotate(err, "cannot disable")
}
owner, err := u.st.ControllerOwner()
if err != nil {
return errors.Trace(err)
}
if u.doc.Name == owner.Name() {
return errors.Unauthorizedf("cannot disable controller model owner")
}
return errors.Annotatef(u.setDeactivated(true), "cannot disable user %q", u.Name())
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"Disable",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"u",
".",
"ensureNotDeleted",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"owner",
",",
"err",
":=",
"u",
".",
"st",
".",
"ControllerOwner",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"doc",
".",
"Name",
"==",
"owner",
".",
"Name",
"(",
")",
"{",
"return",
"errors",
".",
"Unauthorizedf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"errors",
".",
"Annotatef",
"(",
"u",
".",
"setDeactivated",
"(",
"true",
")",
",",
"\"",
"\"",
",",
"u",
".",
"Name",
"(",
")",
")",
"\n",
"}"
] |
// Disable deactivates the user. Disabled identities cannot log in.
|
[
"Disable",
"deactivates",
"the",
"user",
".",
"Disabled",
"identities",
"cannot",
"log",
"in",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L474-L486
|
154,392 |
juju/juju
|
state/user.go
|
Enable
|
func (u *User) Enable() error {
if err := u.ensureNotDeleted(); err != nil {
return errors.Annotate(err, "cannot enable")
}
return errors.Annotatef(u.setDeactivated(false), "cannot enable user %q", u.Name())
}
|
go
|
func (u *User) Enable() error {
if err := u.ensureNotDeleted(); err != nil {
return errors.Annotate(err, "cannot enable")
}
return errors.Annotatef(u.setDeactivated(false), "cannot enable user %q", u.Name())
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"Enable",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"u",
".",
"ensureNotDeleted",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"errors",
".",
"Annotatef",
"(",
"u",
".",
"setDeactivated",
"(",
"false",
")",
",",
"\"",
"\"",
",",
"u",
".",
"Name",
"(",
")",
")",
"\n",
"}"
] |
// Enable reactivates the user, setting disabled to false.
|
[
"Enable",
"reactivates",
"the",
"user",
"setting",
"disabled",
"to",
"false",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L489-L494
|
154,393 |
juju/juju
|
state/user.go
|
ensureNotDeleted
|
func (u *User) ensureNotDeleted() error {
if err := u.Refresh(); err != nil {
return errors.Trace(err)
}
if u.doc.Deleted {
return DeletedUserError{u.Name()}
}
return nil
}
|
go
|
func (u *User) ensureNotDeleted() error {
if err := u.Refresh(); err != nil {
return errors.Trace(err)
}
if u.doc.Deleted {
return DeletedUserError{u.Name()}
}
return nil
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"ensureNotDeleted",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"u",
".",
"Refresh",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"doc",
".",
"Deleted",
"{",
"return",
"DeletedUserError",
"{",
"u",
".",
"Name",
"(",
")",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ensureNotDeleted refreshes the user to ensure it wasn't deleted since we
// acquired it.
|
[
"ensureNotDeleted",
"refreshes",
"the",
"user",
"to",
"ensure",
"it",
"wasn",
"t",
"deleted",
"since",
"we",
"acquired",
"it",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L538-L546
|
154,394 |
juju/juju
|
state/user.go
|
generateSecretKey
|
func generateSecretKey() ([]byte, error) {
var secretKey [32]byte
if _, err := rand.Read(secretKey[:]); err != nil {
return nil, errors.Trace(err)
}
return secretKey[:], nil
}
|
go
|
func generateSecretKey() ([]byte, error) {
var secretKey [32]byte
if _, err := rand.Read(secretKey[:]); err != nil {
return nil, errors.Trace(err)
}
return secretKey[:], nil
}
|
[
"func",
"generateSecretKey",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"secretKey",
"[",
"32",
"]",
"byte",
"\n",
"if",
"_",
",",
"err",
":=",
"rand",
".",
"Read",
"(",
"secretKey",
"[",
":",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"secretKey",
"[",
":",
"]",
",",
"nil",
"\n",
"}"
] |
// generateSecretKey generates a random, 32-byte secret key.
|
[
"generateSecretKey",
"generates",
"a",
"random",
"32",
"-",
"byte",
"secret",
"key",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/user.go#L595-L601
|
154,395 |
juju/juju
|
worker/logger/logger.go
|
NewLogger
|
func NewLogger(api LoggerAPI, tag names.Tag, loggingOverride string, updateCallback func(string) error) (worker.Worker, error) {
logger := &Logger{
api: api,
tag: tag,
updateCallback: updateCallback,
lastConfig: loggo.LoggerInfo(),
configOverride: loggingOverride,
}
log.Debugf("initial log config: %q", logger.lastConfig)
w, err := watcher.NewNotifyWorker(watcher.NotifyConfig{
Handler: logger,
})
if err != nil {
return nil, errors.Trace(err)
}
return w, nil
}
|
go
|
func NewLogger(api LoggerAPI, tag names.Tag, loggingOverride string, updateCallback func(string) error) (worker.Worker, error) {
logger := &Logger{
api: api,
tag: tag,
updateCallback: updateCallback,
lastConfig: loggo.LoggerInfo(),
configOverride: loggingOverride,
}
log.Debugf("initial log config: %q", logger.lastConfig)
w, err := watcher.NewNotifyWorker(watcher.NotifyConfig{
Handler: logger,
})
if err != nil {
return nil, errors.Trace(err)
}
return w, nil
}
|
[
"func",
"NewLogger",
"(",
"api",
"LoggerAPI",
",",
"tag",
"names",
".",
"Tag",
",",
"loggingOverride",
"string",
",",
"updateCallback",
"func",
"(",
"string",
")",
"error",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"logger",
":=",
"&",
"Logger",
"{",
"api",
":",
"api",
",",
"tag",
":",
"tag",
",",
"updateCallback",
":",
"updateCallback",
",",
"lastConfig",
":",
"loggo",
".",
"LoggerInfo",
"(",
")",
",",
"configOverride",
":",
"loggingOverride",
",",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"logger",
".",
"lastConfig",
")",
"\n\n",
"w",
",",
"err",
":=",
"watcher",
".",
"NewNotifyWorker",
"(",
"watcher",
".",
"NotifyConfig",
"{",
"Handler",
":",
"logger",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"w",
",",
"nil",
"\n",
"}"
] |
// NewLogger returns a worker.Worker that uses the notify watcher returned
// from the setup.
|
[
"NewLogger",
"returns",
"a",
"worker",
".",
"Worker",
"that",
"uses",
"the",
"notify",
"watcher",
"returned",
"from",
"the",
"setup",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/logger/logger.go#L35-L52
|
154,396 |
juju/juju
|
upgrades/steps_24.go
|
stateStepsFor24
|
func stateStepsFor24() []Step {
return []Step{
&upgradeStep{
description: "move or drop the old audit log collection",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().MoveOldAuditLog()
},
},
&upgradeStep{
description: "move controller info Mongo space to controller config HA space if valid",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().MoveMongoSpaceToHASpaceConfig()
},
},
&upgradeStep{
description: "create empty application settings for all applications",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().CreateMissingApplicationConfig()
},
},
&upgradeStep{
description: "remove votingmachineids",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().RemoveVotingMachineIds()
},
},
&upgradeStep{
description: "add cloud model counts",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().AddCloudModelCounts()
},
},
&upgradeStep{
description: "bootstrap raft cluster",
targets: []Target{Controller},
run: BootstrapRaft,
},
}
}
|
go
|
func stateStepsFor24() []Step {
return []Step{
&upgradeStep{
description: "move or drop the old audit log collection",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().MoveOldAuditLog()
},
},
&upgradeStep{
description: "move controller info Mongo space to controller config HA space if valid",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().MoveMongoSpaceToHASpaceConfig()
},
},
&upgradeStep{
description: "create empty application settings for all applications",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().CreateMissingApplicationConfig()
},
},
&upgradeStep{
description: "remove votingmachineids",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().RemoveVotingMachineIds()
},
},
&upgradeStep{
description: "add cloud model counts",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().AddCloudModelCounts()
},
},
&upgradeStep{
description: "bootstrap raft cluster",
targets: []Target{Controller},
run: BootstrapRaft,
},
}
}
|
[
"func",
"stateStepsFor24",
"(",
")",
"[",
"]",
"Step",
"{",
"return",
"[",
"]",
"Step",
"{",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"DatabaseMaster",
"}",
",",
"run",
":",
"func",
"(",
"context",
"Context",
")",
"error",
"{",
"return",
"context",
".",
"State",
"(",
")",
".",
"MoveOldAuditLog",
"(",
")",
"\n",
"}",
",",
"}",
",",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"DatabaseMaster",
"}",
",",
"run",
":",
"func",
"(",
"context",
"Context",
")",
"error",
"{",
"return",
"context",
".",
"State",
"(",
")",
".",
"MoveMongoSpaceToHASpaceConfig",
"(",
")",
"\n",
"}",
",",
"}",
",",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"DatabaseMaster",
"}",
",",
"run",
":",
"func",
"(",
"context",
"Context",
")",
"error",
"{",
"return",
"context",
".",
"State",
"(",
")",
".",
"CreateMissingApplicationConfig",
"(",
")",
"\n",
"}",
",",
"}",
",",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"DatabaseMaster",
"}",
",",
"run",
":",
"func",
"(",
"context",
"Context",
")",
"error",
"{",
"return",
"context",
".",
"State",
"(",
")",
".",
"RemoveVotingMachineIds",
"(",
")",
"\n",
"}",
",",
"}",
",",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"DatabaseMaster",
"}",
",",
"run",
":",
"func",
"(",
"context",
"Context",
")",
"error",
"{",
"return",
"context",
".",
"State",
"(",
")",
".",
"AddCloudModelCounts",
"(",
")",
"\n",
"}",
",",
"}",
",",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"Controller",
"}",
",",
"run",
":",
"BootstrapRaft",
",",
"}",
",",
"}",
"\n",
"}"
] |
// stateStepsFor24 returns upgrade steps for Juju 2.4.0 that manipulate state directly.
|
[
"stateStepsFor24",
"returns",
"upgrade",
"steps",
"for",
"Juju",
"2",
".",
"4",
".",
"0",
"that",
"manipulate",
"state",
"directly",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/upgrades/steps_24.go#L17-L60
|
154,397 |
juju/juju
|
upgrades/steps_24.go
|
stepsFor24
|
func stepsFor24() []Step {
return []Step{
&upgradeStep{
description: "Install the service file in Standard location '/lib/systemd'",
targets: []Target{AllMachines},
run: installServiceFile,
},
}
}
|
go
|
func stepsFor24() []Step {
return []Step{
&upgradeStep{
description: "Install the service file in Standard location '/lib/systemd'",
targets: []Target{AllMachines},
run: installServiceFile,
},
}
}
|
[
"func",
"stepsFor24",
"(",
")",
"[",
"]",
"Step",
"{",
"return",
"[",
"]",
"Step",
"{",
"&",
"upgradeStep",
"{",
"description",
":",
"\"",
"\"",
",",
"targets",
":",
"[",
"]",
"Target",
"{",
"AllMachines",
"}",
",",
"run",
":",
"installServiceFile",
",",
"}",
",",
"}",
"\n",
"}"
] |
// stepsFor24 returns upgrade steps for Juju 2.4.
|
[
"stepsFor24",
"returns",
"upgrade",
"steps",
"for",
"Juju",
"2",
".",
"4",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/upgrades/steps_24.go#L63-L71
|
154,398 |
juju/juju
|
cmd/juju/romulus/commands/commands.go
|
RegisterAll
|
func RegisterAll(r commandRegister) {
r.Register(agree.NewAgreeCommand())
r.Register(listagreements.NewListAgreementsCommand())
r.Register(budget.NewBudgetCommand())
r.Register(createwallet.NewCreateWalletCommand())
r.Register(listplans.NewListPlansCommand())
r.Register(setwallet.NewSetWalletCommand())
r.Register(setplan.NewSetPlanCommand())
r.Register(showwallet.NewShowWalletCommand())
r.Register(sla.NewSLACommand())
r.Register(listwallets.NewListWalletsCommand())
}
|
go
|
func RegisterAll(r commandRegister) {
r.Register(agree.NewAgreeCommand())
r.Register(listagreements.NewListAgreementsCommand())
r.Register(budget.NewBudgetCommand())
r.Register(createwallet.NewCreateWalletCommand())
r.Register(listplans.NewListPlansCommand())
r.Register(setwallet.NewSetWalletCommand())
r.Register(setplan.NewSetPlanCommand())
r.Register(showwallet.NewShowWalletCommand())
r.Register(sla.NewSLACommand())
r.Register(listwallets.NewListWalletsCommand())
}
|
[
"func",
"RegisterAll",
"(",
"r",
"commandRegister",
")",
"{",
"r",
".",
"Register",
"(",
"agree",
".",
"NewAgreeCommand",
"(",
")",
")",
"\n",
"r",
".",
"Register",
"(",
"listagreements",
".",
"NewListAgreementsCommand",
"(",
")",
")",
"\n",
"r",
".",
"Register",
"(",
"budget",
".",
"NewBudgetCommand",
"(",
")",
")",
"\n",
"r",
".",
"Register",
"(",
"createwallet",
".",
"NewCreateWalletCommand",
"(",
")",
")",
"\n",
"r",
".",
"Register",
"(",
"listplans",
".",
"NewListPlansCommand",
"(",
")",
")",
"\n",
"r",
".",
"Register",
"(",
"setwallet",
".",
"NewSetWalletCommand",
"(",
")",
")",
"\n",
"r",
".",
"Register",
"(",
"setplan",
".",
"NewSetPlanCommand",
"(",
")",
")",
"\n",
"r",
".",
"Register",
"(",
"showwallet",
".",
"NewShowWalletCommand",
"(",
")",
")",
"\n",
"r",
".",
"Register",
"(",
"sla",
".",
"NewSLACommand",
"(",
")",
")",
"\n",
"r",
".",
"Register",
"(",
"listwallets",
".",
"NewListWalletsCommand",
"(",
")",
")",
"\n",
"}"
] |
// RegisterAll registers all romulus commands with the
// provided command registry.
|
[
"RegisterAll",
"registers",
"all",
"romulus",
"commands",
"with",
"the",
"provided",
"command",
"registry",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/romulus/commands/commands.go#L28-L39
|
154,399 |
juju/juju
|
migration/dialopts.go
|
ControllerDialOpts
|
func ControllerDialOpts() api.DialOpts {
return api.DialOpts{
DialAddressInterval: 50 * time.Millisecond,
Timeout: 1 * time.Second,
RetryDelay: 100 * time.Millisecond,
}
}
|
go
|
func ControllerDialOpts() api.DialOpts {
return api.DialOpts{
DialAddressInterval: 50 * time.Millisecond,
Timeout: 1 * time.Second,
RetryDelay: 100 * time.Millisecond,
}
}
|
[
"func",
"ControllerDialOpts",
"(",
")",
"api",
".",
"DialOpts",
"{",
"return",
"api",
".",
"DialOpts",
"{",
"DialAddressInterval",
":",
"50",
"*",
"time",
".",
"Millisecond",
",",
"Timeout",
":",
"1",
"*",
"time",
".",
"Second",
",",
"RetryDelay",
":",
"100",
"*",
"time",
".",
"Millisecond",
",",
"}",
"\n",
"}"
] |
// ControllerDialOpts returns dial parameters suitable for connecting
// from the source controller to the target controller during model
// migrations. The total attempt time can't be too long because the
// areas of the code which make these connections need to be
// interruptable but a number of retries is useful to deal with short
// lived issues.
|
[
"ControllerDialOpts",
"returns",
"dial",
"parameters",
"suitable",
"for",
"connecting",
"from",
"the",
"source",
"controller",
"to",
"the",
"target",
"controller",
"during",
"model",
"migrations",
".",
"The",
"total",
"attempt",
"time",
"can",
"t",
"be",
"too",
"long",
"because",
"the",
"areas",
"of",
"the",
"code",
"which",
"make",
"these",
"connections",
"need",
"to",
"be",
"interruptable",
"but",
"a",
"number",
"of",
"retries",
"is",
"useful",
"to",
"deal",
"with",
"short",
"lived",
"issues",
"."
] |
ba728eedb1e44937c7bdc59f374b06400d0c7133
|
https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/migration/dialopts.go#L18-L24
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.