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
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
157,500 | juju/juju | resource/resourceadapters/charmstore.go | SetResource | func (cache *charmstoreEntityCache) SetResource(chRes charmresource.Resource, reader io.Reader) (resource.Resource, error) {
return cache.st.SetResource(cache.applicationID, cache.userID.Id(), chRes, reader)
} | go | func (cache *charmstoreEntityCache) SetResource(chRes charmresource.Resource, reader io.Reader) (resource.Resource, error) {
return cache.st.SetResource(cache.applicationID, cache.userID.Id(), chRes, reader)
} | [
"func",
"(",
"cache",
"*",
"charmstoreEntityCache",
")",
"SetResource",
"(",
"chRes",
"charmresource",
".",
"Resource",
",",
"reader",
"io",
".",
"Reader",
")",
"(",
"resource",
".",
"Resource",
",",
"error",
")",
"{",
"return",
"cache",
".",
"st",
".",
"SetResource",
"(",
"cache",
".",
"applicationID",
",",
"cache",
".",
"userID",
".",
"Id",
"(",
")",
",",
"chRes",
",",
"reader",
")",
"\n",
"}"
] | // SetResource implements charmstore.EntityCache. | [
"SetResource",
"implements",
"charmstore",
".",
"EntityCache",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/resource/resourceadapters/charmstore.go#L35-L37 |
157,501 | juju/juju | resource/resourceadapters/charmstore.go | OpenResource | func (cache *charmstoreEntityCache) OpenResource(name string) (resource.Resource, io.ReadCloser, error) {
if cache.unit == nil {
return resource.Resource{}, nil, errors.NotImplementedf("")
}
return cache.st.OpenResourceForUniter(cache.unit, name)
} | go | func (cache *charmstoreEntityCache) OpenResource(name string) (resource.Resource, io.ReadCloser, error) {
if cache.unit == nil {
return resource.Resource{}, nil, errors.NotImplementedf("")
}
return cache.st.OpenResourceForUniter(cache.unit, name)
} | [
"func",
"(",
"cache",
"*",
"charmstoreEntityCache",
")",
"OpenResource",
"(",
"name",
"string",
")",
"(",
"resource",
".",
"Resource",
",",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"if",
"cache",
".",
"unit",
"==",
"nil",
"{",
"return",
"resource",
".",
"Resource",
"{",
"}",
",",
"nil",
",",
"errors",
".",
"NotImplementedf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"cache",
".",
"st",
".",
"OpenResourceForUniter",
"(",
"cache",
".",
"unit",
",",
"name",
")",
"\n",
"}"
] | // OpenResource implements charmstore.EntityCache. | [
"OpenResource",
"implements",
"charmstore",
".",
"EntityCache",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/resource/resourceadapters/charmstore.go#L40-L45 |
157,502 | juju/juju | resource/resourceadapters/charmstore.go | NewClient | func (cs *charmstoreOpener) NewClient() (*CSRetryClient, error) {
// TODO(ericsnow) Use a valid charm store client.
client, err := newCharmStoreClient(cs.st)
if err != nil {
return nil, errors.Trace(err)
}
return newCSRetryClient(client), nil
} | go | func (cs *charmstoreOpener) NewClient() (*CSRetryClient, error) {
// TODO(ericsnow) Use a valid charm store client.
client, err := newCharmStoreClient(cs.st)
if err != nil {
return nil, errors.Trace(err)
}
return newCSRetryClient(client), nil
} | [
"func",
"(",
"cs",
"*",
"charmstoreOpener",
")",
"NewClient",
"(",
")",
"(",
"*",
"CSRetryClient",
",",
"error",
")",
"{",
"// TODO(ericsnow) Use a valid charm store client.",
"client",
",",
"err",
":=",
"newCharmStoreClient",
"(",
"cs",
".",
"st",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"newCSRetryClient",
"(",
"client",
")",
",",
"nil",
"\n",
"}"
] | // NewClient opens a new charm store client. | [
"NewClient",
"opens",
"a",
"new",
"charm",
"store",
"client",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/resource/resourceadapters/charmstore.go#L64-L71 |
157,503 | juju/juju | resource/resourceadapters/charmstore.go | GetResource | func (client CSRetryClient) GetResource(req charmstore.ResourceRequest) (charmstore.ResourceData, error) {
args := client.retryArgs // a copy
var data charmstore.ResourceData
args.Func = func() error {
var err error
data, err = client.ResourceClient.GetResource(req)
if err != nil {
return errors.Trace(err)
}
return nil
}
var lastErr error
args.NotifyFunc = func(err error, i int) {
// Remember the error we're hiding and then retry!
logger.Warningf("attempt %d/%d to download resource %q from charm store [channel (%v), charm (%v), resource revision (%v)] failed with error (will retry): %v",
i, client.retryArgs.Attempts, req.Name, req.Channel, req.Charm, req.Revision, err)
logger.Tracef("resource get error stack: %v", errors.ErrorStack(err))
lastErr = err
}
err := retry.Call(args)
if retry.IsAttemptsExceeded(err) {
return data, errors.Annotate(lastErr, "failed after retrying")
}
if err != nil {
return data, errors.Trace(err)
}
return data, nil
} | go | func (client CSRetryClient) GetResource(req charmstore.ResourceRequest) (charmstore.ResourceData, error) {
args := client.retryArgs // a copy
var data charmstore.ResourceData
args.Func = func() error {
var err error
data, err = client.ResourceClient.GetResource(req)
if err != nil {
return errors.Trace(err)
}
return nil
}
var lastErr error
args.NotifyFunc = func(err error, i int) {
// Remember the error we're hiding and then retry!
logger.Warningf("attempt %d/%d to download resource %q from charm store [channel (%v), charm (%v), resource revision (%v)] failed with error (will retry): %v",
i, client.retryArgs.Attempts, req.Name, req.Channel, req.Charm, req.Revision, err)
logger.Tracef("resource get error stack: %v", errors.ErrorStack(err))
lastErr = err
}
err := retry.Call(args)
if retry.IsAttemptsExceeded(err) {
return data, errors.Annotate(lastErr, "failed after retrying")
}
if err != nil {
return data, errors.Trace(err)
}
return data, nil
} | [
"func",
"(",
"client",
"CSRetryClient",
")",
"GetResource",
"(",
"req",
"charmstore",
".",
"ResourceRequest",
")",
"(",
"charmstore",
".",
"ResourceData",
",",
"error",
")",
"{",
"args",
":=",
"client",
".",
"retryArgs",
"// a copy",
"\n\n",
"var",
"data",
"charmstore",
".",
"ResourceData",
"\n",
"args",
".",
"Func",
"=",
"func",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"data",
",",
"err",
"=",
"client",
".",
"ResourceClient",
".",
"GetResource",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"lastErr",
"error",
"\n",
"args",
".",
"NotifyFunc",
"=",
"func",
"(",
"err",
"error",
",",
"i",
"int",
")",
"{",
"// Remember the error we're hiding and then retry!",
"logger",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"i",
",",
"client",
".",
"retryArgs",
".",
"Attempts",
",",
"req",
".",
"Name",
",",
"req",
".",
"Channel",
",",
"req",
".",
"Charm",
",",
"req",
".",
"Revision",
",",
"err",
")",
"\n",
"logger",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"errors",
".",
"ErrorStack",
"(",
"err",
")",
")",
"\n",
"lastErr",
"=",
"err",
"\n",
"}",
"\n\n",
"err",
":=",
"retry",
".",
"Call",
"(",
"args",
")",
"\n",
"if",
"retry",
".",
"IsAttemptsExceeded",
"(",
"err",
")",
"{",
"return",
"data",
",",
"errors",
".",
"Annotate",
"(",
"lastErr",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"data",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"data",
",",
"nil",
"\n",
"}"
] | // GetResource returns a reader for the resource's data. | [
"GetResource",
"returns",
"a",
"reader",
"for",
"the",
"resource",
"s",
"data",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/resource/resourceadapters/charmstore.go#L110-L141 |
157,504 | juju/juju | container/lxd/container.go | Metadata | func (c *Container) Metadata(key string) string {
return c.Config[UserNamespacePrefix+key]
} | go | func (c *Container) Metadata(key string) string {
return c.Config[UserNamespacePrefix+key]
} | [
"func",
"(",
"c",
"*",
"Container",
")",
"Metadata",
"(",
"key",
"string",
")",
"string",
"{",
"return",
"c",
".",
"Config",
"[",
"UserNamespacePrefix",
"+",
"key",
"]",
"\n",
"}"
] | // Metadata returns the value from container config for the input key.
// Such values are stored with the "user" namespace prefix. | [
"Metadata",
"returns",
"the",
"value",
"from",
"container",
"config",
"for",
"the",
"input",
"key",
".",
"Such",
"values",
"are",
"stored",
"with",
"the",
"user",
"namespace",
"prefix",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L77-L79 |
157,505 | juju/juju | container/lxd/container.go | CPUs | func (c *Container) CPUs() uint {
var cores uint
if v := c.Config["limits.cpu"]; v != "" {
_, err := fmt.Sscanf(v, "%d", &cores)
if err != nil {
logger.Errorf("failed to parse %q into uint, ignoring err: %s", v, err)
}
}
return cores
} | go | func (c *Container) CPUs() uint {
var cores uint
if v := c.Config["limits.cpu"]; v != "" {
_, err := fmt.Sscanf(v, "%d", &cores)
if err != nil {
logger.Errorf("failed to parse %q into uint, ignoring err: %s", v, err)
}
}
return cores
} | [
"func",
"(",
"c",
"*",
"Container",
")",
"CPUs",
"(",
")",
"uint",
"{",
"var",
"cores",
"uint",
"\n",
"if",
"v",
":=",
"c",
".",
"Config",
"[",
"\"",
"\"",
"]",
";",
"v",
"!=",
"\"",
"\"",
"{",
"_",
",",
"err",
":=",
"fmt",
".",
"Sscanf",
"(",
"v",
",",
"\"",
"\"",
",",
"&",
"cores",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"cores",
"\n",
"}"
] | // CPUs returns the configured limit for number of container CPU cores.
// If unset, zero is returned. | [
"CPUs",
"returns",
"the",
"configured",
"limit",
"for",
"number",
"of",
"container",
"CPU",
"cores",
".",
"If",
"unset",
"zero",
"is",
"returned",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L88-L97 |
157,506 | juju/juju | container/lxd/container.go | Mem | func (c *Container) Mem() uint {
v := c.Config["limits.memory"]
if v == "" {
return 0
}
bytes, err := shared.ParseByteSizeString(v)
if err != nil {
logger.Errorf("failed to parse %q into bytes, ignoring err: %s", v, err)
return 0
}
const oneMiB = 1024 * 1024
mib := bytes / oneMiB
if mib > math.MaxUint32 {
logger.Errorf("byte string %q overflowed uint32, using max value", v)
return math.MaxUint32
}
return uint(mib)
} | go | func (c *Container) Mem() uint {
v := c.Config["limits.memory"]
if v == "" {
return 0
}
bytes, err := shared.ParseByteSizeString(v)
if err != nil {
logger.Errorf("failed to parse %q into bytes, ignoring err: %s", v, err)
return 0
}
const oneMiB = 1024 * 1024
mib := bytes / oneMiB
if mib > math.MaxUint32 {
logger.Errorf("byte string %q overflowed uint32, using max value", v)
return math.MaxUint32
}
return uint(mib)
} | [
"func",
"(",
"c",
"*",
"Container",
")",
"Mem",
"(",
")",
"uint",
"{",
"v",
":=",
"c",
".",
"Config",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"v",
"==",
"\"",
"\"",
"{",
"return",
"0",
"\n",
"}",
"\n\n",
"bytes",
",",
"err",
":=",
"shared",
".",
"ParseByteSizeString",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
",",
"err",
")",
"\n",
"return",
"0",
"\n",
"}",
"\n\n",
"const",
"oneMiB",
"=",
"1024",
"*",
"1024",
"\n",
"mib",
":=",
"bytes",
"/",
"oneMiB",
"\n",
"if",
"mib",
">",
"math",
".",
"MaxUint32",
"{",
"logger",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
")",
"\n",
"return",
"math",
".",
"MaxUint32",
"\n",
"}",
"\n\n",
"return",
"uint",
"(",
"mib",
")",
"\n",
"}"
] | // Mem returns the configured limit for container memory in MiB. | [
"Mem",
"returns",
"the",
"configured",
"limit",
"for",
"container",
"memory",
"in",
"MiB",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L100-L120 |
157,507 | juju/juju | container/lxd/container.go | AddDisk | func (c *Container) AddDisk(name, path, source, pool string, readOnly bool) error {
if _, ok := c.Devices[name]; ok {
return errors.Errorf("container %q already has a device %q", c.Name, name)
}
if c.Devices == nil {
c.Devices = map[string]device{}
}
c.Devices[name] = map[string]string{
"path": path,
"source": source,
}
if pool != "" {
c.Devices[name]["pool"] = pool
}
if readOnly {
c.Devices[name]["readonly"] = "true"
}
return nil
} | go | func (c *Container) AddDisk(name, path, source, pool string, readOnly bool) error {
if _, ok := c.Devices[name]; ok {
return errors.Errorf("container %q already has a device %q", c.Name, name)
}
if c.Devices == nil {
c.Devices = map[string]device{}
}
c.Devices[name] = map[string]string{
"path": path,
"source": source,
}
if pool != "" {
c.Devices[name]["pool"] = pool
}
if readOnly {
c.Devices[name]["readonly"] = "true"
}
return nil
} | [
"func",
"(",
"c",
"*",
"Container",
")",
"AddDisk",
"(",
"name",
",",
"path",
",",
"source",
",",
"pool",
"string",
",",
"readOnly",
"bool",
")",
"error",
"{",
"if",
"_",
",",
"ok",
":=",
"c",
".",
"Devices",
"[",
"name",
"]",
";",
"ok",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
".",
"Name",
",",
"name",
")",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"Devices",
"==",
"nil",
"{",
"c",
".",
"Devices",
"=",
"map",
"[",
"string",
"]",
"device",
"{",
"}",
"\n",
"}",
"\n",
"c",
".",
"Devices",
"[",
"name",
"]",
"=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"path",
",",
"\"",
"\"",
":",
"source",
",",
"}",
"\n",
"if",
"pool",
"!=",
"\"",
"\"",
"{",
"c",
".",
"Devices",
"[",
"name",
"]",
"[",
"\"",
"\"",
"]",
"=",
"pool",
"\n",
"}",
"\n",
"if",
"readOnly",
"{",
"c",
".",
"Devices",
"[",
"name",
"]",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // AddDisk modifies updates the container's devices map to represent a disk
// device described by the input arguments.
// If the device already exists, an error is returned. | [
"AddDisk",
"modifies",
"updates",
"the",
"container",
"s",
"devices",
"map",
"to",
"represent",
"a",
"disk",
"device",
"described",
"by",
"the",
"input",
"arguments",
".",
"If",
"the",
"device",
"already",
"exists",
"an",
"error",
"is",
"returned",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L125-L144 |
157,508 | juju/juju | container/lxd/container.go | AliveContainers | func (s *Server) AliveContainers(prefix string) ([]Container, error) {
c, err := s.FilterContainers(prefix, aliveStatuses...)
return c, errors.Trace(err)
} | go | func (s *Server) AliveContainers(prefix string) ([]Container, error) {
c, err := s.FilterContainers(prefix, aliveStatuses...)
return c, errors.Trace(err)
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"AliveContainers",
"(",
"prefix",
"string",
")",
"(",
"[",
"]",
"Container",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"s",
".",
"FilterContainers",
"(",
"prefix",
",",
"aliveStatuses",
"...",
")",
"\n",
"return",
"c",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}"
] | // AliveContainers returns the list of containers based on the input namespace
// prefixed that are in a status indicating they are "alive". | [
"AliveContainers",
"returns",
"the",
"list",
"of",
"containers",
"based",
"on",
"the",
"input",
"namespace",
"prefixed",
"that",
"are",
"in",
"a",
"status",
"indicating",
"they",
"are",
"alive",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L158-L161 |
157,509 | juju/juju | container/lxd/container.go | FilterContainers | func (s *Server) FilterContainers(prefix string, statuses ...string) ([]Container, error) {
containers, err := s.GetContainers()
if err != nil {
return nil, errors.Trace(err)
}
var results []Container
for _, c := range containers {
if prefix != "" && !strings.HasPrefix(c.Name, prefix) {
continue
}
if len(statuses) > 0 && !containerHasStatus(c, statuses) {
continue
}
results = append(results, Container{c})
}
return results, nil
} | go | func (s *Server) FilterContainers(prefix string, statuses ...string) ([]Container, error) {
containers, err := s.GetContainers()
if err != nil {
return nil, errors.Trace(err)
}
var results []Container
for _, c := range containers {
if prefix != "" && !strings.HasPrefix(c.Name, prefix) {
continue
}
if len(statuses) > 0 && !containerHasStatus(c, statuses) {
continue
}
results = append(results, Container{c})
}
return results, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"FilterContainers",
"(",
"prefix",
"string",
",",
"statuses",
"...",
"string",
")",
"(",
"[",
"]",
"Container",
",",
"error",
")",
"{",
"containers",
",",
"err",
":=",
"s",
".",
"GetContainers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"results",
"[",
"]",
"Container",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"containers",
"{",
"if",
"prefix",
"!=",
"\"",
"\"",
"&&",
"!",
"strings",
".",
"HasPrefix",
"(",
"c",
".",
"Name",
",",
"prefix",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"len",
"(",
"statuses",
")",
">",
"0",
"&&",
"!",
"containerHasStatus",
"(",
"c",
",",
"statuses",
")",
"{",
"continue",
"\n",
"}",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"Container",
"{",
"c",
"}",
")",
"\n",
"}",
"\n",
"return",
"results",
",",
"nil",
"\n",
"}"
] | // FilterContainers retrieves the list of containers from the server and filters
// them based on the input namespace prefix and any supplied statuses. | [
"FilterContainers",
"retrieves",
"the",
"list",
"of",
"containers",
"from",
"the",
"server",
"and",
"filters",
"them",
"based",
"on",
"the",
"input",
"namespace",
"prefix",
"and",
"any",
"supplied",
"statuses",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L165-L182 |
157,510 | juju/juju | container/lxd/container.go | ContainerAddresses | func (s *Server) ContainerAddresses(name string) ([]network.Address, error) {
state, _, err := s.GetContainerState(name)
if err != nil {
return nil, errors.Trace(err)
}
networks := state.Network
if networks == nil {
return []network.Address{}, nil
}
var results []network.Address
for netName, net := range networks {
if netName == network.DefaultLXCBridge || netName == network.DefaultLXDBridge {
continue
}
for _, addr := range net.Addresses {
netAddr := network.NewAddress(addr.Address)
if netAddr.Scope == network.ScopeLinkLocal || netAddr.Scope == network.ScopeMachineLocal {
logger.Tracef("ignoring address %q for container %q", addr, name)
continue
}
results = append(results, netAddr)
}
}
return results, nil
} | go | func (s *Server) ContainerAddresses(name string) ([]network.Address, error) {
state, _, err := s.GetContainerState(name)
if err != nil {
return nil, errors.Trace(err)
}
networks := state.Network
if networks == nil {
return []network.Address{}, nil
}
var results []network.Address
for netName, net := range networks {
if netName == network.DefaultLXCBridge || netName == network.DefaultLXDBridge {
continue
}
for _, addr := range net.Addresses {
netAddr := network.NewAddress(addr.Address)
if netAddr.Scope == network.ScopeLinkLocal || netAddr.Scope == network.ScopeMachineLocal {
logger.Tracef("ignoring address %q for container %q", addr, name)
continue
}
results = append(results, netAddr)
}
}
return results, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"ContainerAddresses",
"(",
"name",
"string",
")",
"(",
"[",
"]",
"network",
".",
"Address",
",",
"error",
")",
"{",
"state",
",",
"_",
",",
"err",
":=",
"s",
".",
"GetContainerState",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"networks",
":=",
"state",
".",
"Network",
"\n",
"if",
"networks",
"==",
"nil",
"{",
"return",
"[",
"]",
"network",
".",
"Address",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"var",
"results",
"[",
"]",
"network",
".",
"Address",
"\n",
"for",
"netName",
",",
"net",
":=",
"range",
"networks",
"{",
"if",
"netName",
"==",
"network",
".",
"DefaultLXCBridge",
"||",
"netName",
"==",
"network",
".",
"DefaultLXDBridge",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"addr",
":=",
"range",
"net",
".",
"Addresses",
"{",
"netAddr",
":=",
"network",
".",
"NewAddress",
"(",
"addr",
".",
"Address",
")",
"\n",
"if",
"netAddr",
".",
"Scope",
"==",
"network",
".",
"ScopeLinkLocal",
"||",
"netAddr",
".",
"Scope",
"==",
"network",
".",
"ScopeMachineLocal",
"{",
"logger",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"addr",
",",
"name",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"netAddr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"results",
",",
"nil",
"\n",
"}"
] | // ContainerAddresses gets usable network addresses for the container
// identified by the input name. | [
"ContainerAddresses",
"gets",
"usable",
"network",
"addresses",
"for",
"the",
"container",
"identified",
"by",
"the",
"input",
"name",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L186-L212 |
157,511 | juju/juju | container/lxd/container.go | CreateContainerFromSpec | func (s *Server) CreateContainerFromSpec(spec ContainerSpec) (*Container, error) {
logger.Infof("starting new container %q (image %q)", spec.Name, spec.Image.Image.Filename)
logger.Debugf("new container has profiles %v", spec.Profiles)
req := api.ContainersPost{
Name: spec.Name,
InstanceType: spec.InstanceType,
ContainerPut: api.ContainerPut{
Profiles: spec.Profiles,
Devices: spec.Devices,
Config: spec.Config,
Ephemeral: false,
},
}
op, err := s.CreateContainerFromImage(spec.Image.LXDServer, *spec.Image.Image, req)
if err != nil {
return nil, errors.Trace(err)
}
if err := op.Wait(); err != nil {
return nil, errors.Trace(err)
}
opInfo, err := op.GetTarget()
if err != nil {
return nil, errors.Trace(err)
}
if opInfo.StatusCode != api.Success {
return nil, fmt.Errorf("container creation failed: %s", opInfo.Err)
}
logger.Debugf("created container %q, waiting for start...", spec.Name)
if err := s.StartContainer(spec.Name); err != nil {
if remErr := s.RemoveContainer(spec.Name); remErr != nil {
logger.Errorf("failed to remove container after unsuccessful start: %s", remErr.Error())
}
return nil, errors.Trace(err)
}
container, _, err := s.GetContainer(spec.Name)
if err != nil {
return nil, errors.Trace(err)
}
c := Container{*container}
return &c, nil
} | go | func (s *Server) CreateContainerFromSpec(spec ContainerSpec) (*Container, error) {
logger.Infof("starting new container %q (image %q)", spec.Name, spec.Image.Image.Filename)
logger.Debugf("new container has profiles %v", spec.Profiles)
req := api.ContainersPost{
Name: spec.Name,
InstanceType: spec.InstanceType,
ContainerPut: api.ContainerPut{
Profiles: spec.Profiles,
Devices: spec.Devices,
Config: spec.Config,
Ephemeral: false,
},
}
op, err := s.CreateContainerFromImage(spec.Image.LXDServer, *spec.Image.Image, req)
if err != nil {
return nil, errors.Trace(err)
}
if err := op.Wait(); err != nil {
return nil, errors.Trace(err)
}
opInfo, err := op.GetTarget()
if err != nil {
return nil, errors.Trace(err)
}
if opInfo.StatusCode != api.Success {
return nil, fmt.Errorf("container creation failed: %s", opInfo.Err)
}
logger.Debugf("created container %q, waiting for start...", spec.Name)
if err := s.StartContainer(spec.Name); err != nil {
if remErr := s.RemoveContainer(spec.Name); remErr != nil {
logger.Errorf("failed to remove container after unsuccessful start: %s", remErr.Error())
}
return nil, errors.Trace(err)
}
container, _, err := s.GetContainer(spec.Name)
if err != nil {
return nil, errors.Trace(err)
}
c := Container{*container}
return &c, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"CreateContainerFromSpec",
"(",
"spec",
"ContainerSpec",
")",
"(",
"*",
"Container",
",",
"error",
")",
"{",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
",",
"spec",
".",
"Name",
",",
"spec",
".",
"Image",
".",
"Image",
".",
"Filename",
")",
"\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"spec",
".",
"Profiles",
")",
"\n",
"req",
":=",
"api",
".",
"ContainersPost",
"{",
"Name",
":",
"spec",
".",
"Name",
",",
"InstanceType",
":",
"spec",
".",
"InstanceType",
",",
"ContainerPut",
":",
"api",
".",
"ContainerPut",
"{",
"Profiles",
":",
"spec",
".",
"Profiles",
",",
"Devices",
":",
"spec",
".",
"Devices",
",",
"Config",
":",
"spec",
".",
"Config",
",",
"Ephemeral",
":",
"false",
",",
"}",
",",
"}",
"\n",
"op",
",",
"err",
":=",
"s",
".",
"CreateContainerFromImage",
"(",
"spec",
".",
"Image",
".",
"LXDServer",
",",
"*",
"spec",
".",
"Image",
".",
"Image",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"op",
".",
"Wait",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"opInfo",
",",
"err",
":=",
"op",
".",
"GetTarget",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"opInfo",
".",
"StatusCode",
"!=",
"api",
".",
"Success",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"opInfo",
".",
"Err",
")",
"\n",
"}",
"\n\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"spec",
".",
"Name",
")",
"\n\n",
"if",
"err",
":=",
"s",
".",
"StartContainer",
"(",
"spec",
".",
"Name",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"remErr",
":=",
"s",
".",
"RemoveContainer",
"(",
"spec",
".",
"Name",
")",
";",
"remErr",
"!=",
"nil",
"{",
"logger",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"remErr",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"container",
",",
"_",
",",
"err",
":=",
"s",
".",
"GetContainer",
"(",
"spec",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"c",
":=",
"Container",
"{",
"*",
"container",
"}",
"\n",
"return",
"&",
"c",
",",
"nil",
"\n",
"}"
] | // CreateContainerFromSpec creates a new container based on the input spec,
// and starts it immediately.
// If the container fails to be started, it is removed.
// Upon successful creation and start, the container is returned. | [
"CreateContainerFromSpec",
"creates",
"a",
"new",
"container",
"based",
"on",
"the",
"input",
"spec",
"and",
"starts",
"it",
"immediately",
".",
"If",
"the",
"container",
"fails",
"to",
"be",
"started",
"it",
"is",
"removed",
".",
"Upon",
"successful",
"creation",
"and",
"start",
"the",
"container",
"is",
"returned",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L218-L262 |
157,512 | juju/juju | container/lxd/container.go | StartContainer | func (s *Server) StartContainer(name string) error {
req := api.ContainerStatePut{
Action: "start",
Timeout: -1,
Force: false,
Stateful: false,
}
op, err := s.UpdateContainerState(name, req, "")
if err != nil {
return errors.Trace(err)
}
return errors.Trace(op.Wait())
} | go | func (s *Server) StartContainer(name string) error {
req := api.ContainerStatePut{
Action: "start",
Timeout: -1,
Force: false,
Stateful: false,
}
op, err := s.UpdateContainerState(name, req, "")
if err != nil {
return errors.Trace(err)
}
return errors.Trace(op.Wait())
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"StartContainer",
"(",
"name",
"string",
")",
"error",
"{",
"req",
":=",
"api",
".",
"ContainerStatePut",
"{",
"Action",
":",
"\"",
"\"",
",",
"Timeout",
":",
"-",
"1",
",",
"Force",
":",
"false",
",",
"Stateful",
":",
"false",
",",
"}",
"\n",
"op",
",",
"err",
":=",
"s",
".",
"UpdateContainerState",
"(",
"name",
",",
"req",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"errors",
".",
"Trace",
"(",
"op",
".",
"Wait",
"(",
")",
")",
"\n",
"}"
] | // StartContainer starts the extant container identified by the input name. | [
"StartContainer",
"starts",
"the",
"extant",
"container",
"identified",
"by",
"the",
"input",
"name",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L265-L278 |
157,513 | juju/juju | container/lxd/container.go | RemoveContainers | func (s *Server) RemoveContainers(names []string) error {
if len(names) == 0 {
return nil
}
var failed []string
for _, name := range names {
if err := s.RemoveContainer(name); err != nil {
failed = append(failed, name)
logger.Errorf("removing container %q: %v", name, err)
}
}
if len(failed) != 0 {
return errors.Errorf("failed to remove containers: %s", strings.Join(failed, ", "))
}
return nil
} | go | func (s *Server) RemoveContainers(names []string) error {
if len(names) == 0 {
return nil
}
var failed []string
for _, name := range names {
if err := s.RemoveContainer(name); err != nil {
failed = append(failed, name)
logger.Errorf("removing container %q: %v", name, err)
}
}
if len(failed) != 0 {
return errors.Errorf("failed to remove containers: %s", strings.Join(failed, ", "))
}
return nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"RemoveContainers",
"(",
"names",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"names",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"failed",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"name",
":=",
"range",
"names",
"{",
"if",
"err",
":=",
"s",
".",
"RemoveContainer",
"(",
"name",
")",
";",
"err",
"!=",
"nil",
"{",
"failed",
"=",
"append",
"(",
"failed",
",",
"name",
")",
"\n",
"logger",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"failed",
")",
"!=",
"0",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"failed",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Remove containers stops and deletes containers matching the input list of
// names. Any failed removals are indicated in the returned error. | [
"Remove",
"containers",
"stops",
"and",
"deletes",
"containers",
"matching",
"the",
"input",
"list",
"of",
"names",
".",
"Any",
"failed",
"removals",
"are",
"indicated",
"in",
"the",
"returned",
"error",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L282-L298 |
157,514 | juju/juju | container/lxd/container.go | RemoveContainer | func (s *Server) RemoveContainer(name string) error {
state, eTag, err := s.GetContainerState(name)
if err != nil {
return errors.Trace(err)
}
if state.StatusCode != api.Stopped {
req := api.ContainerStatePut{
Action: "stop",
Timeout: -1,
Force: true,
Stateful: false,
}
op, err := s.UpdateContainerState(name, req, eTag)
if err != nil {
return errors.Trace(err)
}
if err := op.Wait(); err != nil {
return errors.Trace(err)
}
}
// LXD has issues deleting containers, even if they've been stopped. The
// general advice passed back from the LXD team is to retry it again, to
// see if this helps clean up the containers.
// ZFS exacerbates this more for the LXD setup, but there is no way to
// know as the LXD client doesn't return typed errors.
retryArgs := retry.CallArgs{
Clock: s.Clock(),
IsFatalError: func(err error) bool {
return errors.IsBadRequest(err)
},
Func: func() error {
op, err := s.DeleteContainer(name)
if err != nil {
// sigh, LXD not found container - it's been deleted so, we
// just need to return nil.
if IsLXDNotFound(errors.Cause(err)) {
return nil
}
return errors.BadRequestf(err.Error())
}
return errors.Trace(op.Wait())
},
Delay: 2 * time.Second,
Attempts: 3,
}
if err := retry.Call(retryArgs); err != nil {
return errors.Trace(errors.Cause(err))
}
return nil
} | go | func (s *Server) RemoveContainer(name string) error {
state, eTag, err := s.GetContainerState(name)
if err != nil {
return errors.Trace(err)
}
if state.StatusCode != api.Stopped {
req := api.ContainerStatePut{
Action: "stop",
Timeout: -1,
Force: true,
Stateful: false,
}
op, err := s.UpdateContainerState(name, req, eTag)
if err != nil {
return errors.Trace(err)
}
if err := op.Wait(); err != nil {
return errors.Trace(err)
}
}
// LXD has issues deleting containers, even if they've been stopped. The
// general advice passed back from the LXD team is to retry it again, to
// see if this helps clean up the containers.
// ZFS exacerbates this more for the LXD setup, but there is no way to
// know as the LXD client doesn't return typed errors.
retryArgs := retry.CallArgs{
Clock: s.Clock(),
IsFatalError: func(err error) bool {
return errors.IsBadRequest(err)
},
Func: func() error {
op, err := s.DeleteContainer(name)
if err != nil {
// sigh, LXD not found container - it's been deleted so, we
// just need to return nil.
if IsLXDNotFound(errors.Cause(err)) {
return nil
}
return errors.BadRequestf(err.Error())
}
return errors.Trace(op.Wait())
},
Delay: 2 * time.Second,
Attempts: 3,
}
if err := retry.Call(retryArgs); err != nil {
return errors.Trace(errors.Cause(err))
}
return nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"RemoveContainer",
"(",
"name",
"string",
")",
"error",
"{",
"state",
",",
"eTag",
",",
"err",
":=",
"s",
".",
"GetContainerState",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"state",
".",
"StatusCode",
"!=",
"api",
".",
"Stopped",
"{",
"req",
":=",
"api",
".",
"ContainerStatePut",
"{",
"Action",
":",
"\"",
"\"",
",",
"Timeout",
":",
"-",
"1",
",",
"Force",
":",
"true",
",",
"Stateful",
":",
"false",
",",
"}",
"\n",
"op",
",",
"err",
":=",
"s",
".",
"UpdateContainerState",
"(",
"name",
",",
"req",
",",
"eTag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"op",
".",
"Wait",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// LXD has issues deleting containers, even if they've been stopped. The",
"// general advice passed back from the LXD team is to retry it again, to",
"// see if this helps clean up the containers.",
"// ZFS exacerbates this more for the LXD setup, but there is no way to",
"// know as the LXD client doesn't return typed errors.",
"retryArgs",
":=",
"retry",
".",
"CallArgs",
"{",
"Clock",
":",
"s",
".",
"Clock",
"(",
")",
",",
"IsFatalError",
":",
"func",
"(",
"err",
"error",
")",
"bool",
"{",
"return",
"errors",
".",
"IsBadRequest",
"(",
"err",
")",
"\n",
"}",
",",
"Func",
":",
"func",
"(",
")",
"error",
"{",
"op",
",",
"err",
":=",
"s",
".",
"DeleteContainer",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// sigh, LXD not found container - it's been deleted so, we",
"// just need to return nil.",
"if",
"IsLXDNotFound",
"(",
"errors",
".",
"Cause",
"(",
"err",
")",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"errors",
".",
"BadRequestf",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"errors",
".",
"Trace",
"(",
"op",
".",
"Wait",
"(",
")",
")",
"\n",
"}",
",",
"Delay",
":",
"2",
"*",
"time",
".",
"Second",
",",
"Attempts",
":",
"3",
",",
"}",
"\n",
"if",
"err",
":=",
"retry",
".",
"Call",
"(",
"retryArgs",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"errors",
".",
"Cause",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Remove container first ensures that the container is stopped,
// then deletes it. | [
"Remove",
"container",
"first",
"ensures",
"that",
"the",
"container",
"is",
"stopped",
"then",
"deletes",
"it",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L302-L354 |
157,515 | juju/juju | container/lxd/container.go | WriteContainer | func (s *Server) WriteContainer(c *Container) error {
resp, err := s.UpdateContainer(c.Name, c.Writable(), "")
if err != nil {
return errors.Trace(err)
}
if err := resp.Wait(); err != nil {
return errors.Trace(err)
}
return nil
} | go | func (s *Server) WriteContainer(c *Container) error {
resp, err := s.UpdateContainer(c.Name, c.Writable(), "")
if err != nil {
return errors.Trace(err)
}
if err := resp.Wait(); err != nil {
return errors.Trace(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"WriteContainer",
"(",
"c",
"*",
"Container",
")",
"error",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"UpdateContainer",
"(",
"c",
".",
"Name",
",",
"c",
".",
"Writable",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"resp",
".",
"Wait",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // WriteContainer writes the current representation of the input container to
// the server. | [
"WriteContainer",
"writes",
"the",
"current",
"representation",
"of",
"the",
"input",
"container",
"to",
"the",
"server",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L358-L367 |
157,516 | juju/juju | container/lxd/container.go | containerHasStatus | func containerHasStatus(container api.Container, statuses []string) bool {
for _, status := range statuses {
if container.StatusCode.String() == status {
return true
}
}
return false
} | go | func containerHasStatus(container api.Container, statuses []string) bool {
for _, status := range statuses {
if container.StatusCode.String() == status {
return true
}
}
return false
} | [
"func",
"containerHasStatus",
"(",
"container",
"api",
".",
"Container",
",",
"statuses",
"[",
"]",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"status",
":=",
"range",
"statuses",
"{",
"if",
"container",
".",
"StatusCode",
".",
"String",
"(",
")",
"==",
"status",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // containerHasStatus returns true if the input container has a status
// matching one from the input list. | [
"containerHasStatus",
"returns",
"true",
"if",
"the",
"input",
"container",
"has",
"a",
"status",
"matching",
"one",
"from",
"the",
"input",
"list",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/lxd/container.go#L378-L385 |
157,517 | juju/juju | api/cloud/cloud.go | Clouds | func (c *Client) Clouds() (map[names.CloudTag]jujucloud.Cloud, error) {
var result params.CloudsResult
if err := c.facade.FacadeCall("Clouds", nil, &result); err != nil {
return nil, errors.Trace(err)
}
clouds := make(map[names.CloudTag]jujucloud.Cloud)
for tagString, cloud := range result.Clouds {
tag, err := names.ParseCloudTag(tagString)
if err != nil {
return nil, errors.Trace(err)
}
clouds[tag] = common.CloudFromParams(tag.Id(), cloud)
}
return clouds, nil
} | go | func (c *Client) Clouds() (map[names.CloudTag]jujucloud.Cloud, error) {
var result params.CloudsResult
if err := c.facade.FacadeCall("Clouds", nil, &result); err != nil {
return nil, errors.Trace(err)
}
clouds := make(map[names.CloudTag]jujucloud.Cloud)
for tagString, cloud := range result.Clouds {
tag, err := names.ParseCloudTag(tagString)
if err != nil {
return nil, errors.Trace(err)
}
clouds[tag] = common.CloudFromParams(tag.Id(), cloud)
}
return clouds, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Clouds",
"(",
")",
"(",
"map",
"[",
"names",
".",
"CloudTag",
"]",
"jujucloud",
".",
"Cloud",
",",
"error",
")",
"{",
"var",
"result",
"params",
".",
"CloudsResult",
"\n",
"if",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"nil",
",",
"&",
"result",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"clouds",
":=",
"make",
"(",
"map",
"[",
"names",
".",
"CloudTag",
"]",
"jujucloud",
".",
"Cloud",
")",
"\n",
"for",
"tagString",
",",
"cloud",
":=",
"range",
"result",
".",
"Clouds",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseCloudTag",
"(",
"tagString",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"clouds",
"[",
"tag",
"]",
"=",
"common",
".",
"CloudFromParams",
"(",
"tag",
".",
"Id",
"(",
")",
",",
"cloud",
")",
"\n",
"}",
"\n",
"return",
"clouds",
",",
"nil",
"\n",
"}"
] | // Clouds returns the details of all clouds supported by the controller. | [
"Clouds",
"returns",
"the",
"details",
"of",
"all",
"clouds",
"supported",
"by",
"the",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L35-L49 |
157,518 | juju/juju | api/cloud/cloud.go | Cloud | func (c *Client) Cloud(tag names.CloudTag) (jujucloud.Cloud, error) {
var results params.CloudResults
args := params.Entities{[]params.Entity{{tag.String()}}}
if err := c.facade.FacadeCall("Cloud", args, &results); err != nil {
return jujucloud.Cloud{}, errors.Trace(err)
}
if len(results.Results) != 1 {
return jujucloud.Cloud{}, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
if err := results.Results[0].Error; err != nil {
if params.IsCodeNotFound(err) {
return jujucloud.Cloud{}, errors.NotFoundf("cloud %s", tag.Id())
}
return jujucloud.Cloud{}, err
}
return common.CloudFromParams(tag.Id(), *results.Results[0].Cloud), nil
} | go | func (c *Client) Cloud(tag names.CloudTag) (jujucloud.Cloud, error) {
var results params.CloudResults
args := params.Entities{[]params.Entity{{tag.String()}}}
if err := c.facade.FacadeCall("Cloud", args, &results); err != nil {
return jujucloud.Cloud{}, errors.Trace(err)
}
if len(results.Results) != 1 {
return jujucloud.Cloud{}, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
if err := results.Results[0].Error; err != nil {
if params.IsCodeNotFound(err) {
return jujucloud.Cloud{}, errors.NotFoundf("cloud %s", tag.Id())
}
return jujucloud.Cloud{}, err
}
return common.CloudFromParams(tag.Id(), *results.Results[0].Cloud), nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Cloud",
"(",
"tag",
"names",
".",
"CloudTag",
")",
"(",
"jujucloud",
".",
"Cloud",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"CloudResults",
"\n",
"args",
":=",
"params",
".",
"Entities",
"{",
"[",
"]",
"params",
".",
"Entity",
"{",
"{",
"tag",
".",
"String",
"(",
")",
"}",
"}",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"args",
",",
"&",
"results",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"jujucloud",
".",
"Cloud",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"results",
".",
"Results",
")",
"!=",
"1",
"{",
"return",
"jujucloud",
".",
"Cloud",
"{",
"}",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"len",
"(",
"results",
".",
"Results",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"results",
".",
"Results",
"[",
"0",
"]",
".",
"Error",
";",
"err",
"!=",
"nil",
"{",
"if",
"params",
".",
"IsCodeNotFound",
"(",
"err",
")",
"{",
"return",
"jujucloud",
".",
"Cloud",
"{",
"}",
",",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Id",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"jujucloud",
".",
"Cloud",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"common",
".",
"CloudFromParams",
"(",
"tag",
".",
"Id",
"(",
")",
",",
"*",
"results",
".",
"Results",
"[",
"0",
"]",
".",
"Cloud",
")",
",",
"nil",
"\n",
"}"
] | // Cloud returns the details of the cloud with the given tag. | [
"Cloud",
"returns",
"the",
"details",
"of",
"the",
"cloud",
"with",
"the",
"given",
"tag",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L52-L68 |
157,519 | juju/juju | api/cloud/cloud.go | UserCredentials | func (c *Client) UserCredentials(user names.UserTag, cloud names.CloudTag) ([]names.CloudCredentialTag, error) {
var results params.StringsResults
args := params.UserClouds{[]params.UserCloud{
{UserTag: user.String(), CloudTag: cloud.String()},
}}
if err := c.facade.FacadeCall("UserCredentials", args, &results); err != nil {
return nil, errors.Trace(err)
}
if len(results.Results) != 1 {
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
if results.Results[0].Error != nil {
return nil, results.Results[0].Error
}
tags := make([]names.CloudCredentialTag, len(results.Results[0].Result))
for i, s := range results.Results[0].Result {
tag, err := names.ParseCloudCredentialTag(s)
if err != nil {
return nil, errors.Trace(err)
}
tags[i] = tag
}
return tags, nil
} | go | func (c *Client) UserCredentials(user names.UserTag, cloud names.CloudTag) ([]names.CloudCredentialTag, error) {
var results params.StringsResults
args := params.UserClouds{[]params.UserCloud{
{UserTag: user.String(), CloudTag: cloud.String()},
}}
if err := c.facade.FacadeCall("UserCredentials", args, &results); err != nil {
return nil, errors.Trace(err)
}
if len(results.Results) != 1 {
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
if results.Results[0].Error != nil {
return nil, results.Results[0].Error
}
tags := make([]names.CloudCredentialTag, len(results.Results[0].Result))
for i, s := range results.Results[0].Result {
tag, err := names.ParseCloudCredentialTag(s)
if err != nil {
return nil, errors.Trace(err)
}
tags[i] = tag
}
return tags, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UserCredentials",
"(",
"user",
"names",
".",
"UserTag",
",",
"cloud",
"names",
".",
"CloudTag",
")",
"(",
"[",
"]",
"names",
".",
"CloudCredentialTag",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"StringsResults",
"\n",
"args",
":=",
"params",
".",
"UserClouds",
"{",
"[",
"]",
"params",
".",
"UserCloud",
"{",
"{",
"UserTag",
":",
"user",
".",
"String",
"(",
")",
",",
"CloudTag",
":",
"cloud",
".",
"String",
"(",
")",
"}",
",",
"}",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"args",
",",
"&",
"results",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"results",
".",
"Results",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"len",
"(",
"results",
".",
"Results",
")",
")",
"\n",
"}",
"\n",
"if",
"results",
".",
"Results",
"[",
"0",
"]",
".",
"Error",
"!=",
"nil",
"{",
"return",
"nil",
",",
"results",
".",
"Results",
"[",
"0",
"]",
".",
"Error",
"\n",
"}",
"\n",
"tags",
":=",
"make",
"(",
"[",
"]",
"names",
".",
"CloudCredentialTag",
",",
"len",
"(",
"results",
".",
"Results",
"[",
"0",
"]",
".",
"Result",
")",
")",
"\n",
"for",
"i",
",",
"s",
":=",
"range",
"results",
".",
"Results",
"[",
"0",
"]",
".",
"Result",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseCloudCredentialTag",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"tags",
"[",
"i",
"]",
"=",
"tag",
"\n",
"}",
"\n",
"return",
"tags",
",",
"nil",
"\n",
"}"
] | // UserCredentials returns the tags for cloud credentials available to a user for
// use with a specific cloud. | [
"UserCredentials",
"returns",
"the",
"tags",
"for",
"cloud",
"credentials",
"available",
"to",
"a",
"user",
"for",
"use",
"with",
"a",
"specific",
"cloud",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L72-L95 |
157,520 | juju/juju | api/cloud/cloud.go | UpdateCredentialsCheckModels | func (c *Client) UpdateCredentialsCheckModels(tag names.CloudCredentialTag, credential jujucloud.Credential) ([]params.UpdateCredentialModelResult, error) {
in := params.UpdateCredentialArgs{
Credentials: []params.TaggedCredential{{
Tag: tag.String(),
Credential: params.CloudCredential{
AuthType: string(credential.AuthType()),
Attributes: credential.Attributes(),
},
}},
}
if c.facade.BestAPIVersion() < 3 {
var out params.ErrorResults
if err := c.facade.FacadeCall("UpdateCredentials", in, &out); err != nil {
return nil, errors.Trace(err)
}
if len(out.Results) != 1 {
return nil, errors.Errorf("expected 1 result for when updating credential %q, got %d", tag.Name(), len(out.Results))
}
if out.Results[0].Error != nil {
return nil, errors.Trace(out.Results[0].Error)
}
return nil, nil
}
var out params.UpdateCredentialResults
if err := c.facade.FacadeCall("UpdateCredentialsCheckModels", in, &out); err != nil {
return nil, errors.Trace(err)
}
if len(out.Results) != 1 {
return nil, errors.Errorf("expected 1 result for when updating credential %q, got %d", tag.Name(), len(out.Results))
}
if out.Results[0].Error != nil {
// Unlike many other places, we want to return something valid here to provide more details.
return out.Results[0].Models, errors.Trace(out.Results[0].Error)
}
return out.Results[0].Models, nil
} | go | func (c *Client) UpdateCredentialsCheckModels(tag names.CloudCredentialTag, credential jujucloud.Credential) ([]params.UpdateCredentialModelResult, error) {
in := params.UpdateCredentialArgs{
Credentials: []params.TaggedCredential{{
Tag: tag.String(),
Credential: params.CloudCredential{
AuthType: string(credential.AuthType()),
Attributes: credential.Attributes(),
},
}},
}
if c.facade.BestAPIVersion() < 3 {
var out params.ErrorResults
if err := c.facade.FacadeCall("UpdateCredentials", in, &out); err != nil {
return nil, errors.Trace(err)
}
if len(out.Results) != 1 {
return nil, errors.Errorf("expected 1 result for when updating credential %q, got %d", tag.Name(), len(out.Results))
}
if out.Results[0].Error != nil {
return nil, errors.Trace(out.Results[0].Error)
}
return nil, nil
}
var out params.UpdateCredentialResults
if err := c.facade.FacadeCall("UpdateCredentialsCheckModels", in, &out); err != nil {
return nil, errors.Trace(err)
}
if len(out.Results) != 1 {
return nil, errors.Errorf("expected 1 result for when updating credential %q, got %d", tag.Name(), len(out.Results))
}
if out.Results[0].Error != nil {
// Unlike many other places, we want to return something valid here to provide more details.
return out.Results[0].Models, errors.Trace(out.Results[0].Error)
}
return out.Results[0].Models, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpdateCredentialsCheckModels",
"(",
"tag",
"names",
".",
"CloudCredentialTag",
",",
"credential",
"jujucloud",
".",
"Credential",
")",
"(",
"[",
"]",
"params",
".",
"UpdateCredentialModelResult",
",",
"error",
")",
"{",
"in",
":=",
"params",
".",
"UpdateCredentialArgs",
"{",
"Credentials",
":",
"[",
"]",
"params",
".",
"TaggedCredential",
"{",
"{",
"Tag",
":",
"tag",
".",
"String",
"(",
")",
",",
"Credential",
":",
"params",
".",
"CloudCredential",
"{",
"AuthType",
":",
"string",
"(",
"credential",
".",
"AuthType",
"(",
")",
")",
",",
"Attributes",
":",
"credential",
".",
"Attributes",
"(",
")",
",",
"}",
",",
"}",
"}",
",",
"}",
"\n\n",
"if",
"c",
".",
"facade",
".",
"BestAPIVersion",
"(",
")",
"<",
"3",
"{",
"var",
"out",
"params",
".",
"ErrorResults",
"\n",
"if",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"in",
",",
"&",
"out",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"out",
".",
"Results",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Name",
"(",
")",
",",
"len",
"(",
"out",
".",
"Results",
")",
")",
"\n",
"}",
"\n",
"if",
"out",
".",
"Results",
"[",
"0",
"]",
".",
"Error",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"out",
".",
"Results",
"[",
"0",
"]",
".",
"Error",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"var",
"out",
"params",
".",
"UpdateCredentialResults",
"\n",
"if",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"in",
",",
"&",
"out",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"out",
".",
"Results",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Name",
"(",
")",
",",
"len",
"(",
"out",
".",
"Results",
")",
")",
"\n",
"}",
"\n",
"if",
"out",
".",
"Results",
"[",
"0",
"]",
".",
"Error",
"!=",
"nil",
"{",
"// Unlike many other places, we want to return something valid here to provide more details.",
"return",
"out",
".",
"Results",
"[",
"0",
"]",
".",
"Models",
",",
"errors",
".",
"Trace",
"(",
"out",
".",
"Results",
"[",
"0",
"]",
".",
"Error",
")",
"\n",
"}",
"\n",
"return",
"out",
".",
"Results",
"[",
"0",
"]",
".",
"Models",
",",
"nil",
"\n",
"}"
] | // UpdateCredentialsCheckModels updates a cloud credential content
// stored on the controller. This call validates that the new content works
// for all models that are using this credential. | [
"UpdateCredentialsCheckModels",
"updates",
"a",
"cloud",
"credential",
"content",
"stored",
"on",
"the",
"controller",
".",
"This",
"call",
"validates",
"that",
"the",
"new",
"content",
"works",
"for",
"all",
"models",
"that",
"are",
"using",
"this",
"credential",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L100-L137 |
157,521 | juju/juju | api/cloud/cloud.go | Credentials | func (c *Client) Credentials(tags ...names.CloudCredentialTag) ([]params.CloudCredentialResult, error) {
if len(tags) == 0 {
return []params.CloudCredentialResult{}, nil
}
var results params.CloudCredentialResults
args := params.Entities{
Entities: make([]params.Entity, len(tags)),
}
for i, tag := range tags {
args.Entities[i].Tag = tag.String()
}
if err := c.facade.FacadeCall("Credential", args, &results); err != nil {
return nil, errors.Trace(err)
}
return results.Results, nil
} | go | func (c *Client) Credentials(tags ...names.CloudCredentialTag) ([]params.CloudCredentialResult, error) {
if len(tags) == 0 {
return []params.CloudCredentialResult{}, nil
}
var results params.CloudCredentialResults
args := params.Entities{
Entities: make([]params.Entity, len(tags)),
}
for i, tag := range tags {
args.Entities[i].Tag = tag.String()
}
if err := c.facade.FacadeCall("Credential", args, &results); err != nil {
return nil, errors.Trace(err)
}
return results.Results, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Credentials",
"(",
"tags",
"...",
"names",
".",
"CloudCredentialTag",
")",
"(",
"[",
"]",
"params",
".",
"CloudCredentialResult",
",",
"error",
")",
"{",
"if",
"len",
"(",
"tags",
")",
"==",
"0",
"{",
"return",
"[",
"]",
"params",
".",
"CloudCredentialResult",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n",
"var",
"results",
"params",
".",
"CloudCredentialResults",
"\n",
"args",
":=",
"params",
".",
"Entities",
"{",
"Entities",
":",
"make",
"(",
"[",
"]",
"params",
".",
"Entity",
",",
"len",
"(",
"tags",
")",
")",
",",
"}",
"\n",
"for",
"i",
",",
"tag",
":=",
"range",
"tags",
"{",
"args",
".",
"Entities",
"[",
"i",
"]",
".",
"Tag",
"=",
"tag",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"args",
",",
"&",
"results",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"results",
".",
"Results",
",",
"nil",
"\n",
"}"
] | // Credentials returns a slice of credential values for the specified tags.
// Secrets are excluded from the credential attributes. | [
"Credentials",
"returns",
"a",
"slice",
"of",
"credential",
"values",
"for",
"the",
"specified",
"tags",
".",
"Secrets",
"are",
"excluded",
"from",
"the",
"credential",
"attributes",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L168-L183 |
157,522 | juju/juju | api/cloud/cloud.go | AddCredential | func (c *Client) AddCredential(tag string, credential jujucloud.Credential) error {
if bestVer := c.BestAPIVersion(); bestVer < 2 {
return errors.NotImplementedf("AddCredential() (need v2+, have v%d)", bestVer)
}
var results params.ErrorResults
cloudCredential := params.CloudCredential{
AuthType: string(credential.AuthType()),
Attributes: credential.Attributes(),
}
args := params.TaggedCredentials{
Credentials: []params.TaggedCredential{{
Tag: tag,
Credential: cloudCredential,
},
}}
if err := c.facade.FacadeCall("AddCredentials", args, &results); err != nil {
return errors.Trace(err)
}
return results.OneError()
} | go | func (c *Client) AddCredential(tag string, credential jujucloud.Credential) error {
if bestVer := c.BestAPIVersion(); bestVer < 2 {
return errors.NotImplementedf("AddCredential() (need v2+, have v%d)", bestVer)
}
var results params.ErrorResults
cloudCredential := params.CloudCredential{
AuthType: string(credential.AuthType()),
Attributes: credential.Attributes(),
}
args := params.TaggedCredentials{
Credentials: []params.TaggedCredential{{
Tag: tag,
Credential: cloudCredential,
},
}}
if err := c.facade.FacadeCall("AddCredentials", args, &results); err != nil {
return errors.Trace(err)
}
return results.OneError()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"AddCredential",
"(",
"tag",
"string",
",",
"credential",
"jujucloud",
".",
"Credential",
")",
"error",
"{",
"if",
"bestVer",
":=",
"c",
".",
"BestAPIVersion",
"(",
")",
";",
"bestVer",
"<",
"2",
"{",
"return",
"errors",
".",
"NotImplementedf",
"(",
"\"",
"\"",
",",
"bestVer",
")",
"\n",
"}",
"\n",
"var",
"results",
"params",
".",
"ErrorResults",
"\n",
"cloudCredential",
":=",
"params",
".",
"CloudCredential",
"{",
"AuthType",
":",
"string",
"(",
"credential",
".",
"AuthType",
"(",
")",
")",
",",
"Attributes",
":",
"credential",
".",
"Attributes",
"(",
")",
",",
"}",
"\n",
"args",
":=",
"params",
".",
"TaggedCredentials",
"{",
"Credentials",
":",
"[",
"]",
"params",
".",
"TaggedCredential",
"{",
"{",
"Tag",
":",
"tag",
",",
"Credential",
":",
"cloudCredential",
",",
"}",
",",
"}",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"args",
",",
"&",
"results",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"results",
".",
"OneError",
"(",
")",
"\n",
"}"
] | // AddCredential adds a credential to the controller with a given tag.
// This can be a credential for a cloud that is not the same cloud as the controller's host. | [
"AddCredential",
"adds",
"a",
"credential",
"to",
"the",
"controller",
"with",
"a",
"given",
"tag",
".",
"This",
"can",
"be",
"a",
"credential",
"for",
"a",
"cloud",
"that",
"is",
"not",
"the",
"same",
"cloud",
"as",
"the",
"controller",
"s",
"host",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L187-L206 |
157,523 | juju/juju | api/cloud/cloud.go | AddCloud | func (c *Client) AddCloud(cloud jujucloud.Cloud) error {
bestVer := c.BestAPIVersion()
if bestVer < 2 {
return errors.NotImplementedf("AddCloud() (need v2+, have v%d)", bestVer)
}
if (len(cloud.Config) > 0 || len(cloud.RegionConfig) > 0) && bestVer < 5 {
return errors.New("adding a cloud with config parameters is not supported by this version of Juju")
}
args := params.AddCloudArgs{Name: cloud.Name, Cloud: common.CloudToParams(cloud)}
err := c.facade.FacadeCall("AddCloud", args, nil)
if err != nil {
return errors.Trace(err)
}
return nil
} | go | func (c *Client) AddCloud(cloud jujucloud.Cloud) error {
bestVer := c.BestAPIVersion()
if bestVer < 2 {
return errors.NotImplementedf("AddCloud() (need v2+, have v%d)", bestVer)
}
if (len(cloud.Config) > 0 || len(cloud.RegionConfig) > 0) && bestVer < 5 {
return errors.New("adding a cloud with config parameters is not supported by this version of Juju")
}
args := params.AddCloudArgs{Name: cloud.Name, Cloud: common.CloudToParams(cloud)}
err := c.facade.FacadeCall("AddCloud", args, nil)
if err != nil {
return errors.Trace(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"AddCloud",
"(",
"cloud",
"jujucloud",
".",
"Cloud",
")",
"error",
"{",
"bestVer",
":=",
"c",
".",
"BestAPIVersion",
"(",
")",
"\n",
"if",
"bestVer",
"<",
"2",
"{",
"return",
"errors",
".",
"NotImplementedf",
"(",
"\"",
"\"",
",",
"bestVer",
")",
"\n",
"}",
"\n",
"if",
"(",
"len",
"(",
"cloud",
".",
"Config",
")",
">",
"0",
"||",
"len",
"(",
"cloud",
".",
"RegionConfig",
")",
">",
"0",
")",
"&&",
"bestVer",
"<",
"5",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"args",
":=",
"params",
".",
"AddCloudArgs",
"{",
"Name",
":",
"cloud",
".",
"Name",
",",
"Cloud",
":",
"common",
".",
"CloudToParams",
"(",
"cloud",
")",
"}",
"\n",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"args",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // AddCloud adds a new cloud to current controller. | [
"AddCloud",
"adds",
"a",
"new",
"cloud",
"to",
"current",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L209-L223 |
157,524 | juju/juju | api/cloud/cloud.go | UpdateCloud | func (c *Client) UpdateCloud(cloud jujucloud.Cloud) error {
if c.BestAPIVersion() < 4 {
return errors.New("updating controller cloud is not supported by this version of Juju")
}
args := params.UpdateCloudArgs{
Clouds: []params.AddCloudArgs{{
Name: cloud.Name,
Cloud: common.CloudToParams(cloud),
}},
}
var results params.ErrorResults
if err := c.facade.FacadeCall("UpdateCloud", args, &results); err != nil {
return errors.Trace(err)
}
return results.OneError()
} | go | func (c *Client) UpdateCloud(cloud jujucloud.Cloud) error {
if c.BestAPIVersion() < 4 {
return errors.New("updating controller cloud is not supported by this version of Juju")
}
args := params.UpdateCloudArgs{
Clouds: []params.AddCloudArgs{{
Name: cloud.Name,
Cloud: common.CloudToParams(cloud),
}},
}
var results params.ErrorResults
if err := c.facade.FacadeCall("UpdateCloud", args, &results); err != nil {
return errors.Trace(err)
}
return results.OneError()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpdateCloud",
"(",
"cloud",
"jujucloud",
".",
"Cloud",
")",
"error",
"{",
"if",
"c",
".",
"BestAPIVersion",
"(",
")",
"<",
"4",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"args",
":=",
"params",
".",
"UpdateCloudArgs",
"{",
"Clouds",
":",
"[",
"]",
"params",
".",
"AddCloudArgs",
"{",
"{",
"Name",
":",
"cloud",
".",
"Name",
",",
"Cloud",
":",
"common",
".",
"CloudToParams",
"(",
"cloud",
")",
",",
"}",
"}",
",",
"}",
"\n",
"var",
"results",
"params",
".",
"ErrorResults",
"\n",
"if",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"args",
",",
"&",
"results",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"results",
".",
"OneError",
"(",
")",
"\n",
"}"
] | // UpdateCloud updates an existing cloud on a current controller. | [
"UpdateCloud",
"updates",
"an",
"existing",
"cloud",
"on",
"a",
"current",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L226-L241 |
157,525 | juju/juju | api/cloud/cloud.go | RemoveCloud | func (c *Client) RemoveCloud(cloud string) error {
if bestVer := c.BestAPIVersion(); bestVer < 2 {
return errors.NotImplementedf("RemoveCloud() (need v2+, have v%d)", bestVer)
}
args := params.Entities{Entities: []params.Entity{{Tag: names.NewCloudTag(cloud).String()}}}
var result params.ErrorResults
err := c.facade.FacadeCall("RemoveClouds", args, &result)
if err != nil {
return errors.Trace(err)
}
return result.OneError()
} | go | func (c *Client) RemoveCloud(cloud string) error {
if bestVer := c.BestAPIVersion(); bestVer < 2 {
return errors.NotImplementedf("RemoveCloud() (need v2+, have v%d)", bestVer)
}
args := params.Entities{Entities: []params.Entity{{Tag: names.NewCloudTag(cloud).String()}}}
var result params.ErrorResults
err := c.facade.FacadeCall("RemoveClouds", args, &result)
if err != nil {
return errors.Trace(err)
}
return result.OneError()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"RemoveCloud",
"(",
"cloud",
"string",
")",
"error",
"{",
"if",
"bestVer",
":=",
"c",
".",
"BestAPIVersion",
"(",
")",
";",
"bestVer",
"<",
"2",
"{",
"return",
"errors",
".",
"NotImplementedf",
"(",
"\"",
"\"",
",",
"bestVer",
")",
"\n",
"}",
"\n",
"args",
":=",
"params",
".",
"Entities",
"{",
"Entities",
":",
"[",
"]",
"params",
".",
"Entity",
"{",
"{",
"Tag",
":",
"names",
".",
"NewCloudTag",
"(",
"cloud",
")",
".",
"String",
"(",
")",
"}",
"}",
"}",
"\n",
"var",
"result",
"params",
".",
"ErrorResults",
"\n",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"args",
",",
"&",
"result",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
".",
"OneError",
"(",
")",
"\n",
"}"
] | // RemoveCloud removes a cloud from the current controller. | [
"RemoveCloud",
"removes",
"a",
"cloud",
"from",
"the",
"current",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L244-L255 |
157,526 | juju/juju | api/cloud/cloud.go | CredentialContents | func (c *Client) CredentialContents(cloud, credential string, withSecrets bool) ([]params.CredentialContentResult, error) {
if bestVer := c.BestAPIVersion(); bestVer < 2 {
return nil, errors.NotImplementedf("CredentialContents() (need v2+, have v%d)", bestVer)
}
oneCredential := params.CloudCredentialArg{}
if cloud == "" && credential == "" {
// this is valid and means we want all.
} else if cloud == "" {
return nil, errors.New("cloud name must be supplied")
} else if credential == "" {
return nil, errors.New("credential name must be supplied")
} else {
oneCredential.CloudName = cloud
oneCredential.CredentialName = credential
}
var out params.CredentialContentResults
in := params.CloudCredentialArgs{
IncludeSecrets: withSecrets,
}
if !oneCredential.IsEmpty() {
in.Credentials = []params.CloudCredentialArg{oneCredential}
}
err := c.facade.FacadeCall("CredentialContents", in, &out)
if err != nil {
return nil, errors.Trace(err)
}
if !oneCredential.IsEmpty() && len(out.Results) != 1 {
return nil, errors.Errorf("expected 1 result for credential %q on cloud %q, got %d", cloud, credential, len(out.Results))
}
return out.Results, nil
} | go | func (c *Client) CredentialContents(cloud, credential string, withSecrets bool) ([]params.CredentialContentResult, error) {
if bestVer := c.BestAPIVersion(); bestVer < 2 {
return nil, errors.NotImplementedf("CredentialContents() (need v2+, have v%d)", bestVer)
}
oneCredential := params.CloudCredentialArg{}
if cloud == "" && credential == "" {
// this is valid and means we want all.
} else if cloud == "" {
return nil, errors.New("cloud name must be supplied")
} else if credential == "" {
return nil, errors.New("credential name must be supplied")
} else {
oneCredential.CloudName = cloud
oneCredential.CredentialName = credential
}
var out params.CredentialContentResults
in := params.CloudCredentialArgs{
IncludeSecrets: withSecrets,
}
if !oneCredential.IsEmpty() {
in.Credentials = []params.CloudCredentialArg{oneCredential}
}
err := c.facade.FacadeCall("CredentialContents", in, &out)
if err != nil {
return nil, errors.Trace(err)
}
if !oneCredential.IsEmpty() && len(out.Results) != 1 {
return nil, errors.Errorf("expected 1 result for credential %q on cloud %q, got %d", cloud, credential, len(out.Results))
}
return out.Results, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CredentialContents",
"(",
"cloud",
",",
"credential",
"string",
",",
"withSecrets",
"bool",
")",
"(",
"[",
"]",
"params",
".",
"CredentialContentResult",
",",
"error",
")",
"{",
"if",
"bestVer",
":=",
"c",
".",
"BestAPIVersion",
"(",
")",
";",
"bestVer",
"<",
"2",
"{",
"return",
"nil",
",",
"errors",
".",
"NotImplementedf",
"(",
"\"",
"\"",
",",
"bestVer",
")",
"\n",
"}",
"\n",
"oneCredential",
":=",
"params",
".",
"CloudCredentialArg",
"{",
"}",
"\n",
"if",
"cloud",
"==",
"\"",
"\"",
"&&",
"credential",
"==",
"\"",
"\"",
"{",
"// this is valid and means we want all.",
"}",
"else",
"if",
"cloud",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"credential",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"oneCredential",
".",
"CloudName",
"=",
"cloud",
"\n",
"oneCredential",
".",
"CredentialName",
"=",
"credential",
"\n",
"}",
"\n",
"var",
"out",
"params",
".",
"CredentialContentResults",
"\n",
"in",
":=",
"params",
".",
"CloudCredentialArgs",
"{",
"IncludeSecrets",
":",
"withSecrets",
",",
"}",
"\n",
"if",
"!",
"oneCredential",
".",
"IsEmpty",
"(",
")",
"{",
"in",
".",
"Credentials",
"=",
"[",
"]",
"params",
".",
"CloudCredentialArg",
"{",
"oneCredential",
"}",
"\n",
"}",
"\n",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"in",
",",
"&",
"out",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"oneCredential",
".",
"IsEmpty",
"(",
")",
"&&",
"len",
"(",
"out",
".",
"Results",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cloud",
",",
"credential",
",",
"len",
"(",
"out",
".",
"Results",
")",
")",
"\n",
"}",
"\n",
"return",
"out",
".",
"Results",
",",
"nil",
"\n",
"}"
] | // CredentialContents returns contents of the credential values for the specified
// cloud and credential name. Secrets will be included if requested. | [
"CredentialContents",
"returns",
"contents",
"of",
"the",
"credential",
"values",
"for",
"the",
"specified",
"cloud",
"and",
"credential",
"name",
".",
"Secrets",
"will",
"be",
"included",
"if",
"requested",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L259-L289 |
157,527 | juju/juju | api/cloud/cloud.go | GrantCloud | func (c *Client) GrantCloud(user, access string, clouds ...string) error {
if bestVer := c.BestAPIVersion(); bestVer < 3 {
return errors.NotImplementedf("GrantCloud() (need v3+, have v%d)", bestVer)
}
return c.modifyCloudUser(params.GrantCloudAccess, user, access, clouds)
} | go | func (c *Client) GrantCloud(user, access string, clouds ...string) error {
if bestVer := c.BestAPIVersion(); bestVer < 3 {
return errors.NotImplementedf("GrantCloud() (need v3+, have v%d)", bestVer)
}
return c.modifyCloudUser(params.GrantCloudAccess, user, access, clouds)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GrantCloud",
"(",
"user",
",",
"access",
"string",
",",
"clouds",
"...",
"string",
")",
"error",
"{",
"if",
"bestVer",
":=",
"c",
".",
"BestAPIVersion",
"(",
")",
";",
"bestVer",
"<",
"3",
"{",
"return",
"errors",
".",
"NotImplementedf",
"(",
"\"",
"\"",
",",
"bestVer",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"modifyCloudUser",
"(",
"params",
".",
"GrantCloudAccess",
",",
"user",
",",
"access",
",",
"clouds",
")",
"\n",
"}"
] | // GrantCloud grants a user access to a cloud. | [
"GrantCloud",
"grants",
"a",
"user",
"access",
"to",
"a",
"cloud",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L292-L297 |
157,528 | juju/juju | api/cloud/cloud.go | RevokeCloud | func (c *Client) RevokeCloud(user, access string, clouds ...string) error {
if bestVer := c.BestAPIVersion(); bestVer < 3 {
return errors.NotImplementedf("RevokeCloud() (need v3+, have v%d)", bestVer)
}
return c.modifyCloudUser(params.RevokeCloudAccess, user, access, clouds)
} | go | func (c *Client) RevokeCloud(user, access string, clouds ...string) error {
if bestVer := c.BestAPIVersion(); bestVer < 3 {
return errors.NotImplementedf("RevokeCloud() (need v3+, have v%d)", bestVer)
}
return c.modifyCloudUser(params.RevokeCloudAccess, user, access, clouds)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"RevokeCloud",
"(",
"user",
",",
"access",
"string",
",",
"clouds",
"...",
"string",
")",
"error",
"{",
"if",
"bestVer",
":=",
"c",
".",
"BestAPIVersion",
"(",
")",
";",
"bestVer",
"<",
"3",
"{",
"return",
"errors",
".",
"NotImplementedf",
"(",
"\"",
"\"",
",",
"bestVer",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"modifyCloudUser",
"(",
"params",
".",
"RevokeCloudAccess",
",",
"user",
",",
"access",
",",
"clouds",
")",
"\n",
"}"
] | // RevokeCloud revokes a user's access to a cloud. | [
"RevokeCloud",
"revokes",
"a",
"user",
"s",
"access",
"to",
"a",
"cloud",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/cloud/cloud.go#L300-L305 |
157,529 | juju/juju | caas/kubernetes/provider/namespaces.go | Namespaces | func (k *kubernetesClient) Namespaces() ([]string, error) {
namespaces := k.client().CoreV1().Namespaces()
ns, err := namespaces.List(v1.ListOptions{IncludeUninitialized: true})
if err != nil {
return nil, errors.Annotate(err, "listing namespaces")
}
result := make([]string, len(ns.Items))
for i, n := range ns.Items {
if err := checkNamespaceOwnedByJuju(&n, k.annotations); err != nil {
continue
}
result[i] = n.Name
}
return result, nil
} | go | func (k *kubernetesClient) Namespaces() ([]string, error) {
namespaces := k.client().CoreV1().Namespaces()
ns, err := namespaces.List(v1.ListOptions{IncludeUninitialized: true})
if err != nil {
return nil, errors.Annotate(err, "listing namespaces")
}
result := make([]string, len(ns.Items))
for i, n := range ns.Items {
if err := checkNamespaceOwnedByJuju(&n, k.annotations); err != nil {
continue
}
result[i] = n.Name
}
return result, nil
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"Namespaces",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"namespaces",
":=",
"k",
".",
"client",
"(",
")",
".",
"CoreV1",
"(",
")",
".",
"Namespaces",
"(",
")",
"\n",
"ns",
",",
"err",
":=",
"namespaces",
".",
"List",
"(",
"v1",
".",
"ListOptions",
"{",
"IncludeUninitialized",
":",
"true",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"result",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"ns",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"n",
":=",
"range",
"ns",
".",
"Items",
"{",
"if",
"err",
":=",
"checkNamespaceOwnedByJuju",
"(",
"&",
"n",
",",
"k",
".",
"annotations",
")",
";",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"result",
"[",
"i",
"]",
"=",
"n",
".",
"Name",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // Namespaces returns names of the namespaces on the cluster. | [
"Namespaces",
"returns",
"names",
"of",
"the",
"namespaces",
"on",
"the",
"cluster",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/namespaces.go#L35-L49 |
157,530 | juju/juju | caas/kubernetes/provider/namespaces.go | GetNamespace | func (k *kubernetesClient) GetNamespace(name string) (*core.Namespace, error) {
ns, err := k.getNamespaceByName(name)
if err != nil {
return nil, errors.Trace(err)
}
if err := checkNamespaceOwnedByJuju(ns, k.annotations); err != nil {
return nil, errors.NotFoundf("namespace %q", name)
}
return ns, nil
} | go | func (k *kubernetesClient) GetNamespace(name string) (*core.Namespace, error) {
ns, err := k.getNamespaceByName(name)
if err != nil {
return nil, errors.Trace(err)
}
if err := checkNamespaceOwnedByJuju(ns, k.annotations); err != nil {
return nil, errors.NotFoundf("namespace %q", name)
}
return ns, nil
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"GetNamespace",
"(",
"name",
"string",
")",
"(",
"*",
"core",
".",
"Namespace",
",",
"error",
")",
"{",
"ns",
",",
"err",
":=",
"k",
".",
"getNamespaceByName",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"checkNamespaceOwnedByJuju",
"(",
"ns",
",",
"k",
".",
"annotations",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"ns",
",",
"nil",
"\n",
"}"
] | // GetNamespace returns the namespace for the specified name. | [
"GetNamespace",
"returns",
"the",
"namespace",
"for",
"the",
"specified",
"name",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/namespaces.go#L52-L61 |
157,531 | juju/juju | caas/kubernetes/provider/namespaces.go | listNamespacesByAnnotations | func (k *kubernetesClient) listNamespacesByAnnotations(annotations k8sannotations.Annotation) ([]core.Namespace, error) {
namespaces, err := k.client().CoreV1().Namespaces().List(v1.ListOptions{IncludeUninitialized: true})
if err != nil {
return nil, errors.Trace(err)
}
var matchedNS []core.Namespace
annotationMap := annotations
for _, ns := range namespaces.Items {
if err := checkNamespaceOwnedByJuju(&ns, annotationMap); err == nil {
matchedNS = append(matchedNS, ns)
}
}
if len(matchedNS) > 0 {
doLog := logger.Debugf
if len(matchedNS) > 1 {
// this should never happen before we enable multi controller in single cluster.
doLog = logger.Warningf
}
doLog("found %d matched namespaces with annotations %v", len(matchedNS), annotationMap)
return matchedNS, nil
}
return nil, errors.NotFoundf("namespace for %v", k.annotations)
} | go | func (k *kubernetesClient) listNamespacesByAnnotations(annotations k8sannotations.Annotation) ([]core.Namespace, error) {
namespaces, err := k.client().CoreV1().Namespaces().List(v1.ListOptions{IncludeUninitialized: true})
if err != nil {
return nil, errors.Trace(err)
}
var matchedNS []core.Namespace
annotationMap := annotations
for _, ns := range namespaces.Items {
if err := checkNamespaceOwnedByJuju(&ns, annotationMap); err == nil {
matchedNS = append(matchedNS, ns)
}
}
if len(matchedNS) > 0 {
doLog := logger.Debugf
if len(matchedNS) > 1 {
// this should never happen before we enable multi controller in single cluster.
doLog = logger.Warningf
}
doLog("found %d matched namespaces with annotations %v", len(matchedNS), annotationMap)
return matchedNS, nil
}
return nil, errors.NotFoundf("namespace for %v", k.annotations)
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"listNamespacesByAnnotations",
"(",
"annotations",
"k8sannotations",
".",
"Annotation",
")",
"(",
"[",
"]",
"core",
".",
"Namespace",
",",
"error",
")",
"{",
"namespaces",
",",
"err",
":=",
"k",
".",
"client",
"(",
")",
".",
"CoreV1",
"(",
")",
".",
"Namespaces",
"(",
")",
".",
"List",
"(",
"v1",
".",
"ListOptions",
"{",
"IncludeUninitialized",
":",
"true",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"matchedNS",
"[",
"]",
"core",
".",
"Namespace",
"\n",
"annotationMap",
":=",
"annotations",
"\n",
"for",
"_",
",",
"ns",
":=",
"range",
"namespaces",
".",
"Items",
"{",
"if",
"err",
":=",
"checkNamespaceOwnedByJuju",
"(",
"&",
"ns",
",",
"annotationMap",
")",
";",
"err",
"==",
"nil",
"{",
"matchedNS",
"=",
"append",
"(",
"matchedNS",
",",
"ns",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"matchedNS",
")",
">",
"0",
"{",
"doLog",
":=",
"logger",
".",
"Debugf",
"\n",
"if",
"len",
"(",
"matchedNS",
")",
">",
"1",
"{",
"// this should never happen before we enable multi controller in single cluster.",
"doLog",
"=",
"logger",
".",
"Warningf",
"\n",
"}",
"\n",
"doLog",
"(",
"\"",
"\"",
",",
"len",
"(",
"matchedNS",
")",
",",
"annotationMap",
")",
"\n",
"return",
"matchedNS",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"k",
".",
"annotations",
")",
"\n",
"}"
] | // listNamespacesByAnnotations filters namespaces by annotations. | [
"listNamespacesByAnnotations",
"filters",
"namespaces",
"by",
"annotations",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/namespaces.go#L83-L105 |
157,532 | juju/juju | caas/kubernetes/provider/namespaces.go | createNamespace | func (k *kubernetesClient) createNamespace(name string) error {
ns := &core.Namespace{ObjectMeta: v1.ObjectMeta{Name: name}}
if err := k.ensureNamespaceAnnotations(ns); err != nil {
return errors.Trace(err)
}
_, err := k.client().CoreV1().Namespaces().Create(ns)
if k8serrors.IsAlreadyExists(err) {
return errors.AlreadyExistsf("namespace %q", name)
}
return errors.Trace(err)
} | go | func (k *kubernetesClient) createNamespace(name string) error {
ns := &core.Namespace{ObjectMeta: v1.ObjectMeta{Name: name}}
if err := k.ensureNamespaceAnnotations(ns); err != nil {
return errors.Trace(err)
}
_, err := k.client().CoreV1().Namespaces().Create(ns)
if k8serrors.IsAlreadyExists(err) {
return errors.AlreadyExistsf("namespace %q", name)
}
return errors.Trace(err)
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"createNamespace",
"(",
"name",
"string",
")",
"error",
"{",
"ns",
":=",
"&",
"core",
".",
"Namespace",
"{",
"ObjectMeta",
":",
"v1",
".",
"ObjectMeta",
"{",
"Name",
":",
"name",
"}",
"}",
"\n",
"if",
"err",
":=",
"k",
".",
"ensureNamespaceAnnotations",
"(",
"ns",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"k",
".",
"client",
"(",
")",
".",
"CoreV1",
"(",
")",
".",
"Namespaces",
"(",
")",
".",
"Create",
"(",
"ns",
")",
"\n",
"if",
"k8serrors",
".",
"IsAlreadyExists",
"(",
"err",
")",
"{",
"return",
"errors",
".",
"AlreadyExistsf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}"
] | // createNamespace creates a named namespace. | [
"createNamespace",
"creates",
"a",
"named",
"namespace",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/namespaces.go#L123-L133 |
157,533 | juju/juju | caas/kubernetes/provider/namespaces.go | WatchNamespace | func (k *kubernetesClient) WatchNamespace() (watcher.NotifyWatcher, error) {
w, err := k.client().CoreV1().Namespaces().Watch(
v1.ListOptions{
FieldSelector: fields.OneTermEqualSelector("metadata.name", k.namespace).String(),
IncludeUninitialized: true,
},
)
if err != nil {
return nil, errors.Trace(err)
}
return k.newWatcher(w, k.namespace, k.clock)
} | go | func (k *kubernetesClient) WatchNamespace() (watcher.NotifyWatcher, error) {
w, err := k.client().CoreV1().Namespaces().Watch(
v1.ListOptions{
FieldSelector: fields.OneTermEqualSelector("metadata.name", k.namespace).String(),
IncludeUninitialized: true,
},
)
if err != nil {
return nil, errors.Trace(err)
}
return k.newWatcher(w, k.namespace, k.clock)
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"WatchNamespace",
"(",
")",
"(",
"watcher",
".",
"NotifyWatcher",
",",
"error",
")",
"{",
"w",
",",
"err",
":=",
"k",
".",
"client",
"(",
")",
".",
"CoreV1",
"(",
")",
".",
"Namespaces",
"(",
")",
".",
"Watch",
"(",
"v1",
".",
"ListOptions",
"{",
"FieldSelector",
":",
"fields",
".",
"OneTermEqualSelector",
"(",
"\"",
"\"",
",",
"k",
".",
"namespace",
")",
".",
"String",
"(",
")",
",",
"IncludeUninitialized",
":",
"true",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"k",
".",
"newWatcher",
"(",
"w",
",",
"k",
".",
"namespace",
",",
"k",
".",
"clock",
")",
"\n",
"}"
] | // WatchNamespace returns a watcher which notifies when there
// are changes to current namespace. | [
"WatchNamespace",
"returns",
"a",
"watcher",
"which",
"notifies",
"when",
"there",
"are",
"changes",
"to",
"current",
"namespace",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/namespaces.go#L162-L174 |
157,534 | juju/juju | state/settings.go | Keys | func (s *Settings) Keys() []string {
keys := []string{}
for key := range s.core {
keys = append(keys, key)
}
sort.Strings(keys)
return keys
} | go | func (s *Settings) Keys() []string {
keys := []string{}
for key := range s.core {
keys = append(keys, key)
}
sort.Strings(keys)
return keys
} | [
"func",
"(",
"s",
"*",
"Settings",
")",
"Keys",
"(",
")",
"[",
"]",
"string",
"{",
"keys",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"key",
":=",
"range",
"s",
".",
"core",
"{",
"keys",
"=",
"append",
"(",
"keys",
",",
"key",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"keys",
")",
"\n",
"return",
"keys",
"\n",
"}"
] | // Keys returns the current keys in alphabetical order. | [
"Keys",
"returns",
"the",
"current",
"keys",
"in",
"alphabetical",
"order",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L85-L92 |
157,535 | juju/juju | state/settings.go | Get | func (s *Settings) Get(key string) (value interface{}, found bool) {
value, found = s.core[key]
return
} | go | func (s *Settings) Get(key string) (value interface{}, found bool) {
value, found = s.core[key]
return
} | [
"func",
"(",
"s",
"*",
"Settings",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"value",
"interface",
"{",
"}",
",",
"found",
"bool",
")",
"{",
"value",
",",
"found",
"=",
"s",
".",
"core",
"[",
"key",
"]",
"\n",
"return",
"\n",
"}"
] | // Get returns the value of key and whether it was found. | [
"Get",
"returns",
"the",
"value",
"of",
"key",
"and",
"whether",
"it",
"was",
"found",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L95-L98 |
157,536 | juju/juju | state/settings.go | Set | func (s *Settings) Set(key string, value interface{}) {
s.core[key] = value
} | go | func (s *Settings) Set(key string, value interface{}) {
s.core[key] = value
} | [
"func",
"(",
"s",
"*",
"Settings",
")",
"Set",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"core",
"[",
"key",
"]",
"=",
"value",
"\n",
"}"
] | // Set sets key to value | [
"Set",
"sets",
"key",
"to",
"value"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L106-L108 |
157,537 | juju/juju | state/settings.go | settingsUpdateOps | func (s *Settings) settingsUpdateOps() (settings.ItemChanges, []txn.Op) {
changes := s.changes()
if len(changes) == 0 {
return changes, nil
}
updates := bson.M{}
deletions := bson.M{}
for _, ch := range changes {
k := utils.EscapeKey(ch.Key)
switch {
case ch.IsAddition(), ch.IsModification():
updates[k] = ch.NewValue
case ch.IsDeletion():
deletions[k] = 1
}
}
ops := []txn.Op{{
C: s.collection,
Id: s.key,
Assert: txn.DocExists,
Update: setUnsetUpdateSettings(updates, deletions),
}}
return changes, ops
} | go | func (s *Settings) settingsUpdateOps() (settings.ItemChanges, []txn.Op) {
changes := s.changes()
if len(changes) == 0 {
return changes, nil
}
updates := bson.M{}
deletions := bson.M{}
for _, ch := range changes {
k := utils.EscapeKey(ch.Key)
switch {
case ch.IsAddition(), ch.IsModification():
updates[k] = ch.NewValue
case ch.IsDeletion():
deletions[k] = 1
}
}
ops := []txn.Op{{
C: s.collection,
Id: s.key,
Assert: txn.DocExists,
Update: setUnsetUpdateSettings(updates, deletions),
}}
return changes, ops
} | [
"func",
"(",
"s",
"*",
"Settings",
")",
"settingsUpdateOps",
"(",
")",
"(",
"settings",
".",
"ItemChanges",
",",
"[",
"]",
"txn",
".",
"Op",
")",
"{",
"changes",
":=",
"s",
".",
"changes",
"(",
")",
"\n",
"if",
"len",
"(",
"changes",
")",
"==",
"0",
"{",
"return",
"changes",
",",
"nil",
"\n",
"}",
"\n\n",
"updates",
":=",
"bson",
".",
"M",
"{",
"}",
"\n",
"deletions",
":=",
"bson",
".",
"M",
"{",
"}",
"\n",
"for",
"_",
",",
"ch",
":=",
"range",
"changes",
"{",
"k",
":=",
"utils",
".",
"EscapeKey",
"(",
"ch",
".",
"Key",
")",
"\n",
"switch",
"{",
"case",
"ch",
".",
"IsAddition",
"(",
")",
",",
"ch",
".",
"IsModification",
"(",
")",
":",
"updates",
"[",
"k",
"]",
"=",
"ch",
".",
"NewValue",
"\n",
"case",
"ch",
".",
"IsDeletion",
"(",
")",
":",
"deletions",
"[",
"k",
"]",
"=",
"1",
"\n",
"}",
"\n",
"}",
"\n\n",
"ops",
":=",
"[",
"]",
"txn",
".",
"Op",
"{",
"{",
"C",
":",
"s",
".",
"collection",
",",
"Id",
":",
"s",
".",
"key",
",",
"Assert",
":",
"txn",
".",
"DocExists",
",",
"Update",
":",
"setUnsetUpdateSettings",
"(",
"updates",
",",
"deletions",
")",
",",
"}",
"}",
"\n",
"return",
"changes",
",",
"ops",
"\n",
"}"
] | // settingsUpdateOps returns the item changes and txn ops necessary
// to write the changes made to settings back to the database. | [
"settingsUpdateOps",
"returns",
"the",
"item",
"changes",
"and",
"txn",
"ops",
"necessary",
"to",
"write",
"the",
"changes",
"made",
"to",
"settings",
"back",
"to",
"the",
"database",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L124-L149 |
157,538 | juju/juju | state/settings.go | changes | func (s *Settings) changes() settings.ItemChanges {
var changes settings.ItemChanges
for key := range cacheKeys(s.disk, s.core) {
old, onDisk := s.disk[key]
live, inCore := s.core[key]
if reflect.DeepEqual(live, old) {
continue
}
var change settings.ItemChange
switch {
case inCore && onDisk:
change = settings.MakeModification(key, old, live)
case inCore && !onDisk:
change = settings.MakeAddition(key, live)
case onDisk && !inCore:
change = settings.MakeDeletion(key, old)
default:
panic("unreachable")
}
changes = append(changes, change)
}
sort.Sort(changes)
return changes
} | go | func (s *Settings) changes() settings.ItemChanges {
var changes settings.ItemChanges
for key := range cacheKeys(s.disk, s.core) {
old, onDisk := s.disk[key]
live, inCore := s.core[key]
if reflect.DeepEqual(live, old) {
continue
}
var change settings.ItemChange
switch {
case inCore && onDisk:
change = settings.MakeModification(key, old, live)
case inCore && !onDisk:
change = settings.MakeAddition(key, live)
case onDisk && !inCore:
change = settings.MakeDeletion(key, old)
default:
panic("unreachable")
}
changes = append(changes, change)
}
sort.Sort(changes)
return changes
} | [
"func",
"(",
"s",
"*",
"Settings",
")",
"changes",
"(",
")",
"settings",
".",
"ItemChanges",
"{",
"var",
"changes",
"settings",
".",
"ItemChanges",
"\n\n",
"for",
"key",
":=",
"range",
"cacheKeys",
"(",
"s",
".",
"disk",
",",
"s",
".",
"core",
")",
"{",
"old",
",",
"onDisk",
":=",
"s",
".",
"disk",
"[",
"key",
"]",
"\n",
"live",
",",
"inCore",
":=",
"s",
".",
"core",
"[",
"key",
"]",
"\n",
"if",
"reflect",
".",
"DeepEqual",
"(",
"live",
",",
"old",
")",
"{",
"continue",
"\n",
"}",
"\n\n",
"var",
"change",
"settings",
".",
"ItemChange",
"\n",
"switch",
"{",
"case",
"inCore",
"&&",
"onDisk",
":",
"change",
"=",
"settings",
".",
"MakeModification",
"(",
"key",
",",
"old",
",",
"live",
")",
"\n",
"case",
"inCore",
"&&",
"!",
"onDisk",
":",
"change",
"=",
"settings",
".",
"MakeAddition",
"(",
"key",
",",
"live",
")",
"\n",
"case",
"onDisk",
"&&",
"!",
"inCore",
":",
"change",
"=",
"settings",
".",
"MakeDeletion",
"(",
"key",
",",
"old",
")",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"changes",
"=",
"append",
"(",
"changes",
",",
"change",
")",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"changes",
")",
"\n",
"return",
"changes",
"\n",
"}"
] | // changes compares the live settings with those that were retrieved from the
// database in order to generate a set of changes. | [
"changes",
"compares",
"the",
"live",
"settings",
"with",
"those",
"that",
"were",
"retrieved",
"from",
"the",
"database",
"in",
"order",
"to",
"generate",
"a",
"set",
"of",
"changes",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L153-L178 |
157,539 | juju/juju | state/settings.go | cacheKeys | func cacheKeys(caches ...map[string]interface{}) map[string]bool {
keys := make(map[string]bool)
for _, cache := range caches {
for key := range cache {
keys[key] = true
}
}
return keys
} | go | func cacheKeys(caches ...map[string]interface{}) map[string]bool {
keys := make(map[string]bool)
for _, cache := range caches {
for key := range cache {
keys[key] = true
}
}
return keys
} | [
"func",
"cacheKeys",
"(",
"caches",
"...",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"map",
"[",
"string",
"]",
"bool",
"{",
"keys",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"for",
"_",
",",
"cache",
":=",
"range",
"caches",
"{",
"for",
"key",
":=",
"range",
"cache",
"{",
"keys",
"[",
"key",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"keys",
"\n",
"}"
] | // cacheKeys returns the keys of all caches as a key=>true map. | [
"cacheKeys",
"returns",
"the",
"keys",
"of",
"all",
"caches",
"as",
"a",
"key",
"=",
">",
"true",
"map",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L181-L189 |
157,540 | juju/juju | state/settings.go | Write | func (s *Settings) Write() (settings.ItemChanges, error) {
changes, ops := s.settingsUpdateOps()
if len(ops) > 0 {
err := s.write(ops)
if err != nil {
return nil, err
}
}
return changes, nil
} | go | func (s *Settings) Write() (settings.ItemChanges, error) {
changes, ops := s.settingsUpdateOps()
if len(ops) > 0 {
err := s.write(ops)
if err != nil {
return nil, err
}
}
return changes, nil
} | [
"func",
"(",
"s",
"*",
"Settings",
")",
"Write",
"(",
")",
"(",
"settings",
".",
"ItemChanges",
",",
"error",
")",
"{",
"changes",
",",
"ops",
":=",
"s",
".",
"settingsUpdateOps",
"(",
")",
"\n",
"if",
"len",
"(",
"ops",
")",
">",
"0",
"{",
"err",
":=",
"s",
".",
"write",
"(",
"ops",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"changes",
",",
"nil",
"\n",
"}"
] | // Write writes changes made to c back onto its node. Changes are written
// as a delta applied on top of the latest version of the node, to prevent
// overwriting unrelated changes made to the node since it was last read. | [
"Write",
"writes",
"changes",
"made",
"to",
"c",
"back",
"onto",
"its",
"node",
".",
"Changes",
"are",
"written",
"as",
"a",
"delta",
"applied",
"on",
"top",
"of",
"the",
"latest",
"version",
"of",
"the",
"node",
"to",
"prevent",
"overwriting",
"unrelated",
"changes",
"made",
"to",
"the",
"node",
"since",
"it",
"was",
"last",
"read",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L206-L215 |
157,541 | juju/juju | state/settings.go | readSettingsDoc | func readSettingsDoc(db Database, collection, key string) (*settingsDoc, error) {
var doc settingsDoc
if err := readSettingsDocInto(db, collection, key, &doc); err != nil {
return nil, errors.Trace(err)
}
return &doc, nil
} | go | func readSettingsDoc(db Database, collection, key string) (*settingsDoc, error) {
var doc settingsDoc
if err := readSettingsDocInto(db, collection, key, &doc); err != nil {
return nil, errors.Trace(err)
}
return &doc, nil
} | [
"func",
"readSettingsDoc",
"(",
"db",
"Database",
",",
"collection",
",",
"key",
"string",
")",
"(",
"*",
"settingsDoc",
",",
"error",
")",
"{",
"var",
"doc",
"settingsDoc",
"\n",
"if",
"err",
":=",
"readSettingsDocInto",
"(",
"db",
",",
"collection",
",",
"key",
",",
"&",
"doc",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"doc",
",",
"nil",
"\n",
"}"
] | // readSettingsDoc reads the settings doc with the given key. | [
"readSettingsDoc",
"reads",
"the",
"settings",
"doc",
"with",
"the",
"given",
"key",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L235-L241 |
157,542 | juju/juju | state/settings.go | readSettingsDocInto | func readSettingsDocInto(db Database, collection, key string, out interface{}) error {
col, closer := db.GetCollection(collection)
defer closer()
err := col.FindId(key).One(out)
if err == mgo.ErrNotFound {
err = errors.NotFoundf("settings")
}
return err
} | go | func readSettingsDocInto(db Database, collection, key string, out interface{}) error {
col, closer := db.GetCollection(collection)
defer closer()
err := col.FindId(key).One(out)
if err == mgo.ErrNotFound {
err = errors.NotFoundf("settings")
}
return err
} | [
"func",
"readSettingsDocInto",
"(",
"db",
"Database",
",",
"collection",
",",
"key",
"string",
",",
"out",
"interface",
"{",
"}",
")",
"error",
"{",
"col",
",",
"closer",
":=",
"db",
".",
"GetCollection",
"(",
"collection",
")",
"\n",
"defer",
"closer",
"(",
")",
"\n\n",
"err",
":=",
"col",
".",
"FindId",
"(",
"key",
")",
".",
"One",
"(",
"out",
")",
"\n",
"if",
"err",
"==",
"mgo",
".",
"ErrNotFound",
"{",
"err",
"=",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // readSettingsDocInto reads the settings doc with the given key
// into the provided output structure. | [
"readSettingsDocInto",
"reads",
"the",
"settings",
"doc",
"with",
"the",
"given",
"key",
"into",
"the",
"provided",
"output",
"structure",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L245-L254 |
157,543 | juju/juju | state/settings.go | applyChanges | func (s *Settings) applyChanges(changes settings.ItemChanges) {
for _, ch := range changes {
switch {
case ch.IsAddition(), ch.IsModification():
s.Set(ch.Key, ch.NewValue)
case ch.IsDeletion():
s.Delete(ch.Key)
}
}
} | go | func (s *Settings) applyChanges(changes settings.ItemChanges) {
for _, ch := range changes {
switch {
case ch.IsAddition(), ch.IsModification():
s.Set(ch.Key, ch.NewValue)
case ch.IsDeletion():
s.Delete(ch.Key)
}
}
} | [
"func",
"(",
"s",
"*",
"Settings",
")",
"applyChanges",
"(",
"changes",
"settings",
".",
"ItemChanges",
")",
"{",
"for",
"_",
",",
"ch",
":=",
"range",
"changes",
"{",
"switch",
"{",
"case",
"ch",
".",
"IsAddition",
"(",
")",
",",
"ch",
".",
"IsModification",
"(",
")",
":",
"s",
".",
"Set",
"(",
"ch",
".",
"Key",
",",
"ch",
".",
"NewValue",
")",
"\n",
"case",
"ch",
".",
"IsDeletion",
"(",
")",
":",
"s",
".",
"Delete",
"(",
"ch",
".",
"Key",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // applyChanges modifies the live settings
// based on the input collection of changes. | [
"applyChanges",
"modifies",
"the",
"live",
"settings",
"based",
"on",
"the",
"input",
"collection",
"of",
"changes",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L258-L267 |
157,544 | juju/juju | state/settings.go | ReadSettings | func (st *State) ReadSettings(collection, key string) (*Settings, error) {
return readSettings(st.db(), collection, key)
} | go | func (st *State) ReadSettings(collection, key string) (*Settings, error) {
return readSettings(st.db(), collection, key)
} | [
"func",
"(",
"st",
"*",
"State",
")",
"ReadSettings",
"(",
"collection",
",",
"key",
"string",
")",
"(",
"*",
"Settings",
",",
"error",
")",
"{",
"return",
"readSettings",
"(",
"st",
".",
"db",
"(",
")",
",",
"collection",
",",
"key",
")",
"\n",
"}"
] | // ReadSettings returns the settings for the given key. | [
"ReadSettings",
"returns",
"the",
"settings",
"for",
"the",
"given",
"key",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L270-L272 |
157,545 | juju/juju | state/settings.go | readSettings | func readSettings(db Database, collection, key string) (*Settings, error) {
s := newSettings(db, collection, key)
if err := s.Read(); err != nil {
return nil, err
}
return s, nil
} | go | func readSettings(db Database, collection, key string) (*Settings, error) {
s := newSettings(db, collection, key)
if err := s.Read(); err != nil {
return nil, err
}
return s, nil
} | [
"func",
"readSettings",
"(",
"db",
"Database",
",",
"collection",
",",
"key",
"string",
")",
"(",
"*",
"Settings",
",",
"error",
")",
"{",
"s",
":=",
"newSettings",
"(",
"db",
",",
"collection",
",",
"key",
")",
"\n",
"if",
"err",
":=",
"s",
".",
"Read",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] | // readSettings returns the Settings for key. | [
"readSettings",
"returns",
"the",
"Settings",
"for",
"key",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L275-L281 |
157,546 | juju/juju | state/settings.go | createSettings | func createSettings(db Database, collection, key string, values map[string]interface{}) (*Settings, error) {
s := newSettings(db, collection, key)
s.core = copyMap(values, nil)
ops := []txn.Op{createSettingsOp(collection, key, values)}
err := s.db.RunTransaction(ops)
if err == txn.ErrAborted {
return nil, errSettingsExist
}
if err != nil {
return nil, fmt.Errorf("cannot create settings: %v", err)
}
return s, nil
} | go | func createSettings(db Database, collection, key string, values map[string]interface{}) (*Settings, error) {
s := newSettings(db, collection, key)
s.core = copyMap(values, nil)
ops := []txn.Op{createSettingsOp(collection, key, values)}
err := s.db.RunTransaction(ops)
if err == txn.ErrAborted {
return nil, errSettingsExist
}
if err != nil {
return nil, fmt.Errorf("cannot create settings: %v", err)
}
return s, nil
} | [
"func",
"createSettings",
"(",
"db",
"Database",
",",
"collection",
",",
"key",
"string",
",",
"values",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"*",
"Settings",
",",
"error",
")",
"{",
"s",
":=",
"newSettings",
"(",
"db",
",",
"collection",
",",
"key",
")",
"\n",
"s",
".",
"core",
"=",
"copyMap",
"(",
"values",
",",
"nil",
")",
"\n",
"ops",
":=",
"[",
"]",
"txn",
".",
"Op",
"{",
"createSettingsOp",
"(",
"collection",
",",
"key",
",",
"values",
")",
"}",
"\n",
"err",
":=",
"s",
".",
"db",
".",
"RunTransaction",
"(",
"ops",
")",
"\n",
"if",
"err",
"==",
"txn",
".",
"ErrAborted",
"{",
"return",
"nil",
",",
"errSettingsExist",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] | // createSettings writes an initial config node. | [
"createSettings",
"writes",
"an",
"initial",
"config",
"node",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L298-L310 |
157,547 | juju/juju | state/settings.go | removeSettings | func removeSettings(db Database, collection, key string) error {
err := db.RunTransaction([]txn.Op{removeSettingsOp(collection, key)})
if err == txn.ErrAborted {
return errors.NotFoundf("settings")
} else if err != nil {
return errors.Trace(err)
}
return nil
} | go | func removeSettings(db Database, collection, key string) error {
err := db.RunTransaction([]txn.Op{removeSettingsOp(collection, key)})
if err == txn.ErrAborted {
return errors.NotFoundf("settings")
} else if err != nil {
return errors.Trace(err)
}
return nil
} | [
"func",
"removeSettings",
"(",
"db",
"Database",
",",
"collection",
",",
"key",
"string",
")",
"error",
"{",
"err",
":=",
"db",
".",
"RunTransaction",
"(",
"[",
"]",
"txn",
".",
"Op",
"{",
"removeSettingsOp",
"(",
"collection",
",",
"key",
")",
"}",
")",
"\n",
"if",
"err",
"==",
"txn",
".",
"ErrAborted",
"{",
"return",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // removeSettings removes the Settings for key. | [
"removeSettings",
"removes",
"the",
"Settings",
"for",
"key",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L313-L321 |
157,548 | juju/juju | state/settings.go | replaceSettings | func replaceSettings(db Database, collection, key string, values map[string]interface{}) error {
op, _, err := replaceSettingsOp(db, collection, key, values)
if err != nil {
return errors.Annotatef(err, "settings %q", key)
}
err = db.RunTransaction([]txn.Op{op})
if err == txn.ErrAborted {
return errors.NotFoundf("settings")
}
if err != nil {
return fmt.Errorf("cannot replace settings: %v", err)
}
return nil
} | go | func replaceSettings(db Database, collection, key string, values map[string]interface{}) error {
op, _, err := replaceSettingsOp(db, collection, key, values)
if err != nil {
return errors.Annotatef(err, "settings %q", key)
}
err = db.RunTransaction([]txn.Op{op})
if err == txn.ErrAborted {
return errors.NotFoundf("settings")
}
if err != nil {
return fmt.Errorf("cannot replace settings: %v", err)
}
return nil
} | [
"func",
"replaceSettings",
"(",
"db",
"Database",
",",
"collection",
",",
"key",
"string",
",",
"values",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"op",
",",
"_",
",",
"err",
":=",
"replaceSettingsOp",
"(",
"db",
",",
"collection",
",",
"key",
",",
"values",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"key",
")",
"\n",
"}",
"\n",
"err",
"=",
"db",
".",
"RunTransaction",
"(",
"[",
"]",
"txn",
".",
"Op",
"{",
"op",
"}",
")",
"\n",
"if",
"err",
"==",
"txn",
".",
"ErrAborted",
"{",
"return",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // replaceSettings replaces the settings values for key. | [
"replaceSettings",
"replaces",
"the",
"settings",
"values",
"for",
"key",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L333-L346 |
157,549 | juju/juju | state/settings.go | listSettings | func listSettings(backend modelBackend, collection, keyPrefix string) (map[string]map[string]interface{}, error) {
col, closer := backend.db().GetRawCollection(collection)
defer closer()
var matchingSettings []settingsDoc
findExpr := fmt.Sprintf("^%s.*$", backend.docID(keyPrefix))
if err := col.Find(bson.D{{"_id", bson.D{{"$regex", findExpr}}}}).All(&matchingSettings); err != nil {
return nil, err
}
result := make(map[string]map[string]interface{})
for i := range matchingSettings {
result[backend.localID(matchingSettings[i].DocID)] = matchingSettings[i].Settings
}
return result, nil
} | go | func listSettings(backend modelBackend, collection, keyPrefix string) (map[string]map[string]interface{}, error) {
col, closer := backend.db().GetRawCollection(collection)
defer closer()
var matchingSettings []settingsDoc
findExpr := fmt.Sprintf("^%s.*$", backend.docID(keyPrefix))
if err := col.Find(bson.D{{"_id", bson.D{{"$regex", findExpr}}}}).All(&matchingSettings); err != nil {
return nil, err
}
result := make(map[string]map[string]interface{})
for i := range matchingSettings {
result[backend.localID(matchingSettings[i].DocID)] = matchingSettings[i].Settings
}
return result, nil
} | [
"func",
"listSettings",
"(",
"backend",
"modelBackend",
",",
"collection",
",",
"keyPrefix",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"col",
",",
"closer",
":=",
"backend",
".",
"db",
"(",
")",
".",
"GetRawCollection",
"(",
"collection",
")",
"\n",
"defer",
"closer",
"(",
")",
"\n\n",
"var",
"matchingSettings",
"[",
"]",
"settingsDoc",
"\n",
"findExpr",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"backend",
".",
"docID",
"(",
"keyPrefix",
")",
")",
"\n",
"if",
"err",
":=",
"col",
".",
"Find",
"(",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"findExpr",
"}",
"}",
"}",
"}",
")",
".",
"All",
"(",
"&",
"matchingSettings",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"result",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"i",
":=",
"range",
"matchingSettings",
"{",
"result",
"[",
"backend",
".",
"localID",
"(",
"matchingSettings",
"[",
"i",
"]",
".",
"DocID",
")",
"]",
"=",
"matchingSettings",
"[",
"i",
"]",
".",
"Settings",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // listSettings returns all the settings with the specified key prefix. | [
"listSettings",
"returns",
"all",
"the",
"settings",
"with",
"the",
"specified",
"key",
"prefix",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L349-L363 |
157,550 | juju/juju | state/settings.go | subDocKeys | func subDocKeys(m map[string]interface{}, subDoc string) map[string]interface{} {
return copyMap(m, subDocReplacer(subDoc))
} | go | func subDocKeys(m map[string]interface{}, subDoc string) map[string]interface{} {
return copyMap(m, subDocReplacer(subDoc))
} | [
"func",
"subDocKeys",
"(",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"subDoc",
"string",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"return",
"copyMap",
"(",
"m",
",",
"subDocReplacer",
"(",
"subDoc",
")",
")",
"\n",
"}"
] | // subDocKeys returns a new map based on the input,
// with keys indicating nesting within an MongoDB sub-document. | [
"subDocKeys",
"returns",
"a",
"new",
"map",
"based",
"on",
"the",
"input",
"with",
"keys",
"indicating",
"nesting",
"within",
"an",
"MongoDB",
"sub",
"-",
"document",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L423-L425 |
157,551 | juju/juju | state/settings.go | copyMap | func copyMap(in map[string]interface{}, replace func(string) string) (out map[string]interface{}) {
out = make(map[string]interface{})
for key, value := range in {
if replace != nil {
key = replace(key)
}
out[key] = value
}
return
} | go | func copyMap(in map[string]interface{}, replace func(string) string) (out map[string]interface{}) {
out = make(map[string]interface{})
for key, value := range in {
if replace != nil {
key = replace(key)
}
out[key] = value
}
return
} | [
"func",
"copyMap",
"(",
"in",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"replace",
"func",
"(",
"string",
")",
"string",
")",
"(",
"out",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"out",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"key",
",",
"value",
":=",
"range",
"in",
"{",
"if",
"replace",
"!=",
"nil",
"{",
"key",
"=",
"replace",
"(",
"key",
")",
"\n",
"}",
"\n",
"out",
"[",
"key",
"]",
"=",
"value",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // copyMap copies the keys and values of one map into a new one.
// If the input replacement function is non-nil, each key in the new map will
// be the result of applying the function to its original. | [
"copyMap",
"copies",
"the",
"keys",
"and",
"values",
"of",
"one",
"map",
"into",
"a",
"new",
"one",
".",
"If",
"the",
"input",
"replacement",
"function",
"is",
"non",
"-",
"nil",
"each",
"key",
"in",
"the",
"new",
"map",
"will",
"be",
"the",
"result",
"of",
"applying",
"the",
"function",
"to",
"its",
"original",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L430-L439 |
157,552 | juju/juju | state/settings.go | subDocReplacer | func subDocReplacer(subDoc string) func(string) string {
return func(key string) string {
return subDoc + "." + key
}
} | go | func subDocReplacer(subDoc string) func(string) string {
return func(key string) string {
return subDoc + "." + key
}
} | [
"func",
"subDocReplacer",
"(",
"subDoc",
"string",
")",
"func",
"(",
"string",
")",
"string",
"{",
"return",
"func",
"(",
"key",
"string",
")",
"string",
"{",
"return",
"subDoc",
"+",
"\"",
"\"",
"+",
"key",
"\n",
"}",
"\n",
"}"
] | // subDocReplacer returns a replacement function suitable for modifying input
// keys to indicate MongoDB sub-documents. | [
"subDocReplacer",
"returns",
"a",
"replacement",
"function",
"suitable",
"for",
"modifying",
"input",
"keys",
"to",
"indicate",
"MongoDB",
"sub",
"-",
"documents",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L443-L447 |
157,553 | juju/juju | state/settings.go | CreateSettings | func (s *StateSettings) CreateSettings(key string, settings map[string]interface{}) error {
_, err := createSettings(s.backend.db(), s.collection, key, settings)
return err
} | go | func (s *StateSettings) CreateSettings(key string, settings map[string]interface{}) error {
_, err := createSettings(s.backend.db(), s.collection, key, settings)
return err
} | [
"func",
"(",
"s",
"*",
"StateSettings",
")",
"CreateSettings",
"(",
"key",
"string",
",",
"settings",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"_",
",",
"err",
":=",
"createSettings",
"(",
"s",
".",
"backend",
".",
"db",
"(",
")",
",",
"s",
".",
"collection",
",",
"key",
",",
"settings",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // CreateSettings exposes createSettings on state for use outside the state package. | [
"CreateSettings",
"exposes",
"createSettings",
"on",
"state",
"for",
"use",
"outside",
"the",
"state",
"package",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L461-L464 |
157,554 | juju/juju | state/settings.go | ReadSettings | func (s *StateSettings) ReadSettings(key string) (map[string]interface{}, error) {
if s, err := readSettings(s.backend.db(), s.collection, key); err != nil {
return nil, err
} else {
return s.Map(), nil
}
} | go | func (s *StateSettings) ReadSettings(key string) (map[string]interface{}, error) {
if s, err := readSettings(s.backend.db(), s.collection, key); err != nil {
return nil, err
} else {
return s.Map(), nil
}
} | [
"func",
"(",
"s",
"*",
"StateSettings",
")",
"ReadSettings",
"(",
"key",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"s",
",",
"err",
":=",
"readSettings",
"(",
"s",
".",
"backend",
".",
"db",
"(",
")",
",",
"s",
".",
"collection",
",",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"{",
"return",
"s",
".",
"Map",
"(",
")",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // ReadSettings exposes readSettings on state for use outside the state package. | [
"ReadSettings",
"exposes",
"readSettings",
"on",
"state",
"for",
"use",
"outside",
"the",
"state",
"package",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L467-L473 |
157,555 | juju/juju | state/settings.go | RemoveSettings | func (s *StateSettings) RemoveSettings(key string) error {
return removeSettings(s.backend.db(), s.collection, key)
} | go | func (s *StateSettings) RemoveSettings(key string) error {
return removeSettings(s.backend.db(), s.collection, key)
} | [
"func",
"(",
"s",
"*",
"StateSettings",
")",
"RemoveSettings",
"(",
"key",
"string",
")",
"error",
"{",
"return",
"removeSettings",
"(",
"s",
".",
"backend",
".",
"db",
"(",
")",
",",
"s",
".",
"collection",
",",
"key",
")",
"\n",
"}"
] | // RemoveSettings exposes removeSettings on state for use outside the state package. | [
"RemoveSettings",
"exposes",
"removeSettings",
"on",
"state",
"for",
"use",
"outside",
"the",
"state",
"package",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L476-L478 |
157,556 | juju/juju | state/settings.go | ReplaceSettings | func (s *StateSettings) ReplaceSettings(key string, settings map[string]interface{}) error {
return replaceSettings(s.backend.db(), s.collection, key, settings)
} | go | func (s *StateSettings) ReplaceSettings(key string, settings map[string]interface{}) error {
return replaceSettings(s.backend.db(), s.collection, key, settings)
} | [
"func",
"(",
"s",
"*",
"StateSettings",
")",
"ReplaceSettings",
"(",
"key",
"string",
",",
"settings",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"replaceSettings",
"(",
"s",
".",
"backend",
".",
"db",
"(",
")",
",",
"s",
".",
"collection",
",",
"key",
",",
"settings",
")",
"\n",
"}"
] | // ReplaceSettings exposes replaceSettings on state for use outside the state package. | [
"ReplaceSettings",
"exposes",
"replaceSettings",
"on",
"state",
"for",
"use",
"outside",
"the",
"state",
"package",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L481-L483 |
157,557 | juju/juju | state/settings.go | ListSettings | func (s *StateSettings) ListSettings(keyPrefix string) (map[string]map[string]interface{}, error) {
return listSettings(s.backend, s.collection, keyPrefix)
} | go | func (s *StateSettings) ListSettings(keyPrefix string) (map[string]map[string]interface{}, error) {
return listSettings(s.backend, s.collection, keyPrefix)
} | [
"func",
"(",
"s",
"*",
"StateSettings",
")",
"ListSettings",
"(",
"keyPrefix",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"listSettings",
"(",
"s",
".",
"backend",
",",
"s",
".",
"collection",
",",
"keyPrefix",
")",
"\n",
"}"
] | // ListSettings exposes listSettings on state for use outside the state package. | [
"ListSettings",
"exposes",
"listSettings",
"on",
"state",
"for",
"use",
"outside",
"the",
"state",
"package",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/settings.go#L486-L488 |
157,558 | juju/juju | api/action/client.go | Enqueue | func (c *Client) Enqueue(arg params.Actions) (params.ActionResults, error) {
results := params.ActionResults{}
err := c.facade.FacadeCall("Enqueue", arg, &results)
return results, err
} | go | func (c *Client) Enqueue(arg params.Actions) (params.ActionResults, error) {
results := params.ActionResults{}
err := c.facade.FacadeCall("Enqueue", arg, &results)
return results, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Enqueue",
"(",
"arg",
"params",
".",
"Actions",
")",
"(",
"params",
".",
"ActionResults",
",",
"error",
")",
"{",
"results",
":=",
"params",
".",
"ActionResults",
"{",
"}",
"\n",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"arg",
",",
"&",
"results",
")",
"\n",
"return",
"results",
",",
"err",
"\n",
"}"
] | // Enqueue takes a list of Actions and queues them up to be executed by
// the designated ActionReceiver, returning the params.Action for each
// queued Action, or an error if there was a problem queueing up the
// Action. | [
"Enqueue",
"takes",
"a",
"list",
"of",
"Actions",
"and",
"queues",
"them",
"up",
"to",
"be",
"executed",
"by",
"the",
"designated",
"ActionReceiver",
"returning",
"the",
"params",
".",
"Action",
"for",
"each",
"queued",
"Action",
"or",
"an",
"error",
"if",
"there",
"was",
"a",
"problem",
"queueing",
"up",
"the",
"Action",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/action/client.go#L45-L49 |
157,559 | juju/juju | api/action/client.go | FindActionsByNames | func (c *Client) FindActionsByNames(arg params.FindActionsByNames) (params.ActionsByNames, error) {
results := params.ActionsByNames{}
err := c.facade.FacadeCall("FindActionsByNames", arg, &results)
return results, err
} | go | func (c *Client) FindActionsByNames(arg params.FindActionsByNames) (params.ActionsByNames, error) {
results := params.ActionsByNames{}
err := c.facade.FacadeCall("FindActionsByNames", arg, &results)
return results, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"FindActionsByNames",
"(",
"arg",
"params",
".",
"FindActionsByNames",
")",
"(",
"params",
".",
"ActionsByNames",
",",
"error",
")",
"{",
"results",
":=",
"params",
".",
"ActionsByNames",
"{",
"}",
"\n",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"arg",
",",
"&",
"results",
")",
"\n",
"return",
"results",
",",
"err",
"\n",
"}"
] | // FindActionsByNames takes a list of action names and returns actions for
// every name. | [
"FindActionsByNames",
"takes",
"a",
"list",
"of",
"action",
"names",
"and",
"returns",
"actions",
"for",
"every",
"name",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/action/client.go#L53-L57 |
157,560 | juju/juju | api/action/client.go | ListAll | func (c *Client) ListAll(arg params.Entities) (params.ActionsByReceivers, error) {
results := params.ActionsByReceivers{}
err := c.facade.FacadeCall("ListAll", arg, &results)
return results, err
} | go | func (c *Client) ListAll(arg params.Entities) (params.ActionsByReceivers, error) {
results := params.ActionsByReceivers{}
err := c.facade.FacadeCall("ListAll", arg, &results)
return results, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ListAll",
"(",
"arg",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ActionsByReceivers",
",",
"error",
")",
"{",
"results",
":=",
"params",
".",
"ActionsByReceivers",
"{",
"}",
"\n",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"arg",
",",
"&",
"results",
")",
"\n",
"return",
"results",
",",
"err",
"\n",
"}"
] | // ListAll takes a list of Entities representing ActionReceivers and returns
// all of the Actions that have been queued or run by each of those
// Entities. | [
"ListAll",
"takes",
"a",
"list",
"of",
"Entities",
"representing",
"ActionReceivers",
"and",
"returns",
"all",
"of",
"the",
"Actions",
"that",
"have",
"been",
"queued",
"or",
"run",
"by",
"each",
"of",
"those",
"Entities",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/action/client.go#L62-L66 |
157,561 | juju/juju | api/action/client.go | applicationsCharmActions | func (c *Client) applicationsCharmActions(arg params.Entities) (params.ApplicationsCharmActionsResults, error) {
results := params.ApplicationsCharmActionsResults{}
err := c.facade.FacadeCall("ApplicationsCharmsActions", arg, &results)
return results, err
} | go | func (c *Client) applicationsCharmActions(arg params.Entities) (params.ApplicationsCharmActionsResults, error) {
results := params.ApplicationsCharmActionsResults{}
err := c.facade.FacadeCall("ApplicationsCharmsActions", arg, &results)
return results, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"applicationsCharmActions",
"(",
"arg",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ApplicationsCharmActionsResults",
",",
"error",
")",
"{",
"results",
":=",
"params",
".",
"ApplicationsCharmActionsResults",
"{",
"}",
"\n",
"err",
":=",
"c",
".",
"facade",
".",
"FacadeCall",
"(",
"\"",
"\"",
",",
"arg",
",",
"&",
"results",
")",
"\n",
"return",
"results",
",",
"err",
"\n",
"}"
] | // applicationsCharmActions is a batched query for the charm.Actions for a slice
// of applications by Entity. | [
"applicationsCharmActions",
"is",
"a",
"batched",
"query",
"for",
"the",
"charm",
".",
"Actions",
"for",
"a",
"slice",
"of",
"applications",
"by",
"Entity",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/action/client.go#L95-L99 |
157,562 | juju/juju | api/action/client.go | ApplicationCharmActions | func (c *Client) ApplicationCharmActions(arg params.Entity) (map[string]params.ActionSpec, error) {
tags := params.Entities{Entities: []params.Entity{{Tag: arg.Tag}}}
results, err := c.applicationsCharmActions(tags)
if err != nil {
return nil, errors.Trace(err)
}
if len(results.Results) != 1 {
return nil, errors.Errorf("%d results, expected 1", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
if result.ApplicationTag != arg.Tag {
return nil, errors.Errorf("action results received for wrong application %q", result.ApplicationTag)
}
return result.Actions, nil
} | go | func (c *Client) ApplicationCharmActions(arg params.Entity) (map[string]params.ActionSpec, error) {
tags := params.Entities{Entities: []params.Entity{{Tag: arg.Tag}}}
results, err := c.applicationsCharmActions(tags)
if err != nil {
return nil, errors.Trace(err)
}
if len(results.Results) != 1 {
return nil, errors.Errorf("%d results, expected 1", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
if result.ApplicationTag != arg.Tag {
return nil, errors.Errorf("action results received for wrong application %q", result.ApplicationTag)
}
return result.Actions, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ApplicationCharmActions",
"(",
"arg",
"params",
".",
"Entity",
")",
"(",
"map",
"[",
"string",
"]",
"params",
".",
"ActionSpec",
",",
"error",
")",
"{",
"tags",
":=",
"params",
".",
"Entities",
"{",
"Entities",
":",
"[",
"]",
"params",
".",
"Entity",
"{",
"{",
"Tag",
":",
"arg",
".",
"Tag",
"}",
"}",
"}",
"\n",
"results",
",",
"err",
":=",
"c",
".",
"applicationsCharmActions",
"(",
"tags",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"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",
"if",
"result",
".",
"ApplicationTag",
"!=",
"arg",
".",
"Tag",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"result",
".",
"ApplicationTag",
")",
"\n",
"}",
"\n",
"return",
"result",
".",
"Actions",
",",
"nil",
"\n",
"}"
] | // ApplicationCharmActions is a single query which uses ApplicationsCharmsActions to
// get the charm.Actions for a single Application by tag. | [
"ApplicationCharmActions",
"is",
"a",
"single",
"query",
"which",
"uses",
"ApplicationsCharmsActions",
"to",
"get",
"the",
"charm",
".",
"Actions",
"for",
"a",
"single",
"Application",
"by",
"tag",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/action/client.go#L103-L120 |
157,563 | juju/juju | mongo/mongometrics/txnmetrics.go | NewTxnCollector | func NewTxnCollector() *TxnCollector {
return &TxnCollector{
prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: "juju",
Name: "mgo_txn_ops_total",
Help: "Total number of mgo/txn ops executed.",
},
jujuMgoTxnLabelNames,
),
}
} | go | func NewTxnCollector() *TxnCollector {
return &TxnCollector{
prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: "juju",
Name: "mgo_txn_ops_total",
Help: "Total number of mgo/txn ops executed.",
},
jujuMgoTxnLabelNames,
),
}
} | [
"func",
"NewTxnCollector",
"(",
")",
"*",
"TxnCollector",
"{",
"return",
"&",
"TxnCollector",
"{",
"prometheus",
".",
"NewCounterVec",
"(",
"prometheus",
".",
"CounterOpts",
"{",
"Namespace",
":",
"\"",
"\"",
",",
"Name",
":",
"\"",
"\"",
",",
"Help",
":",
"\"",
"\"",
",",
"}",
",",
"jujuMgoTxnLabelNames",
",",
")",
",",
"}",
"\n",
"}"
] | // NewTxnCollector returns a new TxnCollector. | [
"NewTxnCollector",
"returns",
"a",
"new",
"TxnCollector",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/mongo/mongometrics/txnmetrics.go#L34-L45 |
157,564 | juju/juju | environs/storage/storage.go | RemoveAll | func RemoveAll(stor Storage) error {
files, err := List(stor, "")
if err != nil {
return fmt.Errorf("unable to list files for deletion: %v", err)
}
// Some limited parallellism might be useful in this loop.
for _, file := range files {
err = stor.Remove(file)
if err != nil {
break
}
}
return err
} | go | func RemoveAll(stor Storage) error {
files, err := List(stor, "")
if err != nil {
return fmt.Errorf("unable to list files for deletion: %v", err)
}
// Some limited parallellism might be useful in this loop.
for _, file := range files {
err = stor.Remove(file)
if err != nil {
break
}
}
return err
} | [
"func",
"RemoveAll",
"(",
"stor",
"Storage",
")",
"error",
"{",
"files",
",",
"err",
":=",
"List",
"(",
"stor",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Some limited parallellism might be useful in this loop.",
"for",
"_",
",",
"file",
":=",
"range",
"files",
"{",
"err",
"=",
"stor",
".",
"Remove",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // RemoveAll is a default implementation for StorageWriter.RemoveAll.
// Providers may have more efficient implementations, or better error handling,
// or safeguards against races with other users of the same storage medium.
// But a simple way to implement RemoveAll would be to delegate to here. | [
"RemoveAll",
"is",
"a",
"default",
"implementation",
"for",
"StorageWriter",
".",
"RemoveAll",
".",
"Providers",
"may",
"have",
"more",
"efficient",
"implementations",
"or",
"better",
"error",
"handling",
"or",
"safeguards",
"against",
"races",
"with",
"other",
"users",
"of",
"the",
"same",
"storage",
"medium",
".",
"But",
"a",
"simple",
"way",
"to",
"implement",
"RemoveAll",
"would",
"be",
"to",
"delegate",
"to",
"here",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/storage/storage.go#L20-L34 |
157,565 | juju/juju | environs/storage/storage.go | Get | func Get(stor StorageReader, name string) (io.ReadCloser, error) {
return GetWithRetry(stor, name, stor.DefaultConsistencyStrategy())
} | go | func Get(stor StorageReader, name string) (io.ReadCloser, error) {
return GetWithRetry(stor, name, stor.DefaultConsistencyStrategy())
} | [
"func",
"Get",
"(",
"stor",
"StorageReader",
",",
"name",
"string",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"return",
"GetWithRetry",
"(",
"stor",
",",
"name",
",",
"stor",
".",
"DefaultConsistencyStrategy",
"(",
")",
")",
"\n",
"}"
] | // Get gets the named file from stor using the stor's default consistency strategy. | [
"Get",
"gets",
"the",
"named",
"file",
"from",
"stor",
"using",
"the",
"stor",
"s",
"default",
"consistency",
"strategy",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/storage/storage.go#L37-L39 |
157,566 | juju/juju | environs/storage/storage.go | List | func List(stor StorageReader, prefix string) ([]string, error) {
return ListWithRetry(stor, prefix, stor.DefaultConsistencyStrategy())
} | go | func List(stor StorageReader, prefix string) ([]string, error) {
return ListWithRetry(stor, prefix, stor.DefaultConsistencyStrategy())
} | [
"func",
"List",
"(",
"stor",
"StorageReader",
",",
"prefix",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"return",
"ListWithRetry",
"(",
"stor",
",",
"prefix",
",",
"stor",
".",
"DefaultConsistencyStrategy",
"(",
")",
")",
"\n",
"}"
] | // List lists the files matching prefix from stor using the stor's default consistency strategy. | [
"List",
"lists",
"the",
"files",
"matching",
"prefix",
"from",
"stor",
"using",
"the",
"stor",
"s",
"default",
"consistency",
"strategy",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/storage/storage.go#L55-L57 |
157,567 | juju/juju | environs/storage/storage.go | NewStorageSimpleStreamsDataSource | func NewStorageSimpleStreamsDataSource(description string, storage StorageReader, basePath string, priority int, requireSigned bool) simplestreams.DataSource {
return &storageSimpleStreamsDataSource{description, basePath, storage, false, priority, requireSigned}
} | go | func NewStorageSimpleStreamsDataSource(description string, storage StorageReader, basePath string, priority int, requireSigned bool) simplestreams.DataSource {
return &storageSimpleStreamsDataSource{description, basePath, storage, false, priority, requireSigned}
} | [
"func",
"NewStorageSimpleStreamsDataSource",
"(",
"description",
"string",
",",
"storage",
"StorageReader",
",",
"basePath",
"string",
",",
"priority",
"int",
",",
"requireSigned",
"bool",
")",
"simplestreams",
".",
"DataSource",
"{",
"return",
"&",
"storageSimpleStreamsDataSource",
"{",
"description",
",",
"basePath",
",",
"storage",
",",
"false",
",",
"priority",
",",
"requireSigned",
"}",
"\n",
"}"
] | // NewStorageSimpleStreamsDataSource returns a new datasource reading from the specified storage. | [
"NewStorageSimpleStreamsDataSource",
"returns",
"a",
"new",
"datasource",
"reading",
"from",
"the",
"specified",
"storage",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/storage/storage.go#L98-L100 |
157,568 | juju/juju | worker/meterstatus/state.go | Read | func (f *StateFile) Read() (string, string, *Disconnected, error) {
var st state
if err := utils.ReadYaml(f.path, &st); err != nil {
if os.IsNotExist(err) {
return "", "", nil, nil
}
return "", "", nil, errors.Trace(err)
}
return st.Code, st.Info, st.Disconnected, nil
} | go | func (f *StateFile) Read() (string, string, *Disconnected, error) {
var st state
if err := utils.ReadYaml(f.path, &st); err != nil {
if os.IsNotExist(err) {
return "", "", nil, nil
}
return "", "", nil, errors.Trace(err)
}
return st.Code, st.Info, st.Disconnected, nil
} | [
"func",
"(",
"f",
"*",
"StateFile",
")",
"Read",
"(",
")",
"(",
"string",
",",
"string",
",",
"*",
"Disconnected",
",",
"error",
")",
"{",
"var",
"st",
"state",
"\n",
"if",
"err",
":=",
"utils",
".",
"ReadYaml",
"(",
"f",
".",
"path",
",",
"&",
"st",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"st",
".",
"Code",
",",
"st",
".",
"Info",
",",
"st",
".",
"Disconnected",
",",
"nil",
"\n",
"}"
] | // Read reads the current meter status information from disk. | [
"Read",
"reads",
"the",
"current",
"meter",
"status",
"information",
"from",
"disk",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/meterstatus/state.go#L43-L53 |
157,569 | juju/juju | worker/meterstatus/state.go | Write | func (f *StateFile) Write(code, info string, disconnected *Disconnected) error {
st := state{
Code: code,
Info: info,
Disconnected: disconnected,
}
return errors.Trace(utils.WriteYaml(f.path, st))
} | go | func (f *StateFile) Write(code, info string, disconnected *Disconnected) error {
st := state{
Code: code,
Info: info,
Disconnected: disconnected,
}
return errors.Trace(utils.WriteYaml(f.path, st))
} | [
"func",
"(",
"f",
"*",
"StateFile",
")",
"Write",
"(",
"code",
",",
"info",
"string",
",",
"disconnected",
"*",
"Disconnected",
")",
"error",
"{",
"st",
":=",
"state",
"{",
"Code",
":",
"code",
",",
"Info",
":",
"info",
",",
"Disconnected",
":",
"disconnected",
",",
"}",
"\n\n",
"return",
"errors",
".",
"Trace",
"(",
"utils",
".",
"WriteYaml",
"(",
"f",
".",
"path",
",",
"st",
")",
")",
"\n",
"}"
] | // Write stores the supplied status information to disk. | [
"Write",
"stores",
"the",
"supplied",
"status",
"information",
"to",
"disk",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/meterstatus/state.go#L56-L64 |
157,570 | juju/juju | container/kvm/kvm.go | NewContainerManager | func NewContainerManager(conf container.ManagerConfig) (container.Manager, error) {
modelUUID := conf.PopValue(container.ConfigModelUUID)
if modelUUID == "" {
return nil, errors.Errorf("model UUID is required")
}
namespace, err := instance.NewNamespace(modelUUID)
if err != nil {
return nil, errors.Trace(err)
}
logDir := conf.PopValue(container.ConfigLogDir)
if logDir == "" {
logDir = agent.DefaultPaths.LogDir
}
availabilityZone := conf.PopValue(container.ConfigAvailabilityZone)
if availabilityZone == "" {
logger.Infof("Availability zone will be empty for this container manager")
}
imageMetaDataURL := conf.PopValue(config.ContainerImageMetadataURLKey)
imageStream := conf.PopValue(config.ContainerImageStreamKey)
conf.WarnAboutUnused()
return &containerManager{
namespace: namespace,
logDir: logDir,
availabilityZone: availabilityZone,
imageMetadataURL: imageMetaDataURL,
imageStream: imageStream,
}, nil
} | go | func NewContainerManager(conf container.ManagerConfig) (container.Manager, error) {
modelUUID := conf.PopValue(container.ConfigModelUUID)
if modelUUID == "" {
return nil, errors.Errorf("model UUID is required")
}
namespace, err := instance.NewNamespace(modelUUID)
if err != nil {
return nil, errors.Trace(err)
}
logDir := conf.PopValue(container.ConfigLogDir)
if logDir == "" {
logDir = agent.DefaultPaths.LogDir
}
availabilityZone := conf.PopValue(container.ConfigAvailabilityZone)
if availabilityZone == "" {
logger.Infof("Availability zone will be empty for this container manager")
}
imageMetaDataURL := conf.PopValue(config.ContainerImageMetadataURLKey)
imageStream := conf.PopValue(config.ContainerImageStreamKey)
conf.WarnAboutUnused()
return &containerManager{
namespace: namespace,
logDir: logDir,
availabilityZone: availabilityZone,
imageMetadataURL: imageMetaDataURL,
imageStream: imageStream,
}, nil
} | [
"func",
"NewContainerManager",
"(",
"conf",
"container",
".",
"ManagerConfig",
")",
"(",
"container",
".",
"Manager",
",",
"error",
")",
"{",
"modelUUID",
":=",
"conf",
".",
"PopValue",
"(",
"container",
".",
"ConfigModelUUID",
")",
"\n",
"if",
"modelUUID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"namespace",
",",
"err",
":=",
"instance",
".",
"NewNamespace",
"(",
"modelUUID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"logDir",
":=",
"conf",
".",
"PopValue",
"(",
"container",
".",
"ConfigLogDir",
")",
"\n",
"if",
"logDir",
"==",
"\"",
"\"",
"{",
"logDir",
"=",
"agent",
".",
"DefaultPaths",
".",
"LogDir",
"\n",
"}",
"\n\n",
"availabilityZone",
":=",
"conf",
".",
"PopValue",
"(",
"container",
".",
"ConfigAvailabilityZone",
")",
"\n",
"if",
"availabilityZone",
"==",
"\"",
"\"",
"{",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"imageMetaDataURL",
":=",
"conf",
".",
"PopValue",
"(",
"config",
".",
"ContainerImageMetadataURLKey",
")",
"\n",
"imageStream",
":=",
"conf",
".",
"PopValue",
"(",
"config",
".",
"ContainerImageStreamKey",
")",
"\n\n",
"conf",
".",
"WarnAboutUnused",
"(",
")",
"\n",
"return",
"&",
"containerManager",
"{",
"namespace",
":",
"namespace",
",",
"logDir",
":",
"logDir",
",",
"availabilityZone",
":",
"availabilityZone",
",",
"imageMetadataURL",
":",
"imageMetaDataURL",
",",
"imageStream",
":",
"imageStream",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewContainerManager returns a manager object that can start and stop kvm
// containers. | [
"NewContainerManager",
"returns",
"a",
"manager",
"object",
"that",
"can",
"start",
"and",
"stop",
"kvm",
"containers",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/kvm/kvm.go#L91-L121 |
157,571 | juju/juju | container/kvm/kvm.go | ParseConstraintsToStartParams | func ParseConstraintsToStartParams(cons constraints.Value) StartParams {
params := StartParams{
Memory: DefaultMemory,
CpuCores: DefaultCpu,
RootDisk: DefaultDisk,
}
if cons.Mem != nil {
mem := *cons.Mem
if mem < MinMemory {
params.Memory = MinMemory
} else {
params.Memory = mem
}
}
if cons.CpuCores != nil {
cores := *cons.CpuCores
if cores < MinCpu {
params.CpuCores = MinCpu
} else {
params.CpuCores = cores
}
}
if cons.RootDisk != nil {
size := *cons.RootDisk / 1024
if size < MinDisk {
params.RootDisk = MinDisk
} else {
params.RootDisk = size
}
}
if cons.Arch != nil {
logger.Infof("arch constraint of %q being ignored as not supported", *cons.Arch)
}
if cons.Container != nil {
logger.Infof("container constraint of %q being ignored as not supported", *cons.Container)
}
if cons.CpuPower != nil {
logger.Infof("cpu-power constraint of %v being ignored as not supported", *cons.CpuPower)
}
if cons.Tags != nil {
logger.Infof("tags constraint of %q being ignored as not supported", strings.Join(*cons.Tags, ","))
}
return params
} | go | func ParseConstraintsToStartParams(cons constraints.Value) StartParams {
params := StartParams{
Memory: DefaultMemory,
CpuCores: DefaultCpu,
RootDisk: DefaultDisk,
}
if cons.Mem != nil {
mem := *cons.Mem
if mem < MinMemory {
params.Memory = MinMemory
} else {
params.Memory = mem
}
}
if cons.CpuCores != nil {
cores := *cons.CpuCores
if cores < MinCpu {
params.CpuCores = MinCpu
} else {
params.CpuCores = cores
}
}
if cons.RootDisk != nil {
size := *cons.RootDisk / 1024
if size < MinDisk {
params.RootDisk = MinDisk
} else {
params.RootDisk = size
}
}
if cons.Arch != nil {
logger.Infof("arch constraint of %q being ignored as not supported", *cons.Arch)
}
if cons.Container != nil {
logger.Infof("container constraint of %q being ignored as not supported", *cons.Container)
}
if cons.CpuPower != nil {
logger.Infof("cpu-power constraint of %v being ignored as not supported", *cons.CpuPower)
}
if cons.Tags != nil {
logger.Infof("tags constraint of %q being ignored as not supported", strings.Join(*cons.Tags, ","))
}
return params
} | [
"func",
"ParseConstraintsToStartParams",
"(",
"cons",
"constraints",
".",
"Value",
")",
"StartParams",
"{",
"params",
":=",
"StartParams",
"{",
"Memory",
":",
"DefaultMemory",
",",
"CpuCores",
":",
"DefaultCpu",
",",
"RootDisk",
":",
"DefaultDisk",
",",
"}",
"\n\n",
"if",
"cons",
".",
"Mem",
"!=",
"nil",
"{",
"mem",
":=",
"*",
"cons",
".",
"Mem",
"\n",
"if",
"mem",
"<",
"MinMemory",
"{",
"params",
".",
"Memory",
"=",
"MinMemory",
"\n",
"}",
"else",
"{",
"params",
".",
"Memory",
"=",
"mem",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"cons",
".",
"CpuCores",
"!=",
"nil",
"{",
"cores",
":=",
"*",
"cons",
".",
"CpuCores",
"\n",
"if",
"cores",
"<",
"MinCpu",
"{",
"params",
".",
"CpuCores",
"=",
"MinCpu",
"\n",
"}",
"else",
"{",
"params",
".",
"CpuCores",
"=",
"cores",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"cons",
".",
"RootDisk",
"!=",
"nil",
"{",
"size",
":=",
"*",
"cons",
".",
"RootDisk",
"/",
"1024",
"\n",
"if",
"size",
"<",
"MinDisk",
"{",
"params",
".",
"RootDisk",
"=",
"MinDisk",
"\n",
"}",
"else",
"{",
"params",
".",
"RootDisk",
"=",
"size",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"cons",
".",
"Arch",
"!=",
"nil",
"{",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
",",
"*",
"cons",
".",
"Arch",
")",
"\n",
"}",
"\n",
"if",
"cons",
".",
"Container",
"!=",
"nil",
"{",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
",",
"*",
"cons",
".",
"Container",
")",
"\n",
"}",
"\n",
"if",
"cons",
".",
"CpuPower",
"!=",
"nil",
"{",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
",",
"*",
"cons",
".",
"CpuPower",
")",
"\n",
"}",
"\n",
"if",
"cons",
".",
"Tags",
"!=",
"nil",
"{",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"*",
"cons",
".",
"Tags",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n\n",
"return",
"params",
"\n",
"}"
] | // ParseConstraintsToStartParams takes a constraints object and returns a bare
// StartParams object that has Memory, Cpu, and Disk populated. If there are
// no defined values in the constraints for those fields, default values are
// used. Other constrains cause a warning to be emitted. | [
"ParseConstraintsToStartParams",
"takes",
"a",
"constraints",
"object",
"and",
"returns",
"a",
"bare",
"StartParams",
"object",
"that",
"has",
"Memory",
"Cpu",
"and",
"Disk",
"populated",
".",
"If",
"there",
"are",
"no",
"defined",
"values",
"in",
"the",
"constraints",
"for",
"those",
"fields",
"default",
"values",
"are",
"used",
".",
"Other",
"constrains",
"cause",
"a",
"warning",
"to",
"be",
"emitted",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/container/kvm/kvm.go#L285-L330 |
157,572 | juju/juju | apiserver/facades/agent/uniter/uniter.go | unitAccessor | func unitAccessor(authorizer facade.Authorizer, st *state.State) common.GetAuthFunc {
return func() (common.AuthFunc, error) {
switch tag := authorizer.GetAuthTag().(type) {
case names.ApplicationTag:
// If called by an application agent, any of the units
// belonging to that application can be accessed.
app, err := st.Application(tag.Name)
if err != nil {
return nil, errors.Trace(err)
}
allUnits, err := app.AllUnits()
if err != nil {
return nil, errors.Trace(err)
}
return func(tag names.Tag) bool {
for _, u := range allUnits {
if u.Tag() == tag {
return true
}
}
return false
}, nil
case names.UnitTag:
return func(tag names.Tag) bool {
return authorizer.AuthOwner(tag)
}, nil
default:
return nil, errors.Errorf("expected names.UnitTag or names.ApplicationTag, got %T", tag)
}
}
} | go | func unitAccessor(authorizer facade.Authorizer, st *state.State) common.GetAuthFunc {
return func() (common.AuthFunc, error) {
switch tag := authorizer.GetAuthTag().(type) {
case names.ApplicationTag:
// If called by an application agent, any of the units
// belonging to that application can be accessed.
app, err := st.Application(tag.Name)
if err != nil {
return nil, errors.Trace(err)
}
allUnits, err := app.AllUnits()
if err != nil {
return nil, errors.Trace(err)
}
return func(tag names.Tag) bool {
for _, u := range allUnits {
if u.Tag() == tag {
return true
}
}
return false
}, nil
case names.UnitTag:
return func(tag names.Tag) bool {
return authorizer.AuthOwner(tag)
}, nil
default:
return nil, errors.Errorf("expected names.UnitTag or names.ApplicationTag, got %T", tag)
}
}
} | [
"func",
"unitAccessor",
"(",
"authorizer",
"facade",
".",
"Authorizer",
",",
"st",
"*",
"state",
".",
"State",
")",
"common",
".",
"GetAuthFunc",
"{",
"return",
"func",
"(",
")",
"(",
"common",
".",
"AuthFunc",
",",
"error",
")",
"{",
"switch",
"tag",
":=",
"authorizer",
".",
"GetAuthTag",
"(",
")",
".",
"(",
"type",
")",
"{",
"case",
"names",
".",
"ApplicationTag",
":",
"// If called by an application agent, any of the units",
"// belonging to that application can be accessed.",
"app",
",",
"err",
":=",
"st",
".",
"Application",
"(",
"tag",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"allUnits",
",",
"err",
":=",
"app",
".",
"AllUnits",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"func",
"(",
"tag",
"names",
".",
"Tag",
")",
"bool",
"{",
"for",
"_",
",",
"u",
":=",
"range",
"allUnits",
"{",
"if",
"u",
".",
"Tag",
"(",
")",
"==",
"tag",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
",",
"nil",
"\n",
"case",
"names",
".",
"UnitTag",
":",
"return",
"func",
"(",
"tag",
"names",
".",
"Tag",
")",
"bool",
"{",
"return",
"authorizer",
".",
"AuthOwner",
"(",
"tag",
")",
"\n",
"}",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tag",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // unitAccessor creates a accessUnit function for accessing a unit | [
"unitAccessor",
"creates",
"a",
"accessUnit",
"function",
"for",
"accessing",
"a",
"unit"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L129-L159 |
157,573 | juju/juju | apiserver/facades/agent/uniter/uniter.go | NewUniterAPIV11 | func NewUniterAPIV11(context facade.Context) (*UniterAPIV11, error) {
uniterAPI, err := NewUniterAPI(context)
if err != nil {
return nil, err
}
authorizer := context.Auth()
st := context.State()
resources := context.Resources()
accessUnit := unitAccessor(authorizer, st)
return &UniterAPIV11{
LXDProfileAPI: NewExternalLXDProfileAPI(st, resources, authorizer, accessUnit, logger),
UniterAPI: *uniterAPI,
}, nil
} | go | func NewUniterAPIV11(context facade.Context) (*UniterAPIV11, error) {
uniterAPI, err := NewUniterAPI(context)
if err != nil {
return nil, err
}
authorizer := context.Auth()
st := context.State()
resources := context.Resources()
accessUnit := unitAccessor(authorizer, st)
return &UniterAPIV11{
LXDProfileAPI: NewExternalLXDProfileAPI(st, resources, authorizer, accessUnit, logger),
UniterAPI: *uniterAPI,
}, nil
} | [
"func",
"NewUniterAPIV11",
"(",
"context",
"facade",
".",
"Context",
")",
"(",
"*",
"UniterAPIV11",
",",
"error",
")",
"{",
"uniterAPI",
",",
"err",
":=",
"NewUniterAPI",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"authorizer",
":=",
"context",
".",
"Auth",
"(",
")",
"\n",
"st",
":=",
"context",
".",
"State",
"(",
")",
"\n",
"resources",
":=",
"context",
".",
"Resources",
"(",
")",
"\n",
"accessUnit",
":=",
"unitAccessor",
"(",
"authorizer",
",",
"st",
")",
"\n",
"return",
"&",
"UniterAPIV11",
"{",
"LXDProfileAPI",
":",
"NewExternalLXDProfileAPI",
"(",
"st",
",",
"resources",
",",
"authorizer",
",",
"accessUnit",
",",
"logger",
")",
",",
"UniterAPI",
":",
"*",
"uniterAPI",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewUniterAPIV11 creates an instance of the V11 uniter API. | [
"NewUniterAPIV11",
"creates",
"an",
"instance",
"of",
"the",
"V11",
"uniter",
"API",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L301-L314 |
157,574 | juju/juju | apiserver/facades/agent/uniter/uniter.go | NewUniterAPIV10 | func NewUniterAPIV10(context facade.Context) (*UniterAPIV10, error) {
uniterAPI, err := NewUniterAPIV11(context)
if err != nil {
return nil, err
}
return &UniterAPIV10{
LXDProfileAPI: uniterAPI.LXDProfileAPI,
UniterAPIV11: *uniterAPI,
}, nil
} | go | func NewUniterAPIV10(context facade.Context) (*UniterAPIV10, error) {
uniterAPI, err := NewUniterAPIV11(context)
if err != nil {
return nil, err
}
return &UniterAPIV10{
LXDProfileAPI: uniterAPI.LXDProfileAPI,
UniterAPIV11: *uniterAPI,
}, nil
} | [
"func",
"NewUniterAPIV10",
"(",
"context",
"facade",
".",
"Context",
")",
"(",
"*",
"UniterAPIV10",
",",
"error",
")",
"{",
"uniterAPI",
",",
"err",
":=",
"NewUniterAPIV11",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"UniterAPIV10",
"{",
"LXDProfileAPI",
":",
"uniterAPI",
".",
"LXDProfileAPI",
",",
"UniterAPIV11",
":",
"*",
"uniterAPI",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewUniterAPIV10 creates an instance of the V10 uniter API. | [
"NewUniterAPIV10",
"creates",
"an",
"instance",
"of",
"the",
"V10",
"uniter",
"API",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L317-L327 |
157,575 | juju/juju | apiserver/facades/agent/uniter/uniter.go | NewUniterAPIV9 | func NewUniterAPIV9(context facade.Context) (*UniterAPIV9, error) {
uniterAPI, err := NewUniterAPIV10(context)
if err != nil {
return nil, err
}
return &UniterAPIV9{
LXDProfileAPI: uniterAPI.LXDProfileAPI,
UniterAPIV10: *uniterAPI,
}, nil
} | go | func NewUniterAPIV9(context facade.Context) (*UniterAPIV9, error) {
uniterAPI, err := NewUniterAPIV10(context)
if err != nil {
return nil, err
}
return &UniterAPIV9{
LXDProfileAPI: uniterAPI.LXDProfileAPI,
UniterAPIV10: *uniterAPI,
}, nil
} | [
"func",
"NewUniterAPIV9",
"(",
"context",
"facade",
".",
"Context",
")",
"(",
"*",
"UniterAPIV9",
",",
"error",
")",
"{",
"uniterAPI",
",",
"err",
":=",
"NewUniterAPIV10",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"UniterAPIV9",
"{",
"LXDProfileAPI",
":",
"uniterAPI",
".",
"LXDProfileAPI",
",",
"UniterAPIV10",
":",
"*",
"uniterAPI",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewUniterAPIV9 creates an instance of the V9 uniter API. | [
"NewUniterAPIV9",
"creates",
"an",
"instance",
"of",
"the",
"V9",
"uniter",
"API",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L330-L339 |
157,576 | juju/juju | apiserver/facades/agent/uniter/uniter.go | NewUniterAPIV8 | func NewUniterAPIV8(context facade.Context) (*UniterAPIV8, error) {
uniterAPI, err := NewUniterAPIV9(context)
if err != nil {
return nil, err
}
return &UniterAPIV8{
UniterAPIV9: *uniterAPI,
}, nil
} | go | func NewUniterAPIV8(context facade.Context) (*UniterAPIV8, error) {
uniterAPI, err := NewUniterAPIV9(context)
if err != nil {
return nil, err
}
return &UniterAPIV8{
UniterAPIV9: *uniterAPI,
}, nil
} | [
"func",
"NewUniterAPIV8",
"(",
"context",
"facade",
".",
"Context",
")",
"(",
"*",
"UniterAPIV8",
",",
"error",
")",
"{",
"uniterAPI",
",",
"err",
":=",
"NewUniterAPIV9",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"UniterAPIV8",
"{",
"UniterAPIV9",
":",
"*",
"uniterAPI",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewUniterAPIV8 creates an instance of the V8 uniter API. | [
"NewUniterAPIV8",
"creates",
"an",
"instance",
"of",
"the",
"V8",
"uniter",
"API",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L342-L350 |
157,577 | juju/juju | apiserver/facades/agent/uniter/uniter.go | NewUniterAPIV7 | func NewUniterAPIV7(context facade.Context) (*UniterAPIV7, error) {
uniterAPI, err := NewUniterAPIV8(context)
if err != nil {
return nil, err
}
return &UniterAPIV7{
UniterAPIV8: *uniterAPI,
}, nil
} | go | func NewUniterAPIV7(context facade.Context) (*UniterAPIV7, error) {
uniterAPI, err := NewUniterAPIV8(context)
if err != nil {
return nil, err
}
return &UniterAPIV7{
UniterAPIV8: *uniterAPI,
}, nil
} | [
"func",
"NewUniterAPIV7",
"(",
"context",
"facade",
".",
"Context",
")",
"(",
"*",
"UniterAPIV7",
",",
"error",
")",
"{",
"uniterAPI",
",",
"err",
":=",
"NewUniterAPIV8",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"UniterAPIV7",
"{",
"UniterAPIV8",
":",
"*",
"uniterAPI",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewUniterAPIV7 creates an instance of the V7 uniter API. | [
"NewUniterAPIV7",
"creates",
"an",
"instance",
"of",
"the",
"V7",
"uniter",
"API",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L353-L361 |
157,578 | juju/juju | apiserver/facades/agent/uniter/uniter.go | NewUniterAPIV6 | func NewUniterAPIV6(context facade.Context) (*UniterAPIV6, error) {
uniterAPI, err := NewUniterAPIV7(context)
if err != nil {
return nil, err
}
return &UniterAPIV6{
UniterAPIV7: *uniterAPI,
}, nil
} | go | func NewUniterAPIV6(context facade.Context) (*UniterAPIV6, error) {
uniterAPI, err := NewUniterAPIV7(context)
if err != nil {
return nil, err
}
return &UniterAPIV6{
UniterAPIV7: *uniterAPI,
}, nil
} | [
"func",
"NewUniterAPIV6",
"(",
"context",
"facade",
".",
"Context",
")",
"(",
"*",
"UniterAPIV6",
",",
"error",
")",
"{",
"uniterAPI",
",",
"err",
":=",
"NewUniterAPIV7",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"UniterAPIV6",
"{",
"UniterAPIV7",
":",
"*",
"uniterAPI",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewUniterAPIV6 creates an instance of the V6 uniter API. | [
"NewUniterAPIV6",
"creates",
"an",
"instance",
"of",
"the",
"V6",
"uniter",
"API",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L364-L372 |
157,579 | juju/juju | apiserver/facades/agent/uniter/uniter.go | NewUniterAPIV5 | func NewUniterAPIV5(context facade.Context) (*UniterAPIV5, error) {
uniterAPI, err := NewUniterAPIV6(context)
if err != nil {
return nil, err
}
return &UniterAPIV5{
UniterAPIV6: *uniterAPI,
}, nil
} | go | func NewUniterAPIV5(context facade.Context) (*UniterAPIV5, error) {
uniterAPI, err := NewUniterAPIV6(context)
if err != nil {
return nil, err
}
return &UniterAPIV5{
UniterAPIV6: *uniterAPI,
}, nil
} | [
"func",
"NewUniterAPIV5",
"(",
"context",
"facade",
".",
"Context",
")",
"(",
"*",
"UniterAPIV5",
",",
"error",
")",
"{",
"uniterAPI",
",",
"err",
":=",
"NewUniterAPIV6",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"UniterAPIV5",
"{",
"UniterAPIV6",
":",
"*",
"uniterAPI",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewUniterAPIV5 creates an instance of the V5 uniter API. | [
"NewUniterAPIV5",
"creates",
"an",
"instance",
"of",
"the",
"V5",
"uniter",
"API",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L375-L383 |
157,580 | juju/juju | apiserver/facades/agent/uniter/uniter.go | NewUniterAPIV4 | func NewUniterAPIV4(context facade.Context) (*UniterAPIV4, error) {
uniterAPI, err := NewUniterAPIV5(context)
if err != nil {
return nil, err
}
return &UniterAPIV4{
UniterAPIV5: *uniterAPI,
}, nil
} | go | func NewUniterAPIV4(context facade.Context) (*UniterAPIV4, error) {
uniterAPI, err := NewUniterAPIV5(context)
if err != nil {
return nil, err
}
return &UniterAPIV4{
UniterAPIV5: *uniterAPI,
}, nil
} | [
"func",
"NewUniterAPIV4",
"(",
"context",
"facade",
".",
"Context",
")",
"(",
"*",
"UniterAPIV4",
",",
"error",
")",
"{",
"uniterAPI",
",",
"err",
":=",
"NewUniterAPIV5",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"UniterAPIV4",
"{",
"UniterAPIV5",
":",
"*",
"uniterAPI",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewUniterAPIV4 creates an instance of the V4 uniter API. | [
"NewUniterAPIV4",
"creates",
"an",
"instance",
"of",
"the",
"V4",
"uniter",
"API",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L386-L394 |
157,581 | juju/juju | apiserver/facades/agent/uniter/uniter.go | PublicAddress | func (u *UniterAPI) PublicAddress(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var address network.Address
address, err = unit.PublicAddress()
if err == nil {
result.Results[i].Result = address.Value
} else if network.IsNoAddressError(err) {
err = common.NoAddressSetError(tag, "public")
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) PublicAddress(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var address network.Address
address, err = unit.PublicAddress()
if err == nil {
result.Results[i].Result = address.Value
} else if network.IsNoAddressError(err) {
err = common.NoAddressSetError(tag, "public")
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"PublicAddress",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"StringResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"StringResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"StringResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"StringResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"if",
"canAccess",
"(",
"tag",
")",
"{",
"var",
"unit",
"*",
"state",
".",
"Unit",
"\n",
"unit",
",",
"err",
"=",
"u",
".",
"getUnit",
"(",
"tag",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"var",
"address",
"network",
".",
"Address",
"\n",
"address",
",",
"err",
"=",
"unit",
".",
"PublicAddress",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Result",
"=",
"address",
".",
"Value",
"\n",
"}",
"else",
"if",
"network",
".",
"IsNoAddressError",
"(",
"err",
")",
"{",
"err",
"=",
"common",
".",
"NoAddressSetError",
"(",
"tag",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // PublicAddress returns the public address for each given unit, if set. | [
"PublicAddress",
"returns",
"the",
"public",
"address",
"for",
"each",
"given",
"unit",
"if",
"set",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L492-L523 |
157,582 | juju/juju | apiserver/facades/agent/uniter/uniter.go | AvailabilityZone | func (u *UniterAPI) AvailabilityZone(args params.Entities) (params.StringResults, error) {
var results params.StringResults
canAccess, err := u.accessUnit()
if err != nil {
return results, errors.Trace(err)
}
// Prep the results.
results = params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
// Collect the zones. No zone will be collected for any entity where
// the tag is invalid or not authorized. Instead the corresponding
// result will be updated with the error.
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var zone string
zone, err = getZone(u.st, tag)
if err == nil {
results.Results[i].Result = zone
}
}
results.Results[i].Error = common.ServerError(err)
}
return results, nil
} | go | func (u *UniterAPI) AvailabilityZone(args params.Entities) (params.StringResults, error) {
var results params.StringResults
canAccess, err := u.accessUnit()
if err != nil {
return results, errors.Trace(err)
}
// Prep the results.
results = params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
// Collect the zones. No zone will be collected for any entity where
// the tag is invalid or not authorized. Instead the corresponding
// result will be updated with the error.
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var zone string
zone, err = getZone(u.st, tag)
if err == nil {
results.Results[i].Result = zone
}
}
results.Results[i].Error = common.ServerError(err)
}
return results, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"AvailabilityZone",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"StringResults",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"StringResults",
"\n\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"results",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// Prep the results.",
"results",
"=",
"params",
".",
"StringResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"StringResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n\n",
"// Collect the zones. No zone will be collected for any entity where",
"// the tag is invalid or not authorized. Instead the corresponding",
"// result will be updated with the error.",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"results",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"if",
"canAccess",
"(",
"tag",
")",
"{",
"var",
"zone",
"string",
"\n",
"zone",
",",
"err",
"=",
"getZone",
"(",
"u",
".",
"st",
",",
"tag",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"results",
".",
"Results",
"[",
"i",
"]",
".",
"Result",
"=",
"zone",
"\n",
"}",
"\n",
"}",
"\n",
"results",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"results",
",",
"nil",
"\n",
"}"
] | // AvailabilityZone returns the availability zone for each given unit, if applicable. | [
"AvailabilityZone",
"returns",
"the",
"availability",
"zone",
"for",
"each",
"given",
"unit",
"if",
"applicable",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L571-L605 |
157,583 | juju/juju | apiserver/facades/agent/uniter/uniter.go | Resolved | func (u *UniterAPI) Resolved(args params.Entities) (params.ResolvedModeResults, error) {
result := params.ResolvedModeResults{
Results: make([]params.ResolvedModeResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ResolvedModeResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
result.Results[i].Mode = params.ResolvedMode(unit.Resolved())
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) Resolved(args params.Entities) (params.ResolvedModeResults, error) {
result := params.ResolvedModeResults{
Results: make([]params.ResolvedModeResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ResolvedModeResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
result.Results[i].Mode = params.ResolvedMode(unit.Resolved())
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"Resolved",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ResolvedModeResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ResolvedModeResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"ResolvedModeResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"ResolvedModeResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"if",
"canAccess",
"(",
"tag",
")",
"{",
"var",
"unit",
"*",
"state",
".",
"Unit",
"\n",
"unit",
",",
"err",
"=",
"u",
".",
"getUnit",
"(",
"tag",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Mode",
"=",
"params",
".",
"ResolvedMode",
"(",
"unit",
".",
"Resolved",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // Resolved returns the current resolved setting for each given unit. | [
"Resolved",
"returns",
"the",
"current",
"resolved",
"setting",
"for",
"each",
"given",
"unit",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L608-L633 |
157,584 | juju/juju | apiserver/facades/agent/uniter/uniter.go | ClearResolved | func (u *UniterAPI) ClearResolved(args params.Entities) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
err = unit.ClearResolved()
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) ClearResolved(args params.Entities) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
err = unit.ClearResolved()
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"ClearResolved",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"ErrorResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"ErrorResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"if",
"canAccess",
"(",
"tag",
")",
"{",
"var",
"unit",
"*",
"state",
".",
"Unit",
"\n",
"unit",
",",
"err",
"=",
"u",
".",
"getUnit",
"(",
"tag",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"unit",
".",
"ClearResolved",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // ClearResolved removes any resolved setting from each given unit. | [
"ClearResolved",
"removes",
"any",
"resolved",
"setting",
"from",
"each",
"given",
"unit",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L636-L661 |
157,585 | juju/juju | apiserver/facades/agent/uniter/uniter.go | HasSubordinates | func (u *UniterAPI) HasSubordinates(args params.Entities) (params.BoolResults, error) {
result := params.BoolResults{
Results: make([]params.BoolResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.BoolResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
subordinates := unit.SubordinateNames()
result.Results[i].Result = len(subordinates) > 0
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) HasSubordinates(args params.Entities) (params.BoolResults, error) {
result := params.BoolResults{
Results: make([]params.BoolResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.BoolResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
subordinates := unit.SubordinateNames()
result.Results[i].Result = len(subordinates) > 0
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"HasSubordinates",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"BoolResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"BoolResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"BoolResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"BoolResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"if",
"canAccess",
"(",
"tag",
")",
"{",
"var",
"unit",
"*",
"state",
".",
"Unit",
"\n",
"unit",
",",
"err",
"=",
"u",
".",
"getUnit",
"(",
"tag",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"subordinates",
":=",
"unit",
".",
"SubordinateNames",
"(",
")",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Result",
"=",
"len",
"(",
"subordinates",
")",
">",
"0",
"\n",
"}",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // HasSubordinates returns the whether each given unit has any subordinates. | [
"HasSubordinates",
"returns",
"the",
"whether",
"each",
"given",
"unit",
"has",
"any",
"subordinates",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L754-L780 |
157,586 | juju/juju | apiserver/facades/agent/uniter/uniter.go | CharmModifiedVersion | func (u *UniterAPI) CharmModifiedVersion(args params.Entities) (params.IntResults, error) {
results := params.IntResults{
Results: make([]params.IntResult, len(args.Entities)),
}
accessUnitOrApplication := common.AuthAny(u.accessUnit, u.accessApplication)
canAccess, err := accessUnitOrApplication()
if err != nil {
return results, err
}
for i, entity := range args.Entities {
ver, err := u.charmModifiedVersion(entity.Tag, canAccess)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].Result = ver
}
return results, nil
} | go | func (u *UniterAPI) CharmModifiedVersion(args params.Entities) (params.IntResults, error) {
results := params.IntResults{
Results: make([]params.IntResult, len(args.Entities)),
}
accessUnitOrApplication := common.AuthAny(u.accessUnit, u.accessApplication)
canAccess, err := accessUnitOrApplication()
if err != nil {
return results, err
}
for i, entity := range args.Entities {
ver, err := u.charmModifiedVersion(entity.Tag, canAccess)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].Result = ver
}
return results, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"CharmModifiedVersion",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"IntResults",
",",
"error",
")",
"{",
"results",
":=",
"params",
".",
"IntResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"IntResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n\n",
"accessUnitOrApplication",
":=",
"common",
".",
"AuthAny",
"(",
"u",
".",
"accessUnit",
",",
"u",
".",
"accessApplication",
")",
"\n",
"canAccess",
",",
"err",
":=",
"accessUnitOrApplication",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"results",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"ver",
",",
"err",
":=",
"u",
".",
"charmModifiedVersion",
"(",
"entity",
".",
"Tag",
",",
"canAccess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"results",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"results",
".",
"Results",
"[",
"i",
"]",
".",
"Result",
"=",
"ver",
"\n",
"}",
"\n",
"return",
"results",
",",
"nil",
"\n",
"}"
] | // CharmModifiedVersion returns the most CharmModifiedVersion for all given
// units or applications. | [
"CharmModifiedVersion",
"returns",
"the",
"most",
"CharmModifiedVersion",
"for",
"all",
"given",
"units",
"or",
"applications",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L784-L803 |
157,587 | juju/juju | apiserver/facades/agent/uniter/uniter.go | CharmURL | func (u *UniterAPI) CharmURL(args params.Entities) (params.StringBoolResults, error) {
result := params.StringBoolResults{
Results: make([]params.StringBoolResult, len(args.Entities)),
}
accessUnitOrApplication := common.AuthAny(u.accessUnit, u.accessApplication)
canAccess, err := accessUnitOrApplication()
if err != nil {
return params.StringBoolResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unitOrApplication state.Entity
unitOrApplication, err = u.st.FindEntity(tag)
if err == nil {
charmURLer := unitOrApplication.(interface {
CharmURL() (*charm.URL, bool)
})
curl, ok := charmURLer.CharmURL()
if curl != nil {
result.Results[i].Result = curl.String()
result.Results[i].Ok = ok
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) CharmURL(args params.Entities) (params.StringBoolResults, error) {
result := params.StringBoolResults{
Results: make([]params.StringBoolResult, len(args.Entities)),
}
accessUnitOrApplication := common.AuthAny(u.accessUnit, u.accessApplication)
canAccess, err := accessUnitOrApplication()
if err != nil {
return params.StringBoolResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unitOrApplication state.Entity
unitOrApplication, err = u.st.FindEntity(tag)
if err == nil {
charmURLer := unitOrApplication.(interface {
CharmURL() (*charm.URL, bool)
})
curl, ok := charmURLer.CharmURL()
if curl != nil {
result.Results[i].Result = curl.String()
result.Results[i].Ok = ok
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"CharmURL",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"StringBoolResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"StringBoolResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"StringBoolResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"accessUnitOrApplication",
":=",
"common",
".",
"AuthAny",
"(",
"u",
".",
"accessUnit",
",",
"u",
".",
"accessApplication",
")",
"\n",
"canAccess",
",",
"err",
":=",
"accessUnitOrApplication",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"StringBoolResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"if",
"canAccess",
"(",
"tag",
")",
"{",
"var",
"unitOrApplication",
"state",
".",
"Entity",
"\n",
"unitOrApplication",
",",
"err",
"=",
"u",
".",
"st",
".",
"FindEntity",
"(",
"tag",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"charmURLer",
":=",
"unitOrApplication",
".",
"(",
"interface",
"{",
"CharmURL",
"(",
")",
"(",
"*",
"charm",
".",
"URL",
",",
"bool",
")",
"\n",
"}",
")",
"\n",
"curl",
",",
"ok",
":=",
"charmURLer",
".",
"CharmURL",
"(",
")",
"\n",
"if",
"curl",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Result",
"=",
"curl",
".",
"String",
"(",
")",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Ok",
"=",
"ok",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // CharmURL returns the charm URL for all given units or applications. | [
"CharmURL",
"returns",
"the",
"charm",
"URL",
"for",
"all",
"given",
"units",
"or",
"applications",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L833-L866 |
157,588 | juju/juju | apiserver/facades/agent/uniter/uniter.go | SetCharmURL | func (u *UniterAPI) SetCharmURL(args params.EntitiesCharmURL) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var curl *charm.URL
curl, err = charm.ParseURL(entity.CharmURL)
if err == nil {
err = unit.SetCharmURL(curl)
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) SetCharmURL(args params.EntitiesCharmURL) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var curl *charm.URL
curl, err = charm.ParseURL(entity.CharmURL)
if err == nil {
err = unit.SetCharmURL(curl)
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"SetCharmURL",
"(",
"args",
"params",
".",
"EntitiesCharmURL",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"ErrorResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"ErrorResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"if",
"canAccess",
"(",
"tag",
")",
"{",
"var",
"unit",
"*",
"state",
".",
"Unit",
"\n",
"unit",
",",
"err",
"=",
"u",
".",
"getUnit",
"(",
"tag",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"var",
"curl",
"*",
"charm",
".",
"URL",
"\n",
"curl",
",",
"err",
"=",
"charm",
".",
"ParseURL",
"(",
"entity",
".",
"CharmURL",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"unit",
".",
"SetCharmURL",
"(",
"curl",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // SetCharmURL sets the charm URL for each given unit. An error will
// be returned if a unit is dead, or the charm URL is not know. | [
"SetCharmURL",
"sets",
"the",
"charm",
"URL",
"for",
"each",
"given",
"unit",
".",
"An",
"error",
"will",
"be",
"returned",
"if",
"a",
"unit",
"is",
"dead",
"or",
"the",
"charm",
"URL",
"is",
"not",
"know",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L870-L899 |
157,589 | juju/juju | apiserver/facades/agent/uniter/uniter.go | WorkloadVersion | func (u *UniterAPI) WorkloadVersion(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
resultItem := &result.Results[i]
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
if !canAccess(tag) {
resultItem.Error = common.ServerError(common.ErrPerm)
continue
}
unit, err := u.getUnit(tag)
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
version, err := unit.WorkloadVersion()
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
resultItem.Result = version
}
return result, nil
} | go | func (u *UniterAPI) WorkloadVersion(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
resultItem := &result.Results[i]
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
if !canAccess(tag) {
resultItem.Error = common.ServerError(common.ErrPerm)
continue
}
unit, err := u.getUnit(tag)
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
version, err := unit.WorkloadVersion()
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
resultItem.Result = version
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"WorkloadVersion",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"StringResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"StringResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"StringResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"StringResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"resultItem",
":=",
"&",
"result",
".",
"Results",
"[",
"i",
"]",
"\n",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"resultItem",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"canAccess",
"(",
"tag",
")",
"{",
"resultItem",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"unit",
",",
"err",
":=",
"u",
".",
"getUnit",
"(",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"resultItem",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"version",
",",
"err",
":=",
"unit",
".",
"WorkloadVersion",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"resultItem",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"resultItem",
".",
"Result",
"=",
"version",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // WorkloadVersion returns the workload version for all given units or applications. | [
"WorkloadVersion",
"returns",
"the",
"workload",
"version",
"for",
"all",
"given",
"units",
"or",
"applications",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L902-L934 |
157,590 | juju/juju | apiserver/facades/agent/uniter/uniter.go | SetWorkloadVersion | func (u *UniterAPI) SetWorkloadVersion(args params.EntityWorkloadVersions) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
resultItem := &result.Results[i]
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
if !canAccess(tag) {
resultItem.Error = common.ServerError(common.ErrPerm)
continue
}
unit, err := u.getUnit(tag)
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
err = unit.SetWorkloadVersion(entity.WorkloadVersion)
if err != nil {
resultItem.Error = common.ServerError(err)
}
}
return result, nil
} | go | func (u *UniterAPI) SetWorkloadVersion(args params.EntityWorkloadVersions) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
resultItem := &result.Results[i]
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
if !canAccess(tag) {
resultItem.Error = common.ServerError(common.ErrPerm)
continue
}
unit, err := u.getUnit(tag)
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
err = unit.SetWorkloadVersion(entity.WorkloadVersion)
if err != nil {
resultItem.Error = common.ServerError(err)
}
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"SetWorkloadVersion",
"(",
"args",
"params",
".",
"EntityWorkloadVersions",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"ErrorResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"ErrorResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"resultItem",
":=",
"&",
"result",
".",
"Results",
"[",
"i",
"]",
"\n",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"resultItem",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"canAccess",
"(",
"tag",
")",
"{",
"resultItem",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"unit",
",",
"err",
":=",
"u",
".",
"getUnit",
"(",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"resultItem",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"unit",
".",
"SetWorkloadVersion",
"(",
"entity",
".",
"WorkloadVersion",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"resultItem",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // SetWorkloadVersion sets the workload version for each given unit. An error will
// be returned if a unit is dead. | [
"SetWorkloadVersion",
"sets",
"the",
"workload",
"version",
"for",
"each",
"given",
"unit",
".",
"An",
"error",
"will",
"be",
"returned",
"if",
"a",
"unit",
"is",
"dead",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L938-L968 |
157,591 | juju/juju | apiserver/facades/agent/uniter/uniter.go | ConfigSettings | func (u *UniterAPI) ConfigSettings(args params.Entities) (params.ConfigSettingsResults, error) {
result := params.ConfigSettingsResults{
Results: make([]params.ConfigSettingsResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ConfigSettingsResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var settings charm.Settings
settings, err = unit.ConfigSettings()
if err == nil {
result.Results[i].Settings = params.ConfigSettings(settings)
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) ConfigSettings(args params.Entities) (params.ConfigSettingsResults, error) {
result := params.ConfigSettingsResults{
Results: make([]params.ConfigSettingsResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ConfigSettingsResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var settings charm.Settings
settings, err = unit.ConfigSettings()
if err == nil {
result.Results[i].Settings = params.ConfigSettings(settings)
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"ConfigSettings",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ConfigSettingsResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ConfigSettingsResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"ConfigSettingsResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"ConfigSettingsResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"if",
"canAccess",
"(",
"tag",
")",
"{",
"var",
"unit",
"*",
"state",
".",
"Unit",
"\n",
"unit",
",",
"err",
"=",
"u",
".",
"getUnit",
"(",
"tag",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"var",
"settings",
"charm",
".",
"Settings",
"\n",
"settings",
",",
"err",
"=",
"unit",
".",
"ConfigSettings",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Settings",
"=",
"params",
".",
"ConfigSettings",
"(",
"settings",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // ConfigSettings returns the complete set of application charm config
// settings available to each given unit. | [
"ConfigSettings",
"returns",
"the",
"complete",
"set",
"of",
"application",
"charm",
"config",
"settings",
"available",
"to",
"each",
"given",
"unit",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L1096-L1125 |
157,592 | juju/juju | apiserver/facades/agent/uniter/uniter.go | Actions | func (u *UniterAPI) Actions(args params.Entities) (params.ActionResults, error) {
canAccess, err := u.accessUnit()
if err != nil {
return params.ActionResults{}, err
}
m, err := u.st.Model()
if err != nil {
return params.ActionResults{}, errors.Trace(err)
}
actionFn := common.AuthAndActionFromTagFn(canAccess, m.ActionByTag)
return common.Actions(args, actionFn), nil
} | go | func (u *UniterAPI) Actions(args params.Entities) (params.ActionResults, error) {
canAccess, err := u.accessUnit()
if err != nil {
return params.ActionResults{}, err
}
m, err := u.st.Model()
if err != nil {
return params.ActionResults{}, errors.Trace(err)
}
actionFn := common.AuthAndActionFromTagFn(canAccess, m.ActionByTag)
return common.Actions(args, actionFn), nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"Actions",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ActionResults",
",",
"error",
")",
"{",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"ActionResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"m",
",",
"err",
":=",
"u",
".",
"st",
".",
"Model",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"ActionResults",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"actionFn",
":=",
"common",
".",
"AuthAndActionFromTagFn",
"(",
"canAccess",
",",
"m",
".",
"ActionByTag",
")",
"\n",
"return",
"common",
".",
"Actions",
"(",
"args",
",",
"actionFn",
")",
",",
"nil",
"\n",
"}"
] | // Actions returns the Actions by Tags passed and ensures that the Unit asking
// for them is the same Unit that has the Actions. | [
"Actions",
"returns",
"the",
"Actions",
"by",
"Tags",
"passed",
"and",
"ensures",
"that",
"the",
"Unit",
"asking",
"for",
"them",
"is",
"the",
"same",
"Unit",
"that",
"has",
"the",
"Actions",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L1174-L1187 |
157,593 | juju/juju | apiserver/facades/agent/uniter/uniter.go | RelationById | func (u *UniterAPI) RelationById(args params.RelationIds) (params.RelationResults, error) {
result := params.RelationResults{
Results: make([]params.RelationResult, len(args.RelationIds)),
}
for i, relId := range args.RelationIds {
relParams, err := u.getOneRelationById(relId)
if err == nil {
result.Results[i] = relParams
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) RelationById(args params.RelationIds) (params.RelationResults, error) {
result := params.RelationResults{
Results: make([]params.RelationResult, len(args.RelationIds)),
}
for i, relId := range args.RelationIds {
relParams, err := u.getOneRelationById(relId)
if err == nil {
result.Results[i] = relParams
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"RelationById",
"(",
"args",
"params",
".",
"RelationIds",
")",
"(",
"params",
".",
"RelationResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"RelationResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"RelationResult",
",",
"len",
"(",
"args",
".",
"RelationIds",
")",
")",
",",
"}",
"\n",
"for",
"i",
",",
"relId",
":=",
"range",
"args",
".",
"RelationIds",
"{",
"relParams",
",",
"err",
":=",
"u",
".",
"getOneRelationById",
"(",
"relId",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
"=",
"relParams",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // RelationById returns information about all given relations,
// specified by their ids, including their key and the local
// endpoint. | [
"RelationById",
"returns",
"information",
"about",
"all",
"given",
"relations",
"specified",
"by",
"their",
"ids",
"including",
"their",
"key",
"and",
"the",
"local",
"endpoint",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L1224-L1236 |
157,594 | juju/juju | apiserver/facades/agent/uniter/uniter.go | RelationsStatus | func (u *UniterAPI) RelationsStatus(args params.Entities) (params.RelationUnitStatusResults, error) {
result := params.RelationUnitStatusResults{
Results: make([]params.RelationUnitStatusResult, len(args.Entities)),
}
if len(args.Entities) == 0 {
return result, nil
}
canRead, err := u.accessUnit()
if err != nil {
return params.RelationUnitStatusResults{}, err
}
oneRelationUnitStatus := func(rel *state.Relation, unit *state.Unit) (params.RelationUnitStatus, error) {
rus := params.RelationUnitStatus{
RelationTag: rel.Tag().String(),
Suspended: rel.Suspended(),
}
ru, err := rel.Unit(unit)
if err != nil {
return params.RelationUnitStatus{}, errors.Trace(err)
}
inScope, err := ru.InScope()
if err != nil {
return params.RelationUnitStatus{}, errors.Trace(err)
}
rus.InScope = inScope
return rus, nil
}
relationResults := func(unit *state.Unit) ([]params.RelationUnitStatus, error) {
var ruStatus []params.RelationUnitStatus
app, err := unit.Application()
if err != nil {
return nil, errors.Trace(err)
}
relations, err := app.Relations()
for _, rel := range relations {
rus, err := oneRelationUnitStatus(rel, unit)
if err != nil {
return nil, errors.Trace(err)
}
ruStatus = append(ruStatus, rus)
}
return ruStatus, nil
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canRead(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
result.Results[i].RelationResults, err = relationResults(unit)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) RelationsStatus(args params.Entities) (params.RelationUnitStatusResults, error) {
result := params.RelationUnitStatusResults{
Results: make([]params.RelationUnitStatusResult, len(args.Entities)),
}
if len(args.Entities) == 0 {
return result, nil
}
canRead, err := u.accessUnit()
if err != nil {
return params.RelationUnitStatusResults{}, err
}
oneRelationUnitStatus := func(rel *state.Relation, unit *state.Unit) (params.RelationUnitStatus, error) {
rus := params.RelationUnitStatus{
RelationTag: rel.Tag().String(),
Suspended: rel.Suspended(),
}
ru, err := rel.Unit(unit)
if err != nil {
return params.RelationUnitStatus{}, errors.Trace(err)
}
inScope, err := ru.InScope()
if err != nil {
return params.RelationUnitStatus{}, errors.Trace(err)
}
rus.InScope = inScope
return rus, nil
}
relationResults := func(unit *state.Unit) ([]params.RelationUnitStatus, error) {
var ruStatus []params.RelationUnitStatus
app, err := unit.Application()
if err != nil {
return nil, errors.Trace(err)
}
relations, err := app.Relations()
for _, rel := range relations {
rus, err := oneRelationUnitStatus(rel, unit)
if err != nil {
return nil, errors.Trace(err)
}
ruStatus = append(ruStatus, rus)
}
return ruStatus, nil
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canRead(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
result.Results[i].RelationResults, err = relationResults(unit)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"RelationsStatus",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"RelationUnitStatusResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"RelationUnitStatusResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"RelationUnitStatusResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"if",
"len",
"(",
"args",
".",
"Entities",
")",
"==",
"0",
"{",
"return",
"result",
",",
"nil",
"\n",
"}",
"\n",
"canRead",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"RelationUnitStatusResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"oneRelationUnitStatus",
":=",
"func",
"(",
"rel",
"*",
"state",
".",
"Relation",
",",
"unit",
"*",
"state",
".",
"Unit",
")",
"(",
"params",
".",
"RelationUnitStatus",
",",
"error",
")",
"{",
"rus",
":=",
"params",
".",
"RelationUnitStatus",
"{",
"RelationTag",
":",
"rel",
".",
"Tag",
"(",
")",
".",
"String",
"(",
")",
",",
"Suspended",
":",
"rel",
".",
"Suspended",
"(",
")",
",",
"}",
"\n",
"ru",
",",
"err",
":=",
"rel",
".",
"Unit",
"(",
"unit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"RelationUnitStatus",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"inScope",
",",
"err",
":=",
"ru",
".",
"InScope",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"RelationUnitStatus",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"rus",
".",
"InScope",
"=",
"inScope",
"\n",
"return",
"rus",
",",
"nil",
"\n",
"}",
"\n\n",
"relationResults",
":=",
"func",
"(",
"unit",
"*",
"state",
".",
"Unit",
")",
"(",
"[",
"]",
"params",
".",
"RelationUnitStatus",
",",
"error",
")",
"{",
"var",
"ruStatus",
"[",
"]",
"params",
".",
"RelationUnitStatus",
"\n",
"app",
",",
"err",
":=",
"unit",
".",
"Application",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"relations",
",",
"err",
":=",
"app",
".",
"Relations",
"(",
")",
"\n",
"for",
"_",
",",
"rel",
":=",
"range",
"relations",
"{",
"rus",
",",
"err",
":=",
"oneRelationUnitStatus",
"(",
"rel",
",",
"unit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"ruStatus",
"=",
"append",
"(",
"ruStatus",
",",
"rus",
")",
"\n",
"}",
"\n",
"return",
"ruStatus",
",",
"nil",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"if",
"canRead",
"(",
"tag",
")",
"{",
"var",
"unit",
"*",
"state",
".",
"Unit",
"\n",
"unit",
",",
"err",
"=",
"u",
".",
"getUnit",
"(",
"tag",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"RelationResults",
",",
"err",
"=",
"relationResults",
"(",
"unit",
")",
"\n",
"}",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // RelationsStatus returns for each unit the corresponding relation and status information. | [
"RelationsStatus",
"returns",
"for",
"each",
"unit",
"the",
"corresponding",
"relation",
"and",
"status",
"information",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L1272-L1335 |
157,595 | juju/juju | apiserver/facades/agent/uniter/uniter.go | Refresh | func (u *UniterAPI) Refresh(args params.Entities) (params.UnitRefreshResults, error) {
result := params.UnitRefreshResults{
Results: make([]params.UnitRefreshResult, len(args.Entities)),
}
if len(args.Entities) == 0 {
return result, nil
}
canRead, err := u.accessUnit()
if err != nil {
return params.UnitRefreshResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canRead(tag) {
var unit *state.Unit
if unit, err = u.getUnit(tag); err == nil {
result.Results[i].Life = params.Life(unit.Life().String())
result.Results[i].Resolved = params.ResolvedMode(unit.Resolved())
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) Refresh(args params.Entities) (params.UnitRefreshResults, error) {
result := params.UnitRefreshResults{
Results: make([]params.UnitRefreshResult, len(args.Entities)),
}
if len(args.Entities) == 0 {
return result, nil
}
canRead, err := u.accessUnit()
if err != nil {
return params.UnitRefreshResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canRead(tag) {
var unit *state.Unit
if unit, err = u.getUnit(tag); err == nil {
result.Results[i].Life = params.Life(unit.Life().String())
result.Results[i].Resolved = params.ResolvedMode(unit.Resolved())
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"Refresh",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"UnitRefreshResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"UnitRefreshResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"UnitRefreshResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"if",
"len",
"(",
"args",
".",
"Entities",
")",
"==",
"0",
"{",
"return",
"result",
",",
"nil",
"\n",
"}",
"\n",
"canRead",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"UnitRefreshResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"if",
"canRead",
"(",
"tag",
")",
"{",
"var",
"unit",
"*",
"state",
".",
"Unit",
"\n",
"if",
"unit",
",",
"err",
"=",
"u",
".",
"getUnit",
"(",
"tag",
")",
";",
"err",
"==",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Life",
"=",
"params",
".",
"Life",
"(",
"unit",
".",
"Life",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Resolved",
"=",
"params",
".",
"ResolvedMode",
"(",
"unit",
".",
"Resolved",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // Refresh retrieves the latest values for attributes on this unit. | [
"Refresh",
"retrieves",
"the",
"latest",
"values",
"for",
"attributes",
"on",
"this",
"unit",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L1338-L1366 |
157,596 | juju/juju | apiserver/facades/agent/uniter/uniter.go | UpdateSettings | func (u *UniterAPI) UpdateSettings(args params.RelationUnitsSettings) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.RelationUnits)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, arg := range args.RelationUnits {
unit, err := names.ParseUnitTag(arg.Unit)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
relUnit, err := u.getRelationUnit(canAccess, arg.Relation, unit)
if err == nil {
var settings *state.Settings
settings, err = relUnit.Settings()
if err == nil {
for k, v := range arg.Settings {
if v == "" {
settings.Delete(k)
} else {
settings.Set(k, v)
}
}
_, err = settings.Write()
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) UpdateSettings(args params.RelationUnitsSettings) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.RelationUnits)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, arg := range args.RelationUnits {
unit, err := names.ParseUnitTag(arg.Unit)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
relUnit, err := u.getRelationUnit(canAccess, arg.Relation, unit)
if err == nil {
var settings *state.Settings
settings, err = relUnit.Settings()
if err == nil {
for k, v := range arg.Settings {
if v == "" {
settings.Delete(k)
} else {
settings.Set(k, v)
}
}
_, err = settings.Write()
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"UpdateSettings",
"(",
"args",
"params",
".",
"RelationUnitsSettings",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"ErrorResult",
",",
"len",
"(",
"args",
".",
"RelationUnits",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"ErrorResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"arg",
":=",
"range",
"args",
".",
"RelationUnits",
"{",
"unit",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"arg",
".",
"Unit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"relUnit",
",",
"err",
":=",
"u",
".",
"getRelationUnit",
"(",
"canAccess",
",",
"arg",
".",
"Relation",
",",
"unit",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"var",
"settings",
"*",
"state",
".",
"Settings",
"\n",
"settings",
",",
"err",
"=",
"relUnit",
".",
"Settings",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"arg",
".",
"Settings",
"{",
"if",
"v",
"==",
"\"",
"\"",
"{",
"settings",
".",
"Delete",
"(",
"k",
")",
"\n",
"}",
"else",
"{",
"settings",
".",
"Set",
"(",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"settings",
".",
"Write",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // UpdateSettings persists all changes made to the local settings of
// all given pairs of relation and unit. Keys with empty values are
// considered a signal to delete these values. | [
"UpdateSettings",
"persists",
"all",
"changes",
"made",
"to",
"the",
"local",
"settings",
"of",
"all",
"given",
"pairs",
"of",
"relation",
"and",
"unit",
".",
"Keys",
"with",
"empty",
"values",
"are",
"considered",
"a",
"signal",
"to",
"delete",
"these",
"values",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L1561-L1593 |
157,597 | juju/juju | apiserver/facades/agent/uniter/uniter.go | WatchUnitAddresses | func (u *UniterAPIV8) WatchUnitAddresses(args params.Entities) (params.NotifyWatchResults, error) {
result := params.NotifyWatchResults{
Results: make([]params.NotifyWatchResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.NotifyWatchResults{}, err
}
for i, entity := range args.Entities {
unit, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
watcherId := ""
if canAccess(unit) {
watcherId, err = u.watchOneUnitAddresses(unit)
}
result.Results[i].NotifyWatcherId = watcherId
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPIV8) WatchUnitAddresses(args params.Entities) (params.NotifyWatchResults, error) {
result := params.NotifyWatchResults{
Results: make([]params.NotifyWatchResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.NotifyWatchResults{}, err
}
for i, entity := range args.Entities {
unit, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
watcherId := ""
if canAccess(unit) {
watcherId, err = u.watchOneUnitAddresses(unit)
}
result.Results[i].NotifyWatcherId = watcherId
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPIV8",
")",
"WatchUnitAddresses",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"NotifyWatchResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"NotifyWatchResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"NotifyWatchResult",
",",
"len",
"(",
"args",
".",
"Entities",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"NotifyWatchResults",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"entity",
":=",
"range",
"args",
".",
"Entities",
"{",
"unit",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"entity",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"common",
".",
"ErrPerm",
"\n",
"watcherId",
":=",
"\"",
"\"",
"\n",
"if",
"canAccess",
"(",
"unit",
")",
"{",
"watcherId",
",",
"err",
"=",
"u",
".",
"watchOneUnitAddresses",
"(",
"unit",
")",
"\n",
"}",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"NotifyWatcherId",
"=",
"watcherId",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // WatchUnitAddresses returns a NotifyWatcher for observing changes
// to each unit's addresses. | [
"WatchUnitAddresses",
"returns",
"a",
"NotifyWatcher",
"for",
"observing",
"changes",
"to",
"each",
"unit",
"s",
"addresses",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L1704-L1727 |
157,598 | juju/juju | apiserver/facades/agent/uniter/uniter.go | AddMetricBatches | func (u *UniterAPI) AddMetricBatches(args params.MetricBatchParams) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Batches)),
}
canAccess, err := u.accessUnit()
if err != nil {
logger.Warningf("failed to check unit access: %v", err)
return params.ErrorResults{}, common.ErrPerm
}
for i, batch := range args.Batches {
tag, err := names.ParseUnitTag(batch.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
if !canAccess(tag) {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
metrics := make([]state.Metric, len(batch.Batch.Metrics))
for j, metric := range batch.Batch.Metrics {
metrics[j] = state.Metric{
Key: metric.Key,
Value: metric.Value,
Time: metric.Time,
Labels: metric.Labels,
}
}
_, err = u.st.AddMetrics(state.BatchParam{
UUID: batch.Batch.UUID,
Created: batch.Batch.Created,
CharmURL: batch.Batch.CharmURL,
Metrics: metrics,
Unit: tag,
})
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (u *UniterAPI) AddMetricBatches(args params.MetricBatchParams) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Batches)),
}
canAccess, err := u.accessUnit()
if err != nil {
logger.Warningf("failed to check unit access: %v", err)
return params.ErrorResults{}, common.ErrPerm
}
for i, batch := range args.Batches {
tag, err := names.ParseUnitTag(batch.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
if !canAccess(tag) {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
metrics := make([]state.Metric, len(batch.Batch.Metrics))
for j, metric := range batch.Batch.Metrics {
metrics[j] = state.Metric{
Key: metric.Key,
Value: metric.Value,
Time: metric.Time,
Labels: metric.Labels,
}
}
_, err = u.st.AddMetrics(state.BatchParam{
UUID: batch.Batch.UUID,
Created: batch.Batch.Created,
CharmURL: batch.Batch.CharmURL,
Metrics: metrics,
Unit: tag,
})
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"AddMetricBatches",
"(",
"args",
"params",
".",
"MetricBatchParams",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"params",
".",
"ErrorResult",
",",
"len",
"(",
"args",
".",
"Batches",
")",
")",
",",
"}",
"\n",
"canAccess",
",",
"err",
":=",
"u",
".",
"accessUnit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"params",
".",
"ErrorResults",
"{",
"}",
",",
"common",
".",
"ErrPerm",
"\n",
"}",
"\n",
"for",
"i",
",",
"batch",
":=",
"range",
"args",
".",
"Batches",
"{",
"tag",
",",
"err",
":=",
"names",
".",
"ParseUnitTag",
"(",
"batch",
".",
"Tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"canAccess",
"(",
"tag",
")",
"{",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"common",
".",
"ErrPerm",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"metrics",
":=",
"make",
"(",
"[",
"]",
"state",
".",
"Metric",
",",
"len",
"(",
"batch",
".",
"Batch",
".",
"Metrics",
")",
")",
"\n",
"for",
"j",
",",
"metric",
":=",
"range",
"batch",
".",
"Batch",
".",
"Metrics",
"{",
"metrics",
"[",
"j",
"]",
"=",
"state",
".",
"Metric",
"{",
"Key",
":",
"metric",
".",
"Key",
",",
"Value",
":",
"metric",
".",
"Value",
",",
"Time",
":",
"metric",
".",
"Time",
",",
"Labels",
":",
"metric",
".",
"Labels",
",",
"}",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"u",
".",
"st",
".",
"AddMetrics",
"(",
"state",
".",
"BatchParam",
"{",
"UUID",
":",
"batch",
".",
"Batch",
".",
"UUID",
",",
"Created",
":",
"batch",
".",
"Batch",
".",
"Created",
",",
"CharmURL",
":",
"batch",
".",
"Batch",
".",
"CharmURL",
",",
"Metrics",
":",
"metrics",
",",
"Unit",
":",
"tag",
",",
"}",
")",
"\n",
"result",
".",
"Results",
"[",
"i",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // AddMetricBatches adds the metrics for the specified unit. | [
"AddMetricBatches",
"adds",
"the",
"metrics",
"for",
"the",
"specified",
"unit",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L2025-L2063 |
157,599 | juju/juju | apiserver/facades/agent/uniter/uniter.go | SLALevel | func (u *UniterAPI) SLALevel() (params.StringResult, error) {
result := params.StringResult{}
sla, err := u.st.SLALevel()
if err == nil {
result.Result = sla
}
return result, err
} | go | func (u *UniterAPI) SLALevel() (params.StringResult, error) {
result := params.StringResult{}
sla, err := u.st.SLALevel()
if err == nil {
result.Result = sla
}
return result, err
} | [
"func",
"(",
"u",
"*",
"UniterAPI",
")",
"SLALevel",
"(",
")",
"(",
"params",
".",
"StringResult",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"StringResult",
"{",
"}",
"\n",
"sla",
",",
"err",
":=",
"u",
".",
"st",
".",
"SLALevel",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"result",
".",
"Result",
"=",
"sla",
"\n",
"}",
"\n",
"return",
"result",
",",
"err",
"\n",
"}"
] | // V4 specific methods.
// specific methods - the new SLALevel, NetworkInfo and
// WatchUnitRelations methods.
// SLALevel returns the model's SLA level. | [
"V4",
"specific",
"methods",
".",
"specific",
"methods",
"-",
"the",
"new",
"SLALevel",
"NetworkInfo",
"and",
"WatchUnitRelations",
"methods",
".",
"SLALevel",
"returns",
"the",
"model",
"s",
"SLA",
"level",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/uniter/uniter.go#L2071-L2078 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.