id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
4,500 | juju/juju | provider/ec2/environ.go | isSubnetConstrainedError | func isSubnetConstrainedError(err error) bool {
switch err := errors.Cause(err).(type) {
case *ec2.Error:
switch err.Code {
case "InsufficientFreeAddressesInSubnet", "InsufficientInstanceCapacity":
// Subnet and/or VPC general limits reached.
return true
case "InvalidSubnetID.NotFound":
// This shouldn't happen, as we validate the subnet IDs, but it can
// happen if the user manually deleted the subnet outside of Juju.
return true
}
}
return false
} | go | func isSubnetConstrainedError(err error) bool {
switch err := errors.Cause(err).(type) {
case *ec2.Error:
switch err.Code {
case "InsufficientFreeAddressesInSubnet", "InsufficientInstanceCapacity":
// Subnet and/or VPC general limits reached.
return true
case "InvalidSubnetID.NotFound":
// This shouldn't happen, as we validate the subnet IDs, but it can
// happen if the user manually deleted the subnet outside of Juju.
return true
}
}
return false
} | [
"func",
"isSubnetConstrainedError",
"(",
"err",
"error",
")",
"bool",
"{",
"switch",
"err",
":=",
"errors",
".",
"Cause",
"(",
"err",
")",
".",
"(",
"type",
")",
"{",
"case",
"*",
"ec2",
".",
"Error",
":",
"switch",
"err",
".",
"Code",
"{",
"case",
... | // isSubnetConstrainedError reports whether or not the error indicates
// RunInstances failed due to the specified VPC subnet ID being constrained for
// the instance type being provisioned, or is otherwise unusable for the
// specific request made. | [
"isSubnetConstrainedError",
"reports",
"whether",
"or",
"not",
"the",
"error",
"indicates",
"RunInstances",
"failed",
"due",
"to",
"the",
"specified",
"VPC",
"subnet",
"ID",
"being",
"constrained",
"for",
"the",
"instance",
"type",
"being",
"provisioned",
"or",
"i... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/ec2/environ.go#L1968-L1982 |
4,501 | juju/juju | provider/ec2/environ.go | SuperSubnets | func (e *environ) SuperSubnets(ctx context.ProviderCallContext) ([]string, error) {
vpcId := e.ecfg().vpcID()
if !isVPCIDSet(vpcId) {
if hasDefaultVPC, err := e.hasDefaultVPC(ctx); err == nil && hasDefaultVPC {
vpcId = e.defaultVPC.Id
}
}
if !isVPCIDSet(vpcId) {
return nil, errors.NotSupportedf("Not a VPC environment")
}
cidr, err := getVPCCIDR(e.ec2, ctx, vpcId)
if err != nil {
return nil, err
}
return []string{cidr}, nil
} | go | func (e *environ) SuperSubnets(ctx context.ProviderCallContext) ([]string, error) {
vpcId := e.ecfg().vpcID()
if !isVPCIDSet(vpcId) {
if hasDefaultVPC, err := e.hasDefaultVPC(ctx); err == nil && hasDefaultVPC {
vpcId = e.defaultVPC.Id
}
}
if !isVPCIDSet(vpcId) {
return nil, errors.NotSupportedf("Not a VPC environment")
}
cidr, err := getVPCCIDR(e.ec2, ctx, vpcId)
if err != nil {
return nil, err
}
return []string{cidr}, nil
} | [
"func",
"(",
"e",
"*",
"environ",
")",
"SuperSubnets",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"vpcId",
":=",
"e",
".",
"ecfg",
"(",
")",
".",
"vpcID",
"(",
")",
"\n",
"if",
"!",
"i... | // SuperSubnets implements NetworkingEnviron.SuperSubnets | [
"SuperSubnets",
"implements",
"NetworkingEnviron",
".",
"SuperSubnets"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/ec2/environ.go#L2062-L2077 |
4,502 | juju/juju | api/annotations/client.go | Get | func (c *Client) Get(tags []string) ([]params.AnnotationsGetResult, error) {
annotations := params.AnnotationsGetResults{}
if err := c.facade.FacadeCall("Get", entitiesFromTags(tags), &annotations); err != nil {
return annotations.Results, errors.Trace(err)
}
return annotations.Results, nil
} | go | func (c *Client) Get(tags []string) ([]params.AnnotationsGetResult, error) {
annotations := params.AnnotationsGetResults{}
if err := c.facade.FacadeCall("Get", entitiesFromTags(tags), &annotations); err != nil {
return annotations.Results, errors.Trace(err)
}
return annotations.Results, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Get",
"(",
"tags",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"params",
".",
"AnnotationsGetResult",
",",
"error",
")",
"{",
"annotations",
":=",
"params",
".",
"AnnotationsGetResults",
"{",
"}",
"\n",
"if",
"err",
... | // Get returns annotations that have been set on the given entities. | [
"Get",
"returns",
"annotations",
"that",
"have",
"been",
"set",
"on",
"the",
"given",
"entities",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/annotations/client.go#L26-L32 |
4,503 | juju/juju | api/annotations/client.go | Set | func (c *Client) Set(annotations map[string]map[string]string) ([]params.ErrorResult, error) {
args := params.AnnotationsSet{entitiesAnnotations(annotations)}
results := new(params.ErrorResults)
if err := c.facade.FacadeCall("Set", args, results); err != nil {
return nil, errors.Trace(err)
}
return results.Results, nil
} | go | func (c *Client) Set(annotations map[string]map[string]string) ([]params.ErrorResult, error) {
args := params.AnnotationsSet{entitiesAnnotations(annotations)}
results := new(params.ErrorResults)
if err := c.facade.FacadeCall("Set", args, results); err != nil {
return nil, errors.Trace(err)
}
return results.Results, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Set",
"(",
"annotations",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"[",
"]",
"params",
".",
"ErrorResult",
",",
"error",
")",
"{",
"args",
":=",
"params",
".",
"AnnotationsSet",
... | // Set sets entity annotation pairs. | [
"Set",
"sets",
"entity",
"annotation",
"pairs",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/annotations/client.go#L35-L42 |
4,504 | juju/juju | cmd/juju/storage/filesystemlistformatters.go | formatFilesystemListTabular | func formatFilesystemListTabular(writer io.Writer, infos map[string]FilesystemInfo) error {
tw := output.TabWriter(writer)
print := func(values ...string) {
fmt.Fprintln(tw, strings.Join(values, "\t"))
}
haveMachines := false
filesystemAttachmentInfos := make(filesystemAttachmentInfos, 0, len(infos))
for filesystemId, info := range infos {
filesystemAttachmentInfo := filesystemAttachmentInfo{
FilesystemId: filesystemId,
FilesystemInfo: info,
}
if info.Attachments == nil {
filesystemAttachmentInfos = append(filesystemAttachmentInfos, filesystemAttachmentInfo)
continue
}
// Each unit attachment must have a corresponding filesystem
// attachment. Enumerate each of the filesystem attachments,
// and locate the corresponding unit attachment if any.
// Each filesystem attachment has at most one corresponding
// unit attachment.
for machineId, machineInfo := range info.Attachments.Machines {
filesystemAttachmentInfo := filesystemAttachmentInfo
filesystemAttachmentInfo.MachineId = machineId
filesystemAttachmentInfo.FilesystemAttachment = machineInfo
for unitId, unitInfo := range info.Attachments.Units {
if unitInfo.MachineId == machineId {
filesystemAttachmentInfo.UnitId = unitId
filesystemAttachmentInfo.UnitStorageAttachment = unitInfo
break
}
}
haveMachines = true
filesystemAttachmentInfos = append(filesystemAttachmentInfos, filesystemAttachmentInfo)
}
for hostId, containerInfo := range info.Attachments.Containers {
filesystemAttachmentInfo := filesystemAttachmentInfo
filesystemAttachmentInfo.FilesystemAttachment = containerInfo
for unitId, unitInfo := range info.Attachments.Units {
if hostId == unitId {
filesystemAttachmentInfo.UnitId = unitId
filesystemAttachmentInfo.UnitStorageAttachment = unitInfo
break
}
}
filesystemAttachmentInfos = append(filesystemAttachmentInfos, filesystemAttachmentInfo)
}
}
sort.Sort(filesystemAttachmentInfos)
if haveMachines {
print("Machine", "Unit", "Storage id", "Id", "Volume", "Provider id", "Mountpoint", "Size", "State", "Message")
} else {
print("Unit", "Storage id", "Id", "Provider id", "Mountpoint", "Size", "State", "Message")
}
for _, info := range filesystemAttachmentInfos {
var size string
if info.Size > 0 {
size = humanize.IBytes(info.Size * humanize.MiByte)
}
if haveMachines {
print(
info.MachineId, info.UnitId, info.Storage,
info.FilesystemId, info.Volume, info.ProviderFilesystemId,
info.MountPoint, size,
string(info.Status.Current), info.Status.Message,
)
} else {
print(
info.UnitId, info.Storage,
info.FilesystemId, info.ProviderFilesystemId,
info.MountPoint, size,
string(info.Status.Current), info.Status.Message,
)
}
}
return tw.Flush()
} | go | func formatFilesystemListTabular(writer io.Writer, infos map[string]FilesystemInfo) error {
tw := output.TabWriter(writer)
print := func(values ...string) {
fmt.Fprintln(tw, strings.Join(values, "\t"))
}
haveMachines := false
filesystemAttachmentInfos := make(filesystemAttachmentInfos, 0, len(infos))
for filesystemId, info := range infos {
filesystemAttachmentInfo := filesystemAttachmentInfo{
FilesystemId: filesystemId,
FilesystemInfo: info,
}
if info.Attachments == nil {
filesystemAttachmentInfos = append(filesystemAttachmentInfos, filesystemAttachmentInfo)
continue
}
// Each unit attachment must have a corresponding filesystem
// attachment. Enumerate each of the filesystem attachments,
// and locate the corresponding unit attachment if any.
// Each filesystem attachment has at most one corresponding
// unit attachment.
for machineId, machineInfo := range info.Attachments.Machines {
filesystemAttachmentInfo := filesystemAttachmentInfo
filesystemAttachmentInfo.MachineId = machineId
filesystemAttachmentInfo.FilesystemAttachment = machineInfo
for unitId, unitInfo := range info.Attachments.Units {
if unitInfo.MachineId == machineId {
filesystemAttachmentInfo.UnitId = unitId
filesystemAttachmentInfo.UnitStorageAttachment = unitInfo
break
}
}
haveMachines = true
filesystemAttachmentInfos = append(filesystemAttachmentInfos, filesystemAttachmentInfo)
}
for hostId, containerInfo := range info.Attachments.Containers {
filesystemAttachmentInfo := filesystemAttachmentInfo
filesystemAttachmentInfo.FilesystemAttachment = containerInfo
for unitId, unitInfo := range info.Attachments.Units {
if hostId == unitId {
filesystemAttachmentInfo.UnitId = unitId
filesystemAttachmentInfo.UnitStorageAttachment = unitInfo
break
}
}
filesystemAttachmentInfos = append(filesystemAttachmentInfos, filesystemAttachmentInfo)
}
}
sort.Sort(filesystemAttachmentInfos)
if haveMachines {
print("Machine", "Unit", "Storage id", "Id", "Volume", "Provider id", "Mountpoint", "Size", "State", "Message")
} else {
print("Unit", "Storage id", "Id", "Provider id", "Mountpoint", "Size", "State", "Message")
}
for _, info := range filesystemAttachmentInfos {
var size string
if info.Size > 0 {
size = humanize.IBytes(info.Size * humanize.MiByte)
}
if haveMachines {
print(
info.MachineId, info.UnitId, info.Storage,
info.FilesystemId, info.Volume, info.ProviderFilesystemId,
info.MountPoint, size,
string(info.Status.Current), info.Status.Message,
)
} else {
print(
info.UnitId, info.Storage,
info.FilesystemId, info.ProviderFilesystemId,
info.MountPoint, size,
string(info.Status.Current), info.Status.Message,
)
}
}
return tw.Flush()
} | [
"func",
"formatFilesystemListTabular",
"(",
"writer",
"io",
".",
"Writer",
",",
"infos",
"map",
"[",
"string",
"]",
"FilesystemInfo",
")",
"error",
"{",
"tw",
":=",
"output",
".",
"TabWriter",
"(",
"writer",
")",
"\n\n",
"print",
":=",
"func",
"(",
"values... | // formatFilesystemListTabular writes a tabular summary of filesystem instances. | [
"formatFilesystemListTabular",
"writes",
"a",
"tabular",
"summary",
"of",
"filesystem",
"instances",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/storage/filesystemlistformatters.go#L18-L100 |
4,505 | juju/juju | upgrades/upgrade.go | PerformUpgrade | func PerformUpgrade(from version.Number, targets []Target, context Context) error {
if hasStateTarget(targets) {
ops := newStateUpgradeOpsIterator(from)
if err := runUpgradeSteps(ops, targets, context.StateContext()); err != nil {
return err
}
}
ops := newUpgradeOpsIterator(from)
if err := runUpgradeSteps(ops, targets, context.APIContext()); err != nil {
return err
}
logger.Infof("All upgrade steps completed successfully")
return nil
} | go | func PerformUpgrade(from version.Number, targets []Target, context Context) error {
if hasStateTarget(targets) {
ops := newStateUpgradeOpsIterator(from)
if err := runUpgradeSteps(ops, targets, context.StateContext()); err != nil {
return err
}
}
ops := newUpgradeOpsIterator(from)
if err := runUpgradeSteps(ops, targets, context.APIContext()); err != nil {
return err
}
logger.Infof("All upgrade steps completed successfully")
return nil
} | [
"func",
"PerformUpgrade",
"(",
"from",
"version",
".",
"Number",
",",
"targets",
"[",
"]",
"Target",
",",
"context",
"Context",
")",
"error",
"{",
"if",
"hasStateTarget",
"(",
"targets",
")",
"{",
"ops",
":=",
"newStateUpgradeOpsIterator",
"(",
"from",
")",
... | // PerformUpgrade runs the business logic needed to upgrade the current "from" version to this
// version of Juju on the "target" type of machine. | [
"PerformUpgrade",
"runs",
"the",
"business",
"logic",
"needed",
"to",
"upgrade",
"the",
"current",
"from",
"version",
"to",
"this",
"version",
"of",
"Juju",
"on",
"the",
"target",
"type",
"of",
"machine",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/upgrades/upgrade.go#L94-L107 |
4,506 | juju/juju | upgrades/upgrade.go | runUpgradeSteps | func runUpgradeSteps(ops *opsIterator, targets []Target, context Context) error {
for ops.Next() {
for _, step := range ops.Get().Steps() {
if targetsMatch(targets, step.Targets()) {
logger.Infof("running upgrade step: %v", step.Description())
if err := step.Run(context); err != nil {
logger.Errorf("upgrade step %q failed: %v", step.Description(), err)
return &upgradeError{
description: step.Description(),
err: err,
}
}
}
}
}
return nil
} | go | func runUpgradeSteps(ops *opsIterator, targets []Target, context Context) error {
for ops.Next() {
for _, step := range ops.Get().Steps() {
if targetsMatch(targets, step.Targets()) {
logger.Infof("running upgrade step: %v", step.Description())
if err := step.Run(context); err != nil {
logger.Errorf("upgrade step %q failed: %v", step.Description(), err)
return &upgradeError{
description: step.Description(),
err: err,
}
}
}
}
}
return nil
} | [
"func",
"runUpgradeSteps",
"(",
"ops",
"*",
"opsIterator",
",",
"targets",
"[",
"]",
"Target",
",",
"context",
"Context",
")",
"error",
"{",
"for",
"ops",
".",
"Next",
"(",
")",
"{",
"for",
"_",
",",
"step",
":=",
"range",
"ops",
".",
"Get",
"(",
"... | // runUpgradeSteps finds all the upgrade operations relevant to
// the targets given and runs the associated upgrade steps.
//
// As soon as any error is encountered, the operation is aborted since
// subsequent steps may required successful completion of earlier
// ones. The steps must be idempotent so that the entire upgrade
// operation can be retried. | [
"runUpgradeSteps",
"finds",
"all",
"the",
"upgrade",
"operations",
"relevant",
"to",
"the",
"targets",
"given",
"and",
"runs",
"the",
"associated",
"upgrade",
"steps",
".",
"As",
"soon",
"as",
"any",
"error",
"is",
"encountered",
"the",
"operation",
"is",
"abo... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/upgrades/upgrade.go#L134-L150 |
4,507 | juju/juju | upgrades/upgrade.go | targetsMatch | func targetsMatch(machineTargets []Target, stepTargets []Target) bool {
for _, machineTarget := range machineTargets {
for _, stepTarget := range stepTargets {
if machineTarget == stepTarget || stepTarget == AllMachines {
return true
}
}
}
return false
} | go | func targetsMatch(machineTargets []Target, stepTargets []Target) bool {
for _, machineTarget := range machineTargets {
for _, stepTarget := range stepTargets {
if machineTarget == stepTarget || stepTarget == AllMachines {
return true
}
}
}
return false
} | [
"func",
"targetsMatch",
"(",
"machineTargets",
"[",
"]",
"Target",
",",
"stepTargets",
"[",
"]",
"Target",
")",
"bool",
"{",
"for",
"_",
",",
"machineTarget",
":=",
"range",
"machineTargets",
"{",
"for",
"_",
",",
"stepTarget",
":=",
"range",
"stepTargets",
... | // targetsMatch returns true if any machineTargets match any of
// stepTargets. | [
"targetsMatch",
"returns",
"true",
"if",
"any",
"machineTargets",
"match",
"any",
"of",
"stepTargets",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/upgrades/upgrade.go#L154-L163 |
4,508 | juju/juju | apiserver/apiserver.go | NewServer | func NewServer(cfg ServerConfig) (*Server, error) {
if cfg.LogSinkConfig == nil {
logSinkConfig := DefaultLogSinkConfig()
cfg.LogSinkConfig = &logSinkConfig
}
if err := cfg.Validate(); err != nil {
return nil, errors.Trace(err)
}
// Important note:
// Do not manipulate the state within NewServer as the API
// server needs to run before mongo upgrades have happened and
// any state manipulation may be be relying on features of the
// database added by upgrades. Here be dragons.
return newServer(cfg)
} | go | func NewServer(cfg ServerConfig) (*Server, error) {
if cfg.LogSinkConfig == nil {
logSinkConfig := DefaultLogSinkConfig()
cfg.LogSinkConfig = &logSinkConfig
}
if err := cfg.Validate(); err != nil {
return nil, errors.Trace(err)
}
// Important note:
// Do not manipulate the state within NewServer as the API
// server needs to run before mongo upgrades have happened and
// any state manipulation may be be relying on features of the
// database added by upgrades. Here be dragons.
return newServer(cfg)
} | [
"func",
"NewServer",
"(",
"cfg",
"ServerConfig",
")",
"(",
"*",
"Server",
",",
"error",
")",
"{",
"if",
"cfg",
".",
"LogSinkConfig",
"==",
"nil",
"{",
"logSinkConfig",
":=",
"DefaultLogSinkConfig",
"(",
")",
"\n",
"cfg",
".",
"LogSinkConfig",
"=",
"&",
"... | // NewServer serves API requests using the given configuration. | [
"NewServer",
"serves",
"API",
"requests",
"using",
"the",
"given",
"configuration",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/apiserver.go#L236-L250 |
4,509 | juju/juju | apiserver/apiserver.go | Stop | func (srv *Server) Stop() error {
srv.tomb.Kill(nil)
return srv.tomb.Wait()
} | go | func (srv *Server) Stop() error {
srv.tomb.Kill(nil)
return srv.tomb.Wait()
} | [
"func",
"(",
"srv",
"*",
"Server",
")",
"Stop",
"(",
")",
"error",
"{",
"srv",
".",
"tomb",
".",
"Kill",
"(",
"nil",
")",
"\n",
"return",
"srv",
".",
"tomb",
".",
"Wait",
"(",
")",
"\n",
"}"
] | // Stop stops the server and returns when all running requests
// have completed. | [
"Stop",
"stops",
"the",
"server",
"and",
"returns",
"when",
"all",
"running",
"requests",
"have",
"completed",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/apiserver.go#L355-L358 |
4,510 | juju/juju | apiserver/apiserver.go | loop | func (srv *Server) loop(ready chan struct{}) error {
// for pat based handlers, they are matched in-order of being
// registered, first match wins. So more specific ones have to be
// registered first.
for _, ep := range srv.endpoints() {
srv.mux.AddHandler(ep.Method, ep.Pattern, ep.Handler)
defer srv.mux.RemoveHandler(ep.Method, ep.Pattern)
if ep.Method == "GET" {
srv.mux.AddHandler("HEAD", ep.Pattern, ep.Handler)
defer srv.mux.RemoveHandler("HEAD", ep.Pattern)
}
}
close(ready)
<-srv.tomb.Dying()
srv.wg.Wait() // wait for any outstanding requests to complete.
return tomb.ErrDying
} | go | func (srv *Server) loop(ready chan struct{}) error {
// for pat based handlers, they are matched in-order of being
// registered, first match wins. So more specific ones have to be
// registered first.
for _, ep := range srv.endpoints() {
srv.mux.AddHandler(ep.Method, ep.Pattern, ep.Handler)
defer srv.mux.RemoveHandler(ep.Method, ep.Pattern)
if ep.Method == "GET" {
srv.mux.AddHandler("HEAD", ep.Pattern, ep.Handler)
defer srv.mux.RemoveHandler("HEAD", ep.Pattern)
}
}
close(ready)
<-srv.tomb.Dying()
srv.wg.Wait() // wait for any outstanding requests to complete.
return tomb.ErrDying
} | [
"func",
"(",
"srv",
"*",
"Server",
")",
"loop",
"(",
"ready",
"chan",
"struct",
"{",
"}",
")",
"error",
"{",
"// for pat based handlers, they are matched in-order of being",
"// registered, first match wins. So more specific ones have to be",
"// registered first.",
"for",
"_... | // loop is the main loop for the server. | [
"loop",
"is",
"the",
"main",
"loop",
"for",
"the",
"server",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/apiserver.go#L412-L428 |
4,511 | juju/juju | apiserver/apiserver.go | publicDNSName | func (srv *Server) publicDNSName() string {
srv.mu.Lock()
defer srv.mu.Unlock()
return srv.publicDNSName_
} | go | func (srv *Server) publicDNSName() string {
srv.mu.Lock()
defer srv.mu.Unlock()
return srv.publicDNSName_
} | [
"func",
"(",
"srv",
"*",
"Server",
")",
"publicDNSName",
"(",
")",
"string",
"{",
"srv",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"srv",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"srv",
".",
"publicDNSName_",
"\n",
"}"
] | // publicDNSName returns the current public hostname. | [
"publicDNSName",
"returns",
"the",
"current",
"public",
"hostname",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/apiserver.go#L889-L893 |
4,512 | juju/juju | provider/cloudsigma/environinstance.go | StartInstance | func (env *environ) StartInstance(ctx context.ProviderCallContext, args environs.StartInstanceParams) (*environs.StartInstanceResult, error) {
logger.Infof("sigmaEnviron.StartInstance...")
if args.InstanceConfig == nil {
return nil, errors.New("instance configuration is nil")
}
if len(args.Tools) == 0 {
return nil, errors.New("agent binaries not found")
}
img, err := findInstanceImage(args.ImageMetadata)
if err != nil {
return nil, err
}
tools, err := args.Tools.Match(tools.Filter{Arch: img.Arch})
if err != nil {
return nil, errors.Errorf("chosen architecture %v not present in %v", img.Arch, args.Tools.Arches())
}
if err := args.InstanceConfig.SetTools(tools); err != nil {
return nil, errors.Trace(err)
}
if err := instancecfg.FinishInstanceConfig(args.InstanceConfig, env.Config()); err != nil {
return nil, err
}
userData, err := providerinit.ComposeUserData(args.InstanceConfig, nil, CloudSigmaRenderer{})
if err != nil {
return nil, errors.Annotate(err, "cannot make user data")
}
logger.Debugf("cloudsigma user data; %d bytes", len(userData))
client := env.client
cfg := env.Config()
server, rootdrive, arch, err := client.newInstance(args, img, userData, cfg.AuthorizedKeys())
if err != nil {
return nil, errors.Errorf("failed start instance: %v", err)
}
inst := &sigmaInstance{server: server}
// prepare hardware characteristics
hwch, err := inst.hardware(arch, rootdrive.Size())
if err != nil {
return nil, err
}
logger.Debugf("hardware: %v", hwch)
return &environs.StartInstanceResult{
Instance: inst,
Hardware: hwch,
}, nil
} | go | func (env *environ) StartInstance(ctx context.ProviderCallContext, args environs.StartInstanceParams) (*environs.StartInstanceResult, error) {
logger.Infof("sigmaEnviron.StartInstance...")
if args.InstanceConfig == nil {
return nil, errors.New("instance configuration is nil")
}
if len(args.Tools) == 0 {
return nil, errors.New("agent binaries not found")
}
img, err := findInstanceImage(args.ImageMetadata)
if err != nil {
return nil, err
}
tools, err := args.Tools.Match(tools.Filter{Arch: img.Arch})
if err != nil {
return nil, errors.Errorf("chosen architecture %v not present in %v", img.Arch, args.Tools.Arches())
}
if err := args.InstanceConfig.SetTools(tools); err != nil {
return nil, errors.Trace(err)
}
if err := instancecfg.FinishInstanceConfig(args.InstanceConfig, env.Config()); err != nil {
return nil, err
}
userData, err := providerinit.ComposeUserData(args.InstanceConfig, nil, CloudSigmaRenderer{})
if err != nil {
return nil, errors.Annotate(err, "cannot make user data")
}
logger.Debugf("cloudsigma user data; %d bytes", len(userData))
client := env.client
cfg := env.Config()
server, rootdrive, arch, err := client.newInstance(args, img, userData, cfg.AuthorizedKeys())
if err != nil {
return nil, errors.Errorf("failed start instance: %v", err)
}
inst := &sigmaInstance{server: server}
// prepare hardware characteristics
hwch, err := inst.hardware(arch, rootdrive.Size())
if err != nil {
return nil, err
}
logger.Debugf("hardware: %v", hwch)
return &environs.StartInstanceResult{
Instance: inst,
Hardware: hwch,
}, nil
} | [
"func",
"(",
"env",
"*",
"environ",
")",
"StartInstance",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"args",
"environs",
".",
"StartInstanceParams",
")",
"(",
"*",
"environs",
".",
"StartInstanceResult",
",",
"error",
")",
"{",
"logger",
".",
"I... | // StartInstance asks for a new instance to be created, associated with
// the provided config in machineConfig. The given config describes the juju
// state for the new instance to connect to. The config MachineNonce, which must be
// unique within an environment, is used by juju to protect against the
// consequences of multiple instances being started with the same machine id. | [
"StartInstance",
"asks",
"for",
"a",
"new",
"instance",
"to",
"be",
"created",
"associated",
"with",
"the",
"provided",
"config",
"in",
"machineConfig",
".",
"The",
"given",
"config",
"describes",
"the",
"juju",
"state",
"for",
"the",
"new",
"instance",
"to",
... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/cloudsigma/environinstance.go#L43-L97 |
4,513 | juju/juju | provider/cloudsigma/environinstance.go | AllInstances | func (env *environ) AllInstances(ctx context.ProviderCallContext) ([]instances.Instance, error) {
// Please note that this must *not* return instances that have not been
// allocated as part of this environment -- if it does, juju will see they
// are not tracked in state, assume they're stale/rogue, and shut them down.
logger.Tracef("environ.AllInstances...")
servers, err := env.client.instances()
if err != nil {
logger.Tracef("environ.AllInstances failed: %v", err)
return nil, err
}
instances := make([]instances.Instance, 0, len(servers))
for _, server := range servers {
instance := sigmaInstance{server: server}
instances = append(instances, instance)
}
if logger.LogLevel() <= loggo.TRACE {
logger.Tracef("All instances, len = %d:", len(instances))
for _, instance := range instances {
logger.Tracef("... id: %q, status: %q", instance.Id(), instance.Status(ctx))
}
}
return instances, nil
} | go | func (env *environ) AllInstances(ctx context.ProviderCallContext) ([]instances.Instance, error) {
// Please note that this must *not* return instances that have not been
// allocated as part of this environment -- if it does, juju will see they
// are not tracked in state, assume they're stale/rogue, and shut them down.
logger.Tracef("environ.AllInstances...")
servers, err := env.client.instances()
if err != nil {
logger.Tracef("environ.AllInstances failed: %v", err)
return nil, err
}
instances := make([]instances.Instance, 0, len(servers))
for _, server := range servers {
instance := sigmaInstance{server: server}
instances = append(instances, instance)
}
if logger.LogLevel() <= loggo.TRACE {
logger.Tracef("All instances, len = %d:", len(instances))
for _, instance := range instances {
logger.Tracef("... id: %q, status: %q", instance.Id(), instance.Status(ctx))
}
}
return instances, nil
} | [
"func",
"(",
"env",
"*",
"environ",
")",
"AllInstances",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
")",
"(",
"[",
"]",
"instances",
".",
"Instance",
",",
"error",
")",
"{",
"// Please note that this must *not* return instances that have not been",
"// allocat... | // AllInstances returns all instances currently known to the broker. | [
"AllInstances",
"returns",
"all",
"instances",
"currently",
"known",
"to",
"the",
"broker",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/cloudsigma/environinstance.go#L100-L127 |
4,514 | juju/juju | provider/cloudsigma/environinstance.go | Instances | func (env *environ) Instances(ctx context.ProviderCallContext, ids []instance.Id) ([]instances.Instance, error) {
logger.Tracef("environ.Instances %#v", ids)
// Please note that this must *not* return instances that have not been
// allocated as part of this environment -- if it does, juju will see they
// are not tracked in state, assume they're stale/rogue, and shut them down.
// This advice applies even if an instance id passed in corresponds to a
// real instance that's not part of the environment -- the Environ should
// treat that no differently to a request for one that does not exist.
m, err := env.client.instanceMap()
if err != nil {
return nil, errors.Annotate(err, "environ.Instances failed")
}
var found int
r := make([]instances.Instance, len(ids))
for i, id := range ids {
if s, ok := m[string(id)]; ok {
r[i] = sigmaInstance{server: s}
found++
}
}
if found == 0 {
err = environs.ErrNoInstances
} else if found != len(ids) {
err = environs.ErrPartialInstances
}
return r, errors.Trace(err)
} | go | func (env *environ) Instances(ctx context.ProviderCallContext, ids []instance.Id) ([]instances.Instance, error) {
logger.Tracef("environ.Instances %#v", ids)
// Please note that this must *not* return instances that have not been
// allocated as part of this environment -- if it does, juju will see they
// are not tracked in state, assume they're stale/rogue, and shut them down.
// This advice applies even if an instance id passed in corresponds to a
// real instance that's not part of the environment -- the Environ should
// treat that no differently to a request for one that does not exist.
m, err := env.client.instanceMap()
if err != nil {
return nil, errors.Annotate(err, "environ.Instances failed")
}
var found int
r := make([]instances.Instance, len(ids))
for i, id := range ids {
if s, ok := m[string(id)]; ok {
r[i] = sigmaInstance{server: s}
found++
}
}
if found == 0 {
err = environs.ErrNoInstances
} else if found != len(ids) {
err = environs.ErrPartialInstances
}
return r, errors.Trace(err)
} | [
"func",
"(",
"env",
"*",
"environ",
")",
"Instances",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"ids",
"[",
"]",
"instance",
".",
"Id",
")",
"(",
"[",
"]",
"instances",
".",
"Instance",
",",
"error",
")",
"{",
"logger",
".",
"Tracef",
"... | // Instances returns a slice of instances corresponding to the
// given instance ids. If no instances were found, but there
// was no other error, it will return ErrNoInstances. If
// some but not all the instances were found, the returned slice
// will have some nil slots, and an ErrPartialInstances error
// will be returned. | [
"Instances",
"returns",
"a",
"slice",
"of",
"instances",
"corresponding",
"to",
"the",
"given",
"instance",
"ids",
".",
"If",
"no",
"instances",
"were",
"found",
"but",
"there",
"was",
"no",
"other",
"error",
"it",
"will",
"return",
"ErrNoInstances",
".",
"I... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/cloudsigma/environinstance.go#L135-L165 |
4,515 | juju/juju | environs/utils.go | getAddresses | func getAddresses(ctx context.ProviderCallContext, instances []instances.Instance) []network.Address {
var allAddrs []network.Address
for _, inst := range instances {
if inst == nil {
continue
}
addrs, err := inst.Addresses(ctx)
if err != nil {
logger.Debugf(
"failed to get addresses for %v: %v (ignoring)",
inst.Id(), err,
)
continue
}
allAddrs = append(allAddrs, addrs...)
}
return allAddrs
} | go | func getAddresses(ctx context.ProviderCallContext, instances []instances.Instance) []network.Address {
var allAddrs []network.Address
for _, inst := range instances {
if inst == nil {
continue
}
addrs, err := inst.Addresses(ctx)
if err != nil {
logger.Debugf(
"failed to get addresses for %v: %v (ignoring)",
inst.Id(), err,
)
continue
}
allAddrs = append(allAddrs, addrs...)
}
return allAddrs
} | [
"func",
"getAddresses",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"instances",
"[",
"]",
"instances",
".",
"Instance",
")",
"[",
"]",
"network",
".",
"Address",
"{",
"var",
"allAddrs",
"[",
"]",
"network",
".",
"Address",
"\n",
"for",
"_",
... | // getAddresses queries and returns the Addresses for the given instances,
// ignoring nil instances or ones without addresses. | [
"getAddresses",
"queries",
"and",
"returns",
"the",
"Addresses",
"for",
"the",
"given",
"instances",
"ignoring",
"nil",
"instances",
"or",
"ones",
"without",
"addresses",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/utils.go#L29-L46 |
4,516 | juju/juju | environs/utils.go | waitAnyInstanceAddresses | func waitAnyInstanceAddresses(
env Environ,
ctx context.ProviderCallContext,
instanceIds []instance.Id,
) ([]network.Address, error) {
var addrs []network.Address
for a := AddressesRefreshAttempt.Start(); len(addrs) == 0 && a.Next(); {
instances, err := env.Instances(ctx, instanceIds)
if err != nil && err != ErrPartialInstances {
logger.Debugf("error getting state instances: %v", err)
return nil, err
}
addrs = getAddresses(ctx, instances)
}
if len(addrs) == 0 {
return nil, errors.NotFoundf("addresses for %v", instanceIds)
}
return addrs, nil
} | go | func waitAnyInstanceAddresses(
env Environ,
ctx context.ProviderCallContext,
instanceIds []instance.Id,
) ([]network.Address, error) {
var addrs []network.Address
for a := AddressesRefreshAttempt.Start(); len(addrs) == 0 && a.Next(); {
instances, err := env.Instances(ctx, instanceIds)
if err != nil && err != ErrPartialInstances {
logger.Debugf("error getting state instances: %v", err)
return nil, err
}
addrs = getAddresses(ctx, instances)
}
if len(addrs) == 0 {
return nil, errors.NotFoundf("addresses for %v", instanceIds)
}
return addrs, nil
} | [
"func",
"waitAnyInstanceAddresses",
"(",
"env",
"Environ",
",",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"instanceIds",
"[",
"]",
"instance",
".",
"Id",
",",
")",
"(",
"[",
"]",
"network",
".",
"Address",
",",
"error",
")",
"{",
"var",
"addrs",
... | // waitAnyInstanceAddresses waits for at least one of the instances
// to have addresses, and returns them. | [
"waitAnyInstanceAddresses",
"waits",
"for",
"at",
"least",
"one",
"of",
"the",
"instances",
"to",
"have",
"addresses",
"and",
"returns",
"them",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/utils.go#L50-L68 |
4,517 | juju/juju | environs/utils.go | APIInfo | func APIInfo(ctx context.ProviderCallContext, controllerUUID, modelUUID, caCert string, apiPort int, env Environ) (*api.Info, error) {
instanceIds, err := env.ControllerInstances(ctx, controllerUUID)
if err != nil {
return nil, err
}
logger.Debugf("ControllerInstances returned: %v", instanceIds)
addrs, err := waitAnyInstanceAddresses(env, ctx, instanceIds)
if err != nil {
return nil, err
}
apiAddrs := network.HostPortsToStrings(
network.AddressesWithPort(addrs, apiPort),
)
modelTag := names.NewModelTag(modelUUID)
apiInfo := &api.Info{Addrs: apiAddrs, CACert: caCert, ModelTag: modelTag}
return apiInfo, nil
} | go | func APIInfo(ctx context.ProviderCallContext, controllerUUID, modelUUID, caCert string, apiPort int, env Environ) (*api.Info, error) {
instanceIds, err := env.ControllerInstances(ctx, controllerUUID)
if err != nil {
return nil, err
}
logger.Debugf("ControllerInstances returned: %v", instanceIds)
addrs, err := waitAnyInstanceAddresses(env, ctx, instanceIds)
if err != nil {
return nil, err
}
apiAddrs := network.HostPortsToStrings(
network.AddressesWithPort(addrs, apiPort),
)
modelTag := names.NewModelTag(modelUUID)
apiInfo := &api.Info{Addrs: apiAddrs, CACert: caCert, ModelTag: modelTag}
return apiInfo, nil
} | [
"func",
"APIInfo",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"controllerUUID",
",",
"modelUUID",
",",
"caCert",
"string",
",",
"apiPort",
"int",
",",
"env",
"Environ",
")",
"(",
"*",
"api",
".",
"Info",
",",
"error",
")",
"{",
"instanceIds",
... | // APIInfo returns an api.Info for the environment. The result is populated
// with addresses and CA certificate, but no tag or password. | [
"APIInfo",
"returns",
"an",
"api",
".",
"Info",
"for",
"the",
"environment",
".",
"The",
"result",
"is",
"populated",
"with",
"addresses",
"and",
"CA",
"certificate",
"but",
"no",
"tag",
"or",
"password",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/utils.go#L72-L88 |
4,518 | juju/juju | environs/utils.go | CheckProviderAPI | func CheckProviderAPI(env InstanceBroker, ctx context.ProviderCallContext) error {
// We will make a simple API call to the provider
// to ensure the underlying substrate is ok.
_, err := env.AllInstances(ctx)
switch err {
case nil, ErrPartialInstances, ErrNoInstances:
return nil
}
return errors.Annotate(err, "cannot make API call to provider")
} | go | func CheckProviderAPI(env InstanceBroker, ctx context.ProviderCallContext) error {
// We will make a simple API call to the provider
// to ensure the underlying substrate is ok.
_, err := env.AllInstances(ctx)
switch err {
case nil, ErrPartialInstances, ErrNoInstances:
return nil
}
return errors.Annotate(err, "cannot make API call to provider")
} | [
"func",
"CheckProviderAPI",
"(",
"env",
"InstanceBroker",
",",
"ctx",
"context",
".",
"ProviderCallContext",
")",
"error",
"{",
"// We will make a simple API call to the provider",
"// to ensure the underlying substrate is ok.",
"_",
",",
"err",
":=",
"env",
".",
"AllInstan... | // CheckProviderAPI returns an error if a simple API call
// to check a basic response from the specified environ fails. | [
"CheckProviderAPI",
"returns",
"an",
"error",
"if",
"a",
"simple",
"API",
"call",
"to",
"check",
"a",
"basic",
"response",
"from",
"the",
"specified",
"environ",
"fails",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/utils.go#L92-L101 |
4,519 | juju/juju | apiserver/facades/agent/caasoperator/operator.go | NewFacade | func NewFacade(
resources facade.Resources,
authorizer facade.Authorizer,
st CAASOperatorState,
) (*Facade, error) {
if !authorizer.AuthApplicationAgent() {
return nil, common.ErrPerm
}
model, err := st.Model()
if err != nil {
return nil, errors.Trace(err)
}
canRead := common.AuthAny(
common.AuthFuncForTagKind(names.ApplicationTagKind),
common.AuthFuncForTagKind(names.UnitTagKind),
)
accessUnit := func() (common.AuthFunc, error) {
switch tag := authorizer.GetAuthTag().(type) {
case names.ApplicationTag:
// Any of the units belonging to
// the 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
default:
return nil, errors.Errorf("expected names.ApplicationTag, got %T", tag)
}
}
return &Facade{
LifeGetter: common.NewLifeGetter(st, canRead),
APIAddresser: common.NewAPIAddresser(st, resources),
AgentEntityWatcher: common.NewAgentEntityWatcher(st, resources, canRead),
Remover: common.NewRemover(st, true, accessUnit),
ToolsSetter: common.NewToolsSetter(st, common.AuthFuncForTag(authorizer.GetAuthTag())),
auth: authorizer,
resources: resources,
state: st,
model: model,
}, nil
} | go | func NewFacade(
resources facade.Resources,
authorizer facade.Authorizer,
st CAASOperatorState,
) (*Facade, error) {
if !authorizer.AuthApplicationAgent() {
return nil, common.ErrPerm
}
model, err := st.Model()
if err != nil {
return nil, errors.Trace(err)
}
canRead := common.AuthAny(
common.AuthFuncForTagKind(names.ApplicationTagKind),
common.AuthFuncForTagKind(names.UnitTagKind),
)
accessUnit := func() (common.AuthFunc, error) {
switch tag := authorizer.GetAuthTag().(type) {
case names.ApplicationTag:
// Any of the units belonging to
// the 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
default:
return nil, errors.Errorf("expected names.ApplicationTag, got %T", tag)
}
}
return &Facade{
LifeGetter: common.NewLifeGetter(st, canRead),
APIAddresser: common.NewAPIAddresser(st, resources),
AgentEntityWatcher: common.NewAgentEntityWatcher(st, resources, canRead),
Remover: common.NewRemover(st, true, accessUnit),
ToolsSetter: common.NewToolsSetter(st, common.AuthFuncForTag(authorizer.GetAuthTag())),
auth: authorizer,
resources: resources,
state: st,
model: model,
}, nil
} | [
"func",
"NewFacade",
"(",
"resources",
"facade",
".",
"Resources",
",",
"authorizer",
"facade",
".",
"Authorizer",
",",
"st",
"CAASOperatorState",
",",
")",
"(",
"*",
"Facade",
",",
"error",
")",
"{",
"if",
"!",
"authorizer",
".",
"AuthApplicationAgent",
"("... | // NewFacade returns a new CAASOperator facade. | [
"NewFacade",
"returns",
"a",
"new",
"CAASOperator",
"facade",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/caasoperator/operator.go#L40-L92 |
4,520 | juju/juju | apiserver/facades/agent/caasoperator/operator.go | Charm | func (f *Facade) Charm(args params.Entities) (params.ApplicationCharmResults, error) {
results := params.ApplicationCharmResults{
Results: make([]params.ApplicationCharmResult, len(args.Entities)),
}
authTag := f.auth.GetAuthTag()
for i, entity := range args.Entities {
tag, err := names.ParseApplicationTag(entity.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
if tag != authTag {
results.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
application, err := f.state.Application(tag.Id())
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
charm, force, err := application.Charm()
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].Result = ¶ms.ApplicationCharm{
URL: charm.URL().String(),
ForceUpgrade: force,
SHA256: charm.BundleSha256(),
CharmModifiedVersion: application.CharmModifiedVersion(),
}
}
return results, nil
} | go | func (f *Facade) Charm(args params.Entities) (params.ApplicationCharmResults, error) {
results := params.ApplicationCharmResults{
Results: make([]params.ApplicationCharmResult, len(args.Entities)),
}
authTag := f.auth.GetAuthTag()
for i, entity := range args.Entities {
tag, err := names.ParseApplicationTag(entity.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
if tag != authTag {
results.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
application, err := f.state.Application(tag.Id())
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
charm, force, err := application.Charm()
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].Result = ¶ms.ApplicationCharm{
URL: charm.URL().String(),
ForceUpgrade: force,
SHA256: charm.BundleSha256(),
CharmModifiedVersion: application.CharmModifiedVersion(),
}
}
return results, nil
} | [
"func",
"(",
"f",
"*",
"Facade",
")",
"Charm",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ApplicationCharmResults",
",",
"error",
")",
"{",
"results",
":=",
"params",
".",
"ApplicationCharmResults",
"{",
"Results",
":",
"make",
"(",
... | // Charm returns the charm info for all given applications. | [
"Charm",
"returns",
"the",
"charm",
"info",
"for",
"all",
"given",
"applications",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/caasoperator/operator.go#L138-L171 |
4,521 | juju/juju | apiserver/facades/agent/caasoperator/operator.go | SetPodSpec | func (f *Facade) SetPodSpec(args params.SetPodSpecParams) (params.ErrorResults, error) {
results := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Specs)),
}
cfg, err := f.model.ModelConfig()
if err != nil {
return params.ErrorResults{}, errors.Trace(err)
}
provider, err := environs.Provider(cfg.Type())
if err != nil {
return params.ErrorResults{}, errors.Trace(err)
}
caasProvider, ok := provider.(caas.ContainerEnvironProvider)
if !ok {
return params.ErrorResults{}, errors.NotValidf("container environ provider %T", provider)
}
for i, arg := range args.Specs {
tag, err := names.ParseApplicationTag(arg.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
if !f.auth.AuthOwner(tag) {
results.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
if _, err := caasProvider.ParsePodSpec(arg.Value); err != nil {
results.Results[i].Error = common.ServerError(errors.New("invalid pod spec"))
continue
}
results.Results[i].Error = common.ServerError(
f.model.SetPodSpec(tag, arg.Value),
)
}
return results, nil
} | go | func (f *Facade) SetPodSpec(args params.SetPodSpecParams) (params.ErrorResults, error) {
results := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Specs)),
}
cfg, err := f.model.ModelConfig()
if err != nil {
return params.ErrorResults{}, errors.Trace(err)
}
provider, err := environs.Provider(cfg.Type())
if err != nil {
return params.ErrorResults{}, errors.Trace(err)
}
caasProvider, ok := provider.(caas.ContainerEnvironProvider)
if !ok {
return params.ErrorResults{}, errors.NotValidf("container environ provider %T", provider)
}
for i, arg := range args.Specs {
tag, err := names.ParseApplicationTag(arg.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
if !f.auth.AuthOwner(tag) {
results.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
if _, err := caasProvider.ParsePodSpec(arg.Value); err != nil {
results.Results[i].Error = common.ServerError(errors.New("invalid pod spec"))
continue
}
results.Results[i].Error = common.ServerError(
f.model.SetPodSpec(tag, arg.Value),
)
}
return results, nil
} | [
"func",
"(",
"f",
"*",
"Facade",
")",
"SetPodSpec",
"(",
"args",
"params",
".",
"SetPodSpecParams",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"results",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
"make",
"(",
"[",
... | // SetPodSpec sets the container specs for a set of applications. | [
"SetPodSpec",
"sets",
"the",
"container",
"specs",
"for",
"a",
"set",
"of",
"applications",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/caasoperator/operator.go#L174-L211 |
4,522 | juju/juju | apiserver/facades/agent/caasoperator/operator.go | WatchUnits | func (f *Facade) WatchUnits(args params.Entities) (params.StringsWatchResults, error) {
results := params.StringsWatchResults{
Results: make([]params.StringsWatchResult, len(args.Entities)),
}
for i, arg := range args.Entities {
id, changes, err := f.watchUnits(arg.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].StringsWatcherId = id
results.Results[i].Changes = changes
}
return results, nil
} | go | func (f *Facade) WatchUnits(args params.Entities) (params.StringsWatchResults, error) {
results := params.StringsWatchResults{
Results: make([]params.StringsWatchResult, len(args.Entities)),
}
for i, arg := range args.Entities {
id, changes, err := f.watchUnits(arg.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
results.Results[i].StringsWatcherId = id
results.Results[i].Changes = changes
}
return results, nil
} | [
"func",
"(",
"f",
"*",
"Facade",
")",
"WatchUnits",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"StringsWatchResults",
",",
"error",
")",
"{",
"results",
":=",
"params",
".",
"StringsWatchResults",
"{",
"Results",
":",
"make",
"(",
"... | // WatchUnits starts a StringsWatcher to watch changes to the
// lifecycle states of units for the specified applications in
// this model. | [
"WatchUnits",
"starts",
"a",
"StringsWatcher",
"to",
"watch",
"changes",
"to",
"the",
"lifecycle",
"states",
"of",
"units",
"for",
"the",
"specified",
"applications",
"in",
"this",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/caasoperator/operator.go#L216-L230 |
4,523 | juju/juju | api/agent/facade.go | NewConnFacade | func NewConnFacade(caller base.APICaller) (ConnFacade, error) {
facadeCaller := base.NewFacadeCaller(caller, "Agent")
return &connFacade{
caller: facadeCaller,
}, nil
} | go | func NewConnFacade(caller base.APICaller) (ConnFacade, error) {
facadeCaller := base.NewFacadeCaller(caller, "Agent")
return &connFacade{
caller: facadeCaller,
}, nil
} | [
"func",
"NewConnFacade",
"(",
"caller",
"base",
".",
"APICaller",
")",
"(",
"ConnFacade",
",",
"error",
")",
"{",
"facadeCaller",
":=",
"base",
".",
"NewFacadeCaller",
"(",
"caller",
",",
"\"",
"\"",
")",
"\n",
"return",
"&",
"connFacade",
"{",
"caller",
... | // NewConnFacade returns a ConnFacade backed by the supplied APICaller. | [
"NewConnFacade",
"returns",
"a",
"ConnFacade",
"backed",
"by",
"the",
"supplied",
"APICaller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/agent/facade.go#L50-L55 |
4,524 | juju/juju | api/agent/facade.go | Life | func (facade *connFacade) Life(entity names.Tag) (Life, error) {
var results params.AgentGetEntitiesResults
args := params.Entities{
Entities: []params.Entity{{Tag: entity.String()}},
}
err := facade.caller.FacadeCall("GetEntities", args, &results)
if err != nil {
return "", errors.Trace(err)
}
if len(results.Entities) != 1 {
return "", errors.Errorf("expected 1 result, got %d", len(results.Entities))
}
if err := results.Entities[0].Error; err != nil {
if params.IsCodeNotFoundOrCodeUnauthorized(err) {
return "", ErrDenied
}
return "", errors.Trace(err)
}
life := Life(results.Entities[0].Life)
switch life {
case Alive, Dying, Dead:
return life, nil
}
return "", errors.Errorf("unknown life value %q", life)
} | go | func (facade *connFacade) Life(entity names.Tag) (Life, error) {
var results params.AgentGetEntitiesResults
args := params.Entities{
Entities: []params.Entity{{Tag: entity.String()}},
}
err := facade.caller.FacadeCall("GetEntities", args, &results)
if err != nil {
return "", errors.Trace(err)
}
if len(results.Entities) != 1 {
return "", errors.Errorf("expected 1 result, got %d", len(results.Entities))
}
if err := results.Entities[0].Error; err != nil {
if params.IsCodeNotFoundOrCodeUnauthorized(err) {
return "", ErrDenied
}
return "", errors.Trace(err)
}
life := Life(results.Entities[0].Life)
switch life {
case Alive, Dying, Dead:
return life, nil
}
return "", errors.Errorf("unknown life value %q", life)
} | [
"func",
"(",
"facade",
"*",
"connFacade",
")",
"Life",
"(",
"entity",
"names",
".",
"Tag",
")",
"(",
"Life",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"AgentGetEntitiesResults",
"\n",
"args",
":=",
"params",
".",
"Entities",
"{",
"Entities... | // Life is part of the ConnFacade interface. | [
"Life",
"is",
"part",
"of",
"the",
"ConnFacade",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/agent/facade.go#L63-L87 |
4,525 | juju/juju | api/agent/facade.go | SetPassword | func (facade *connFacade) SetPassword(entity names.Tag, password string) error {
var results params.ErrorResults
args := params.EntityPasswords{
Changes: []params.EntityPassword{{
Tag: entity.String(),
Password: password,
}},
}
err := facade.caller.FacadeCall("SetPasswords", args, &results)
if err != nil {
return errors.Trace(err)
}
if len(results.Results) != 1 {
return errors.Errorf("expected 1 result, got %d", len(results.Results))
}
if err := results.Results[0].Error; err != nil {
if params.IsCodeDead(err) {
return ErrDenied
} else if params.IsCodeNotFoundOrCodeUnauthorized(err) {
return ErrDenied
}
return errors.Trace(err)
}
return nil
} | go | func (facade *connFacade) SetPassword(entity names.Tag, password string) error {
var results params.ErrorResults
args := params.EntityPasswords{
Changes: []params.EntityPassword{{
Tag: entity.String(),
Password: password,
}},
}
err := facade.caller.FacadeCall("SetPasswords", args, &results)
if err != nil {
return errors.Trace(err)
}
if len(results.Results) != 1 {
return errors.Errorf("expected 1 result, got %d", len(results.Results))
}
if err := results.Results[0].Error; err != nil {
if params.IsCodeDead(err) {
return ErrDenied
} else if params.IsCodeNotFoundOrCodeUnauthorized(err) {
return ErrDenied
}
return errors.Trace(err)
}
return nil
} | [
"func",
"(",
"facade",
"*",
"connFacade",
")",
"SetPassword",
"(",
"entity",
"names",
".",
"Tag",
",",
"password",
"string",
")",
"error",
"{",
"var",
"results",
"params",
".",
"ErrorResults",
"\n",
"args",
":=",
"params",
".",
"EntityPasswords",
"{",
"Cha... | // SetPassword is part of the ConnFacade interface. | [
"SetPassword",
"is",
"part",
"of",
"the",
"ConnFacade",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/agent/facade.go#L90-L114 |
4,526 | juju/juju | state/mocks/mongo_mock.go | NewMockCollection | func NewMockCollection(ctrl *gomock.Controller) *MockCollection {
mock := &MockCollection{ctrl: ctrl}
mock.recorder = &MockCollectionMockRecorder{mock}
return mock
} | go | func NewMockCollection(ctrl *gomock.Controller) *MockCollection {
mock := &MockCollection{ctrl: ctrl}
mock.recorder = &MockCollectionMockRecorder{mock}
return mock
} | [
"func",
"NewMockCollection",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockCollection",
"{",
"mock",
":=",
"&",
"MockCollection",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockCollectionMockRecorder",
"{",
"mock... | // NewMockCollection creates a new mock instance | [
"NewMockCollection",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L27-L31 |
4,527 | juju/juju | state/mocks/mongo_mock.go | Count | func (m *MockCollection) Count() (int, error) {
ret := m.ctrl.Call(m, "Count")
ret0, _ := ret[0].(int)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockCollection) Count() (int, error) {
ret := m.ctrl.Call(m, "Count")
ret0, _ := ret[0].(int)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockCollection",
")",
"Count",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
... | // Count mocks base method | [
"Count",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L39-L44 |
4,528 | juju/juju | state/mocks/mongo_mock.go | Pipe | func (m *MockCollection) Pipe(arg0 interface{}) *mgo_v2.Pipe {
ret := m.ctrl.Call(m, "Pipe", arg0)
ret0, _ := ret[0].(*mgo_v2.Pipe)
return ret0
} | go | func (m *MockCollection) Pipe(arg0 interface{}) *mgo_v2.Pipe {
ret := m.ctrl.Call(m, "Pipe", arg0)
ret0, _ := ret[0].(*mgo_v2.Pipe)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCollection",
")",
"Pipe",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"mgo_v2",
".",
"Pipe",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
"... | // Pipe mocks base method | [
"Pipe",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L88-L92 |
4,529 | juju/juju | state/mocks/mongo_mock.go | Pipe | func (mr *MockCollectionMockRecorder) Pipe(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipe", reflect.TypeOf((*MockCollection)(nil).Pipe), arg0)
} | go | func (mr *MockCollectionMockRecorder) Pipe(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipe", reflect.TypeOf((*MockCollection)(nil).Pipe), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockCollectionMockRecorder",
")",
"Pipe",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"... | // Pipe indicates an expected call of Pipe | [
"Pipe",
"indicates",
"an",
"expected",
"call",
"of",
"Pipe"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L95-L97 |
4,530 | juju/juju | state/mocks/mongo_mock.go | Writeable | func (m *MockCollection) Writeable() mongo.WriteCollection {
ret := m.ctrl.Call(m, "Writeable")
ret0, _ := ret[0].(mongo.WriteCollection)
return ret0
} | go | func (m *MockCollection) Writeable() mongo.WriteCollection {
ret := m.ctrl.Call(m, "Writeable")
ret0, _ := ret[0].(mongo.WriteCollection)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCollection",
")",
"Writeable",
"(",
")",
"mongo",
".",
"WriteCollection",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",... | // Writeable mocks base method | [
"Writeable",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L100-L104 |
4,531 | juju/juju | state/mocks/mongo_mock.go | NewMockQuery | func NewMockQuery(ctrl *gomock.Controller) *MockQuery {
mock := &MockQuery{ctrl: ctrl}
mock.recorder = &MockQueryMockRecorder{mock}
return mock
} | go | func NewMockQuery(ctrl *gomock.Controller) *MockQuery {
mock := &MockQuery{ctrl: ctrl}
mock.recorder = &MockQueryMockRecorder{mock}
return mock
} | [
"func",
"NewMockQuery",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockQuery",
"{",
"mock",
":=",
"&",
"MockQuery",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockQueryMockRecorder",
"{",
"mock",
"}",
"\n",
... | // NewMockQuery creates a new mock instance | [
"NewMockQuery",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L123-L127 |
4,532 | juju/juju | state/mocks/mongo_mock.go | Comment | func (m *MockQuery) Comment(arg0 string) mongo.Query {
ret := m.ctrl.Call(m, "Comment", arg0)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | go | func (m *MockQuery) Comment(arg0 string) mongo.Query {
ret := m.ctrl.Call(m, "Comment", arg0)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"Comment",
"(",
"arg0",
"string",
")",
"mongo",
".",
"Query",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0"... | // Comment mocks base method | [
"Comment",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L172-L176 |
4,533 | juju/juju | state/mocks/mongo_mock.go | Distinct | func (m *MockQuery) Distinct(arg0 string, arg1 interface{}) error {
ret := m.ctrl.Call(m, "Distinct", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockQuery) Distinct(arg0 string, arg1 interface{}) error {
ret := m.ctrl.Call(m, "Distinct", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"Distinct",
"(",
"arg0",
"string",
",",
"arg1",
"interface",
"{",
"}",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0... | // Distinct mocks base method | [
"Distinct",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L197-L201 |
4,534 | juju/juju | state/mocks/mongo_mock.go | Iter | func (m *MockQuery) Iter() mongo.Iterator {
ret := m.ctrl.Call(m, "Iter")
ret0, _ := ret[0].(mongo.Iterator)
return ret0
} | go | func (m *MockQuery) Iter() mongo.Iterator {
ret := m.ctrl.Call(m, "Iter")
ret0, _ := ret[0].(mongo.Iterator)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"Iter",
"(",
")",
"mongo",
".",
"Iterator",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"mongo",
"."... | // Iter mocks base method | [
"Iter",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L249-L253 |
4,535 | juju/juju | state/mocks/mongo_mock.go | Iter | func (mr *MockQueryMockRecorder) Iter() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iter", reflect.TypeOf((*MockQuery)(nil).Iter))
} | go | func (mr *MockQueryMockRecorder) Iter() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iter", reflect.TypeOf((*MockQuery)(nil).Iter))
} | [
"func",
"(",
"mr",
"*",
"MockQueryMockRecorder",
")",
"Iter",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
... | // Iter indicates an expected call of Iter | [
"Iter",
"indicates",
"an",
"expected",
"call",
"of",
"Iter"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L256-L258 |
4,536 | juju/juju | state/mocks/mongo_mock.go | Limit | func (m *MockQuery) Limit(arg0 int) mongo.Query {
ret := m.ctrl.Call(m, "Limit", arg0)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | go | func (m *MockQuery) Limit(arg0 int) mongo.Query {
ret := m.ctrl.Call(m, "Limit", arg0)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"Limit",
"(",
"arg0",
"int",
")",
"mongo",
".",
"Query",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"... | // Limit mocks base method | [
"Limit",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L261-L265 |
4,537 | juju/juju | state/mocks/mongo_mock.go | LogReplay | func (m *MockQuery) LogReplay() mongo.Query {
ret := m.ctrl.Call(m, "LogReplay")
ret0, _ := ret[0].(mongo.Query)
return ret0
} | go | func (m *MockQuery) LogReplay() mongo.Query {
ret := m.ctrl.Call(m, "LogReplay")
ret0, _ := ret[0].(mongo.Query)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"LogReplay",
"(",
")",
"mongo",
".",
"Query",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"mongo",
"... | // LogReplay mocks base method | [
"LogReplay",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L273-L277 |
4,538 | juju/juju | state/mocks/mongo_mock.go | MapReduce | func (m *MockQuery) MapReduce(arg0 *mgo_v2.MapReduce, arg1 interface{}) (*mgo_v2.MapReduceInfo, error) {
ret := m.ctrl.Call(m, "MapReduce", arg0, arg1)
ret0, _ := ret[0].(*mgo_v2.MapReduceInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockQuery) MapReduce(arg0 *mgo_v2.MapReduce, arg1 interface{}) (*mgo_v2.MapReduceInfo, error) {
ret := m.ctrl.Call(m, "MapReduce", arg0, arg1)
ret0, _ := ret[0].(*mgo_v2.MapReduceInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"MapReduce",
"(",
"arg0",
"*",
"mgo_v2",
".",
"MapReduce",
",",
"arg1",
"interface",
"{",
"}",
")",
"(",
"*",
"mgo_v2",
".",
"MapReduceInfo",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call... | // MapReduce mocks base method | [
"MapReduce",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L285-L290 |
4,539 | juju/juju | state/mocks/mongo_mock.go | One | func (m *MockQuery) One(arg0 interface{}) error {
ret := m.ctrl.Call(m, "One", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockQuery) One(arg0 interface{}) error {
ret := m.ctrl.Call(m, "One", arg0)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"One",
"(",
"arg0",
"interface",
"{",
"}",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"... | // One mocks base method | [
"One",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L298-L302 |
4,540 | juju/juju | state/mocks/mongo_mock.go | Prefetch | func (m *MockQuery) Prefetch(arg0 float64) mongo.Query {
ret := m.ctrl.Call(m, "Prefetch", arg0)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | go | func (m *MockQuery) Prefetch(arg0 float64) mongo.Query {
ret := m.ctrl.Call(m, "Prefetch", arg0)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"Prefetch",
"(",
"arg0",
"float64",
")",
"mongo",
".",
"Query",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"... | // Prefetch mocks base method | [
"Prefetch",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L310-L314 |
4,541 | juju/juju | state/mocks/mongo_mock.go | Select | func (m *MockQuery) Select(arg0 interface{}) mongo.Query {
ret := m.ctrl.Call(m, "Select", arg0)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | go | func (m *MockQuery) Select(arg0 interface{}) mongo.Query {
ret := m.ctrl.Call(m, "Select", arg0)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"Select",
"(",
"arg0",
"interface",
"{",
"}",
")",
"mongo",
".",
"Query",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"re... | // Select mocks base method | [
"Select",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L322-L326 |
4,542 | juju/juju | state/mocks/mongo_mock.go | SetMaxTime | func (m *MockQuery) SetMaxTime(arg0 time.Duration) mongo.Query {
ret := m.ctrl.Call(m, "SetMaxTime", arg0)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | go | func (m *MockQuery) SetMaxTime(arg0 time.Duration) mongo.Query {
ret := m.ctrl.Call(m, "SetMaxTime", arg0)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"SetMaxTime",
"(",
"arg0",
"time",
".",
"Duration",
")",
"mongo",
".",
"Query",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",... | // SetMaxTime mocks base method | [
"SetMaxTime",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L346-L350 |
4,543 | juju/juju | state/mocks/mongo_mock.go | SetMaxTime | func (mr *MockQueryMockRecorder) SetMaxTime(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxTime", reflect.TypeOf((*MockQuery)(nil).SetMaxTime), arg0)
} | go | func (mr *MockQueryMockRecorder) SetMaxTime(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxTime", reflect.TypeOf((*MockQuery)(nil).SetMaxTime), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockQueryMockRecorder",
")",
"SetMaxTime",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
... | // SetMaxTime indicates an expected call of SetMaxTime | [
"SetMaxTime",
"indicates",
"an",
"expected",
"call",
"of",
"SetMaxTime"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L353-L355 |
4,544 | juju/juju | state/mocks/mongo_mock.go | Sort | func (m *MockQuery) Sort(arg0 ...string) mongo.Query {
varargs := []interface{}{}
for _, a := range arg0 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Sort", varargs...)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | go | func (m *MockQuery) Sort(arg0 ...string) mongo.Query {
varargs := []interface{}{}
for _, a := range arg0 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Sort", varargs...)
ret0, _ := ret[0].(mongo.Query)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"Sort",
"(",
"arg0",
"...",
"string",
")",
"mongo",
".",
"Query",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg0",
"{",
"varargs",
"=",
... | // Sort mocks base method | [
"Sort",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L382-L390 |
4,545 | juju/juju | state/mocks/mongo_mock.go | Tail | func (m *MockQuery) Tail(arg0 time.Duration) *mgo_v2.Iter {
ret := m.ctrl.Call(m, "Tail", arg0)
ret0, _ := ret[0].(*mgo_v2.Iter)
return ret0
} | go | func (m *MockQuery) Tail(arg0 time.Duration) *mgo_v2.Iter {
ret := m.ctrl.Call(m, "Tail", arg0)
ret0, _ := ret[0].(*mgo_v2.Iter)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockQuery",
")",
"Tail",
"(",
"arg0",
"time",
".",
"Duration",
")",
"*",
"mgo_v2",
".",
"Iter",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":="... | // Tail mocks base method | [
"Tail",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/mongo_mock.go#L398-L402 |
4,546 | juju/juju | apiserver/facades/agent/proxyupdater/proxyupdater.go | NewAPIBase | func NewAPIBase(backend Backend, resources facade.Resources, authorizer facade.Authorizer) (*APIBase, error) {
if !(authorizer.AuthMachineAgent() || authorizer.AuthUnitAgent()) {
return nil, common.ErrPerm
}
return &APIBase{
backend: backend,
resources: resources,
authorizer: authorizer,
}, nil
} | go | func NewAPIBase(backend Backend, resources facade.Resources, authorizer facade.Authorizer) (*APIBase, error) {
if !(authorizer.AuthMachineAgent() || authorizer.AuthUnitAgent()) {
return nil, common.ErrPerm
}
return &APIBase{
backend: backend,
resources: resources,
authorizer: authorizer,
}, nil
} | [
"func",
"NewAPIBase",
"(",
"backend",
"Backend",
",",
"resources",
"facade",
".",
"Resources",
",",
"authorizer",
"facade",
".",
"Authorizer",
")",
"(",
"*",
"APIBase",
",",
"error",
")",
"{",
"if",
"!",
"(",
"authorizer",
".",
"AuthMachineAgent",
"(",
")"... | // NewAPIBase creates a new server-side API facade with the given Backing. | [
"NewAPIBase",
"creates",
"a",
"new",
"server",
"-",
"side",
"API",
"facade",
"with",
"the",
"given",
"Backing",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/proxyupdater/proxyupdater.go#L95-L104 |
4,547 | juju/juju | apiserver/facades/agent/proxyupdater/proxyupdater.go | WatchForProxyConfigAndAPIHostPortChanges | func (api *APIBase) WatchForProxyConfigAndAPIHostPortChanges(args params.Entities) params.NotifyWatchResults {
results := params.NotifyWatchResults{
Results: make([]params.NotifyWatchResult, len(args.Entities)),
}
errors, _ := api.authEntities(args)
for i := range args.Entities {
if errors.Results[i].Error == nil {
results.Results[i] = api.oneWatch()
} else {
results.Results[i].Error = errors.Results[i].Error
}
}
return results
} | go | func (api *APIBase) WatchForProxyConfigAndAPIHostPortChanges(args params.Entities) params.NotifyWatchResults {
results := params.NotifyWatchResults{
Results: make([]params.NotifyWatchResult, len(args.Entities)),
}
errors, _ := api.authEntities(args)
for i := range args.Entities {
if errors.Results[i].Error == nil {
results.Results[i] = api.oneWatch()
} else {
results.Results[i].Error = errors.Results[i].Error
}
}
return results
} | [
"func",
"(",
"api",
"*",
"APIBase",
")",
"WatchForProxyConfigAndAPIHostPortChanges",
"(",
"args",
"params",
".",
"Entities",
")",
"params",
".",
"NotifyWatchResults",
"{",
"results",
":=",
"params",
".",
"NotifyWatchResults",
"{",
"Results",
":",
"make",
"(",
"[... | // WatchForProxyConfigAndAPIHostPortChanges watches for cleanups to be perfomed in state | [
"WatchForProxyConfigAndAPIHostPortChanges",
"watches",
"for",
"cleanups",
"to",
"be",
"perfomed",
"in",
"state"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/proxyupdater/proxyupdater.go#L124-L139 |
4,548 | juju/juju | storage/provider/loop.go | CreateVolumes | func (lvs *loopVolumeSource) CreateVolumes(ctx context.ProviderCallContext, args []storage.VolumeParams) ([]storage.CreateVolumesResult, error) {
results := make([]storage.CreateVolumesResult, len(args))
for i, arg := range args {
volume, err := lvs.createVolume(arg)
if err != nil {
results[i].Error = errors.Annotate(err, "creating volume")
}
results[i].Volume = &volume
}
return results, nil
} | go | func (lvs *loopVolumeSource) CreateVolumes(ctx context.ProviderCallContext, args []storage.VolumeParams) ([]storage.CreateVolumesResult, error) {
results := make([]storage.CreateVolumesResult, len(args))
for i, arg := range args {
volume, err := lvs.createVolume(arg)
if err != nil {
results[i].Error = errors.Annotate(err, "creating volume")
}
results[i].Volume = &volume
}
return results, nil
} | [
"func",
"(",
"lvs",
"*",
"loopVolumeSource",
")",
"CreateVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"args",
"[",
"]",
"storage",
".",
"VolumeParams",
")",
"(",
"[",
"]",
"storage",
".",
"CreateVolumesResult",
",",
"error",
")",
"{",
... | // CreateVolumes is defined on the VolumeSource interface. | [
"CreateVolumes",
"is",
"defined",
"on",
"the",
"VolumeSource",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/loop.go#L109-L119 |
4,549 | juju/juju | storage/provider/loop.go | ListVolumes | func (lvs *loopVolumeSource) ListVolumes(ctx context.ProviderCallContext) ([]string, error) {
// TODO(axw) implement this when we need it.
return nil, errors.NotImplementedf("ListVolumes")
} | go | func (lvs *loopVolumeSource) ListVolumes(ctx context.ProviderCallContext) ([]string, error) {
// TODO(axw) implement this when we need it.
return nil, errors.NotImplementedf("ListVolumes")
} | [
"func",
"(",
"lvs",
"*",
"loopVolumeSource",
")",
"ListVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"// TODO(axw) implement this when we need it.",
"return",
"nil",
",",
"errors",
".",
"NotImp... | // ListVolumes is defined on the VolumeSource interface. | [
"ListVolumes",
"is",
"defined",
"on",
"the",
"VolumeSource",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/loop.go#L144-L147 |
4,550 | juju/juju | storage/provider/loop.go | DescribeVolumes | func (lvs *loopVolumeSource) DescribeVolumes(ctx context.ProviderCallContext, volumeIds []string) ([]storage.DescribeVolumesResult, error) {
// TODO(axw) implement this when we need it.
return nil, errors.NotImplementedf("DescribeVolumes")
} | go | func (lvs *loopVolumeSource) DescribeVolumes(ctx context.ProviderCallContext, volumeIds []string) ([]storage.DescribeVolumesResult, error) {
// TODO(axw) implement this when we need it.
return nil, errors.NotImplementedf("DescribeVolumes")
} | [
"func",
"(",
"lvs",
"*",
"loopVolumeSource",
")",
"DescribeVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"volumeIds",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"storage",
".",
"DescribeVolumesResult",
",",
"error",
")",
"{",
"// TODO(axw) imp... | // DescribeVolumes is defined on the VolumeSource interface. | [
"DescribeVolumes",
"is",
"defined",
"on",
"the",
"VolumeSource",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/loop.go#L150-L153 |
4,551 | juju/juju | storage/provider/loop.go | DestroyVolumes | func (lvs *loopVolumeSource) DestroyVolumes(ctx context.ProviderCallContext, volumeIds []string) ([]error, error) {
results := make([]error, len(volumeIds))
for i, volumeId := range volumeIds {
if err := lvs.destroyVolume(volumeId); err != nil {
results[i] = errors.Annotatef(err, "destroying %q", volumeId)
}
}
return results, nil
} | go | func (lvs *loopVolumeSource) DestroyVolumes(ctx context.ProviderCallContext, volumeIds []string) ([]error, error) {
results := make([]error, len(volumeIds))
for i, volumeId := range volumeIds {
if err := lvs.destroyVolume(volumeId); err != nil {
results[i] = errors.Annotatef(err, "destroying %q", volumeId)
}
}
return results, nil
} | [
"func",
"(",
"lvs",
"*",
"loopVolumeSource",
")",
"DestroyVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"volumeIds",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"error",
",",
"error",
")",
"{",
"results",
":=",
"make",
"(",
"[",
"]",
"e... | // DestroyVolumes is defined on the VolumeSource interface. | [
"DestroyVolumes",
"is",
"defined",
"on",
"the",
"VolumeSource",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/loop.go#L156-L164 |
4,552 | juju/juju | storage/provider/loop.go | ReleaseVolumes | func (lvs *loopVolumeSource) ReleaseVolumes(ctx context.ProviderCallContext, volumeIds []string) ([]error, error) {
return make([]error, len(volumeIds)), nil
} | go | func (lvs *loopVolumeSource) ReleaseVolumes(ctx context.ProviderCallContext, volumeIds []string) ([]error, error) {
return make([]error, len(volumeIds)), nil
} | [
"func",
"(",
"lvs",
"*",
"loopVolumeSource",
")",
"ReleaseVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"volumeIds",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"error",
",",
"error",
")",
"{",
"return",
"make",
"(",
"[",
"]",
"error",
... | // ReleaseVolumes is defined on the VolumeSource interface. | [
"ReleaseVolumes",
"is",
"defined",
"on",
"the",
"VolumeSource",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/loop.go#L167-L169 |
4,553 | juju/juju | storage/provider/loop.go | AttachVolumes | func (lvs *loopVolumeSource) AttachVolumes(ctx context.ProviderCallContext, args []storage.VolumeAttachmentParams) ([]storage.AttachVolumesResult, error) {
results := make([]storage.AttachVolumesResult, len(args))
for i, arg := range args {
attachment, err := lvs.attachVolume(arg)
if err != nil {
results[i].Error = errors.Annotatef(err, "attaching volume %v", arg.Volume.Id())
continue
}
results[i].VolumeAttachment = attachment
}
return results, nil
} | go | func (lvs *loopVolumeSource) AttachVolumes(ctx context.ProviderCallContext, args []storage.VolumeAttachmentParams) ([]storage.AttachVolumesResult, error) {
results := make([]storage.AttachVolumesResult, len(args))
for i, arg := range args {
attachment, err := lvs.attachVolume(arg)
if err != nil {
results[i].Error = errors.Annotatef(err, "attaching volume %v", arg.Volume.Id())
continue
}
results[i].VolumeAttachment = attachment
}
return results, nil
} | [
"func",
"(",
"lvs",
"*",
"loopVolumeSource",
")",
"AttachVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"args",
"[",
"]",
"storage",
".",
"VolumeAttachmentParams",
")",
"(",
"[",
"]",
"storage",
".",
"AttachVolumesResult",
",",
"error",
")",... | // AttachVolumes is defined on the VolumeSource interface. | [
"AttachVolumes",
"is",
"defined",
"on",
"the",
"VolumeSource",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/loop.go#L193-L204 |
4,554 | juju/juju | storage/provider/loop.go | DetachVolumes | func (lvs *loopVolumeSource) DetachVolumes(ctx context.ProviderCallContext, args []storage.VolumeAttachmentParams) ([]error, error) {
results := make([]error, len(args))
for i, arg := range args {
if err := lvs.detachVolume(arg.Volume); err != nil {
results[i] = errors.Annotatef(err, "detaching volume %s", arg.Volume.Id())
}
}
return results, nil
} | go | func (lvs *loopVolumeSource) DetachVolumes(ctx context.ProviderCallContext, args []storage.VolumeAttachmentParams) ([]error, error) {
results := make([]error, len(args))
for i, arg := range args {
if err := lvs.detachVolume(arg.Volume); err != nil {
results[i] = errors.Annotatef(err, "detaching volume %s", arg.Volume.Id())
}
}
return results, nil
} | [
"func",
"(",
"lvs",
"*",
"loopVolumeSource",
")",
"DetachVolumes",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"args",
"[",
"]",
"storage",
".",
"VolumeAttachmentParams",
")",
"(",
"[",
"]",
"error",
",",
"error",
")",
"{",
"results",
":=",
"ma... | // DetachVolumes is defined on the VolumeSource interface. | [
"DetachVolumes",
"is",
"defined",
"on",
"the",
"VolumeSource",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/loop.go#L224-L232 |
4,555 | juju/juju | storage/provider/loop.go | createBlockFile | func createBlockFile(run runCommandFunc, filePath string, sizeInMiB uint64) error {
// fallocate will reserve the space without actually writing to it.
_, err := run("fallocate", "-l", fmt.Sprintf("%dMiB", sizeInMiB), filePath)
if err != nil {
return errors.Annotatef(err, "allocating loop backing file %q", filePath)
}
return nil
} | go | func createBlockFile(run runCommandFunc, filePath string, sizeInMiB uint64) error {
// fallocate will reserve the space without actually writing to it.
_, err := run("fallocate", "-l", fmt.Sprintf("%dMiB", sizeInMiB), filePath)
if err != nil {
return errors.Annotatef(err, "allocating loop backing file %q", filePath)
}
return nil
} | [
"func",
"createBlockFile",
"(",
"run",
"runCommandFunc",
",",
"filePath",
"string",
",",
"sizeInMiB",
"uint64",
")",
"error",
"{",
"// fallocate will reserve the space without actually writing to it.",
"_",
",",
"err",
":=",
"run",
"(",
"\"",
"\"",
",",
"\"",
"\"",
... | // createBlockFile creates a file at the specified path, with the
// given size in mebibytes. | [
"createBlockFile",
"creates",
"a",
"file",
"at",
"the",
"specified",
"path",
"with",
"the",
"given",
"size",
"in",
"mebibytes",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/loop.go#L253-L260 |
4,556 | juju/juju | storage/provider/loop.go | detachLoopDevice | func detachLoopDevice(run runCommandFunc, deviceName string) error {
_, err := run("losetup", "-d", path.Join("/dev", deviceName))
if err != nil {
return errors.Annotatef(err, "detaching loop device %q", deviceName)
}
return err
} | go | func detachLoopDevice(run runCommandFunc, deviceName string) error {
_, err := run("losetup", "-d", path.Join("/dev", deviceName))
if err != nil {
return errors.Annotatef(err, "detaching loop device %q", deviceName)
}
return err
} | [
"func",
"detachLoopDevice",
"(",
"run",
"runCommandFunc",
",",
"deviceName",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"run",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"path",
".",
"Join",
"(",
"\"",
"\"",
",",
"deviceName",
")",
")",
"\n",
... | // detachLoopDevice detaches the loop device with the specified name. | [
"detachLoopDevice",
"detaches",
"the",
"loop",
"device",
"with",
"the",
"specified",
"name",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/loop.go#L293-L299 |
4,557 | juju/juju | storage/provider/loop.go | associatedLoopDevices | func associatedLoopDevices(run runCommandFunc, filePath string) ([]string, error) {
stdout, err := run("losetup", "-j", filePath)
if err != nil {
return nil, errors.Trace(err)
}
stdout = strings.TrimSpace(stdout)
if stdout == "" {
return nil, nil
}
// The output will be zero or more lines with the format:
// "/dev/loop0: [0021]:7504142 (/tmp/test.dat)"
lines := strings.Split(stdout, "\n")
deviceNames := make([]string, len(lines))
for i, line := range lines {
pos := strings.IndexRune(line, ':')
if pos == -1 {
return nil, errors.Errorf("unexpected output %q", line)
}
deviceName := line[:pos][len("/dev/"):]
deviceNames[i] = deviceName
}
return deviceNames, nil
} | go | func associatedLoopDevices(run runCommandFunc, filePath string) ([]string, error) {
stdout, err := run("losetup", "-j", filePath)
if err != nil {
return nil, errors.Trace(err)
}
stdout = strings.TrimSpace(stdout)
if stdout == "" {
return nil, nil
}
// The output will be zero or more lines with the format:
// "/dev/loop0: [0021]:7504142 (/tmp/test.dat)"
lines := strings.Split(stdout, "\n")
deviceNames := make([]string, len(lines))
for i, line := range lines {
pos := strings.IndexRune(line, ':')
if pos == -1 {
return nil, errors.Errorf("unexpected output %q", line)
}
deviceName := line[:pos][len("/dev/"):]
deviceNames[i] = deviceName
}
return deviceNames, nil
} | [
"func",
"associatedLoopDevices",
"(",
"run",
"runCommandFunc",
",",
"filePath",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"stdout",
",",
"err",
":=",
"run",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"filePath",
")",
"\n",
"if",
"er... | // associatedLoopDevices returns the device names of the loop devices
// associated with the specified file path. | [
"associatedLoopDevices",
"returns",
"the",
"device",
"names",
"of",
"the",
"loop",
"devices",
"associated",
"with",
"the",
"specified",
"file",
"path",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/storage/provider/loop.go#L303-L325 |
4,558 | juju/juju | cmd/juju/controller/register.go | NewRegisterCommand | func NewRegisterCommand() cmd.Command {
c := ®isterCommand{}
c.apiOpen = c.APIOpen
c.listModelsFunc = c.listModels
c.store = jujuclient.NewFileClientStore()
c.CanClearCurrentModel = true
return modelcmd.WrapBase(c)
} | go | func NewRegisterCommand() cmd.Command {
c := ®isterCommand{}
c.apiOpen = c.APIOpen
c.listModelsFunc = c.listModels
c.store = jujuclient.NewFileClientStore()
c.CanClearCurrentModel = true
return modelcmd.WrapBase(c)
} | [
"func",
"NewRegisterCommand",
"(",
")",
"cmd",
".",
"Command",
"{",
"c",
":=",
"&",
"registerCommand",
"{",
"}",
"\n",
"c",
".",
"apiOpen",
"=",
"c",
".",
"APIOpen",
"\n",
"c",
".",
"listModelsFunc",
"=",
"c",
".",
"listModels",
"\n",
"c",
".",
"stor... | // NewRegisterCommand returns a command to allow the user to register a controller. | [
"NewRegisterCommand",
"returns",
"a",
"command",
"to",
"allow",
"the",
"user",
"to",
"register",
"a",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/register.go#L46-L53 |
4,559 | juju/juju | cmd/juju/controller/register.go | Info | func (c *registerCommand) Info() *cmd.Info {
return jujucmd.Info(&cmd.Info{
Name: "register",
Args: "<registration string>|<controller host name>",
Purpose: usageRegisterSummary,
Doc: usageRegisterDetails,
})
} | go | func (c *registerCommand) Info() *cmd.Info {
return jujucmd.Info(&cmd.Info{
Name: "register",
Args: "<registration string>|<controller host name>",
Purpose: usageRegisterSummary,
Doc: usageRegisterDetails,
})
} | [
"func",
"(",
"c",
"*",
"registerCommand",
")",
"Info",
"(",
")",
"*",
"cmd",
".",
"Info",
"{",
"return",
"jujucmd",
".",
"Info",
"(",
"&",
"cmd",
".",
"Info",
"{",
"Name",
":",
"\"",
"\"",
",",
"Args",
":",
"\"",
"\"",
",",
"Purpose",
":",
"usa... | // Info implements Command.Info
// `register` may seem generic, but is seen as simple and without potential
// naming collisions in any current or planned features. | [
"Info",
"implements",
"Command",
".",
"Info",
"register",
"may",
"seem",
"generic",
"but",
"is",
"seen",
"as",
"simple",
"and",
"without",
"potential",
"naming",
"collisions",
"in",
"any",
"current",
"or",
"planned",
"features",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/register.go#L105-L112 |
4,560 | juju/juju | cmd/juju/controller/register.go | Init | func (c *registerCommand) Init(args []string) error {
if len(args) < 1 {
return errors.New("registration data missing")
}
c.Arg, args = args[0], args[1:]
if err := cmd.CheckEmpty(args); err != nil {
return errors.Trace(err)
}
return nil
} | go | func (c *registerCommand) Init(args []string) error {
if len(args) < 1 {
return errors.New("registration data missing")
}
c.Arg, args = args[0], args[1:]
if err := cmd.CheckEmpty(args); err != nil {
return errors.Trace(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"registerCommand",
")",
"Init",
"(",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"args",
")",
"<",
"1",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"c",
".",
"Arg",
"... | // SetFlags implements Command.Init. | [
"SetFlags",
"implements",
"Command",
".",
"Init",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/register.go#L115-L124 |
4,561 | juju/juju | cmd/juju/controller/register.go | controllerDetails | func (c *registerCommand) controllerDetails(ctx *cmd.Context, p *registrationParams, controllerName string) (jujuclient.ControllerDetails, jujuclient.AccountDetails, error) {
if p.publicHost != "" {
return c.publicControllerDetails(p.publicHost, controllerName)
}
return c.nonPublicControllerDetails(ctx, p, controllerName)
} | go | func (c *registerCommand) controllerDetails(ctx *cmd.Context, p *registrationParams, controllerName string) (jujuclient.ControllerDetails, jujuclient.AccountDetails, error) {
if p.publicHost != "" {
return c.publicControllerDetails(p.publicHost, controllerName)
}
return c.nonPublicControllerDetails(ctx, p, controllerName)
} | [
"func",
"(",
"c",
"*",
"registerCommand",
")",
"controllerDetails",
"(",
"ctx",
"*",
"cmd",
".",
"Context",
",",
"p",
"*",
"registrationParams",
",",
"controllerName",
"string",
")",
"(",
"jujuclient",
".",
"ControllerDetails",
",",
"jujuclient",
".",
"Account... | // controllerDetails returns controller and account details to be registered for the
// given registration parameters. | [
"controllerDetails",
"returns",
"controller",
"and",
"account",
"details",
"to",
"be",
"registered",
"for",
"the",
"given",
"registration",
"parameters",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/register.go#L188-L193 |
4,562 | juju/juju | cmd/juju/controller/register.go | publicControllerDetails | func (c *registerCommand) publicControllerDetails(host, controllerName string) (jujuclient.ControllerDetails, jujuclient.AccountDetails, error) {
errRet := func(err error) (jujuclient.ControllerDetails, jujuclient.AccountDetails, error) {
return jujuclient.ControllerDetails{}, jujuclient.AccountDetails{}, err
}
apiAddr := host
if !strings.Contains(apiAddr, ":") {
apiAddr += ":443"
}
// Make a direct API connection because we don't yet know the
// controller UUID so can't store the thus-incomplete controller
// details to make a conventional connection.
//
// Unfortunately this means we'll connect twice to the controller
// but it's probably best to go through the conventional path the
// second time.
bclient, err := c.BakeryClient(c.store, controllerName)
if err != nil {
return errRet(errors.Trace(err))
}
dialOpts := api.DefaultDialOpts()
dialOpts.BakeryClient = bclient
conn, err := c.apiOpen(&api.Info{
Addrs: []string{apiAddr},
}, dialOpts)
if err != nil {
return errRet(errors.Trace(err))
}
defer conn.Close()
user, ok := conn.AuthTag().(names.UserTag)
if !ok {
return errRet(errors.Errorf("logged in as %v, not a user", conn.AuthTag()))
}
// If we get to here, then we have a cached macaroon for the registered
// user. If we encounter an error after here, we need to clear it.
c.onRunError = func() {
if err := c.ClearControllerMacaroons(c.store, controllerName); err != nil {
logger.Errorf("failed to clear macaroon: %v", err)
}
}
return jujuclient.ControllerDetails{
APIEndpoints: []string{apiAddr},
ControllerUUID: conn.ControllerTag().Id(),
}, jujuclient.AccountDetails{
User: user.Id(),
LastKnownAccess: conn.ControllerAccess(),
}, nil
} | go | func (c *registerCommand) publicControllerDetails(host, controllerName string) (jujuclient.ControllerDetails, jujuclient.AccountDetails, error) {
errRet := func(err error) (jujuclient.ControllerDetails, jujuclient.AccountDetails, error) {
return jujuclient.ControllerDetails{}, jujuclient.AccountDetails{}, err
}
apiAddr := host
if !strings.Contains(apiAddr, ":") {
apiAddr += ":443"
}
// Make a direct API connection because we don't yet know the
// controller UUID so can't store the thus-incomplete controller
// details to make a conventional connection.
//
// Unfortunately this means we'll connect twice to the controller
// but it's probably best to go through the conventional path the
// second time.
bclient, err := c.BakeryClient(c.store, controllerName)
if err != nil {
return errRet(errors.Trace(err))
}
dialOpts := api.DefaultDialOpts()
dialOpts.BakeryClient = bclient
conn, err := c.apiOpen(&api.Info{
Addrs: []string{apiAddr},
}, dialOpts)
if err != nil {
return errRet(errors.Trace(err))
}
defer conn.Close()
user, ok := conn.AuthTag().(names.UserTag)
if !ok {
return errRet(errors.Errorf("logged in as %v, not a user", conn.AuthTag()))
}
// If we get to here, then we have a cached macaroon for the registered
// user. If we encounter an error after here, we need to clear it.
c.onRunError = func() {
if err := c.ClearControllerMacaroons(c.store, controllerName); err != nil {
logger.Errorf("failed to clear macaroon: %v", err)
}
}
return jujuclient.ControllerDetails{
APIEndpoints: []string{apiAddr},
ControllerUUID: conn.ControllerTag().Id(),
}, jujuclient.AccountDetails{
User: user.Id(),
LastKnownAccess: conn.ControllerAccess(),
}, nil
} | [
"func",
"(",
"c",
"*",
"registerCommand",
")",
"publicControllerDetails",
"(",
"host",
",",
"controllerName",
"string",
")",
"(",
"jujuclient",
".",
"ControllerDetails",
",",
"jujuclient",
".",
"AccountDetails",
",",
"error",
")",
"{",
"errRet",
":=",
"func",
... | // publicControllerDetails returns controller and account details to be registered
// for the given public controller host name. | [
"publicControllerDetails",
"returns",
"controller",
"and",
"account",
"details",
"to",
"be",
"registered",
"for",
"the",
"given",
"public",
"controller",
"host",
"name",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/register.go#L197-L243 |
4,563 | juju/juju | cmd/juju/controller/register.go | nonPublicControllerDetails | func (c *registerCommand) nonPublicControllerDetails(ctx *cmd.Context, registrationParams *registrationParams, controllerName string) (jujuclient.ControllerDetails, jujuclient.AccountDetails, error) {
errRet := func(err error) (jujuclient.ControllerDetails, jujuclient.AccountDetails, error) {
return jujuclient.ControllerDetails{}, jujuclient.AccountDetails{}, err
}
// During registration we must set a new password. This has to be done
// atomically with the clearing of the secret key.
payloadBytes, err := json.Marshal(params.SecretKeyLoginRequestPayload{
registrationParams.newPassword,
})
if err != nil {
return errRet(errors.Trace(err))
}
// Make the registration call. If this is successful, the client's
// cookie jar will be populated with a macaroon that may be used
// to log in below without the user having to type in the password
// again.
req := params.SecretKeyLoginRequest{
Nonce: registrationParams.nonce[:],
User: registrationParams.userTag.String(),
PayloadCiphertext: secretbox.Seal(
nil, payloadBytes,
®istrationParams.nonce,
®istrationParams.key,
),
}
resp, err := c.secretKeyLogin(registrationParams.controllerAddrs, req, controllerName)
if err != nil {
// If we got here and got an error, the registration token supplied
// will be expired.
// Log the error as it will be useful for debugging, but give user a
// suggestion for the way forward instead of error details.
logger.Infof("while validating secret key: %v", err)
err = errors.Errorf("Provided registration token may have been expired.\nA controller administrator must reset your user to issue a new token.\nSee %q for more information.", "juju help change-user-password")
return errRet(errors.Trace(err))
}
// Decrypt the response to authenticate the controller and
// obtain its CA certificate.
if len(resp.Nonce) != len(registrationParams.nonce) {
return errRet(errors.NotValidf("response nonce"))
}
var respNonce [24]byte
copy(respNonce[:], resp.Nonce)
payloadBytes, ok := secretbox.Open(nil, resp.PayloadCiphertext, &respNonce, ®istrationParams.key)
if !ok {
return errRet(errors.NotValidf("response payload"))
}
var responsePayload params.SecretKeyLoginResponsePayload
if err := json.Unmarshal(payloadBytes, &responsePayload); err != nil {
return errRet(errors.Annotate(err, "unmarshalling response payload"))
}
user := registrationParams.userTag.Id()
ctx.Infof("Initial password successfully set for %s.", friendlyUserName(user))
// If we get to here, then we have a cached macaroon for the registered
// user. If we encounter an error after here, we need to clear it.
c.onRunError = func() {
if err := c.ClearControllerMacaroons(c.store, controllerName); err != nil {
logger.Errorf("failed to clear macaroon: %v", err)
}
}
return jujuclient.ControllerDetails{
APIEndpoints: registrationParams.controllerAddrs,
ControllerUUID: responsePayload.ControllerUUID,
CACert: responsePayload.CACert,
}, jujuclient.AccountDetails{
User: user,
LastKnownAccess: string(permission.LoginAccess),
}, nil
} | go | func (c *registerCommand) nonPublicControllerDetails(ctx *cmd.Context, registrationParams *registrationParams, controllerName string) (jujuclient.ControllerDetails, jujuclient.AccountDetails, error) {
errRet := func(err error) (jujuclient.ControllerDetails, jujuclient.AccountDetails, error) {
return jujuclient.ControllerDetails{}, jujuclient.AccountDetails{}, err
}
// During registration we must set a new password. This has to be done
// atomically with the clearing of the secret key.
payloadBytes, err := json.Marshal(params.SecretKeyLoginRequestPayload{
registrationParams.newPassword,
})
if err != nil {
return errRet(errors.Trace(err))
}
// Make the registration call. If this is successful, the client's
// cookie jar will be populated with a macaroon that may be used
// to log in below without the user having to type in the password
// again.
req := params.SecretKeyLoginRequest{
Nonce: registrationParams.nonce[:],
User: registrationParams.userTag.String(),
PayloadCiphertext: secretbox.Seal(
nil, payloadBytes,
®istrationParams.nonce,
®istrationParams.key,
),
}
resp, err := c.secretKeyLogin(registrationParams.controllerAddrs, req, controllerName)
if err != nil {
// If we got here and got an error, the registration token supplied
// will be expired.
// Log the error as it will be useful for debugging, but give user a
// suggestion for the way forward instead of error details.
logger.Infof("while validating secret key: %v", err)
err = errors.Errorf("Provided registration token may have been expired.\nA controller administrator must reset your user to issue a new token.\nSee %q for more information.", "juju help change-user-password")
return errRet(errors.Trace(err))
}
// Decrypt the response to authenticate the controller and
// obtain its CA certificate.
if len(resp.Nonce) != len(registrationParams.nonce) {
return errRet(errors.NotValidf("response nonce"))
}
var respNonce [24]byte
copy(respNonce[:], resp.Nonce)
payloadBytes, ok := secretbox.Open(nil, resp.PayloadCiphertext, &respNonce, ®istrationParams.key)
if !ok {
return errRet(errors.NotValidf("response payload"))
}
var responsePayload params.SecretKeyLoginResponsePayload
if err := json.Unmarshal(payloadBytes, &responsePayload); err != nil {
return errRet(errors.Annotate(err, "unmarshalling response payload"))
}
user := registrationParams.userTag.Id()
ctx.Infof("Initial password successfully set for %s.", friendlyUserName(user))
// If we get to here, then we have a cached macaroon for the registered
// user. If we encounter an error after here, we need to clear it.
c.onRunError = func() {
if err := c.ClearControllerMacaroons(c.store, controllerName); err != nil {
logger.Errorf("failed to clear macaroon: %v", err)
}
}
return jujuclient.ControllerDetails{
APIEndpoints: registrationParams.controllerAddrs,
ControllerUUID: responsePayload.ControllerUUID,
CACert: responsePayload.CACert,
}, jujuclient.AccountDetails{
User: user,
LastKnownAccess: string(permission.LoginAccess),
}, nil
} | [
"func",
"(",
"c",
"*",
"registerCommand",
")",
"nonPublicControllerDetails",
"(",
"ctx",
"*",
"cmd",
".",
"Context",
",",
"registrationParams",
"*",
"registrationParams",
",",
"controllerName",
"string",
")",
"(",
"jujuclient",
".",
"ControllerDetails",
",",
"juju... | // nonPublicControllerDetails returns controller and account details to be registered with
// respect to the given registration parameters. | [
"nonPublicControllerDetails",
"returns",
"controller",
"and",
"account",
"details",
"to",
"be",
"registered",
"with",
"respect",
"to",
"the",
"given",
"registration",
"parameters",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/register.go#L247-L316 |
4,564 | juju/juju | cmd/juju/controller/register.go | updateController | func (c *registerCommand) updateController(
ctx *cmd.Context,
store jujuclient.ClientStore,
controllerName string,
controllerDetails jujuclient.ControllerDetails,
accountDetails jujuclient.AccountDetails,
) error {
// Check that the same controller isn't already stored, so that we
// can avoid needlessly asking for a controller name in that case.
all, err := store.AllControllers()
if err != nil {
return errors.Trace(err)
}
for name, ctl := range all {
if ctl.ControllerUUID == controllerDetails.ControllerUUID {
var buf bytes.Buffer
if err := alreadyRegisteredMessageT.Execute(
&buf,
map[string]interface{}{
"ControllerName": name,
"UserName": accountDetails.User,
},
); err != nil {
return err
}
ctx.Warningf(buf.String())
return errors.Errorf("controller is already registered as %q", name)
}
}
if err := store.AddController(controllerName, controllerDetails); err != nil {
return errors.Trace(err)
}
if err := store.UpdateAccount(controllerName, accountDetails); err != nil {
return errors.Annotatef(err, "cannot update account information: %v", err)
}
return nil
} | go | func (c *registerCommand) updateController(
ctx *cmd.Context,
store jujuclient.ClientStore,
controllerName string,
controllerDetails jujuclient.ControllerDetails,
accountDetails jujuclient.AccountDetails,
) error {
// Check that the same controller isn't already stored, so that we
// can avoid needlessly asking for a controller name in that case.
all, err := store.AllControllers()
if err != nil {
return errors.Trace(err)
}
for name, ctl := range all {
if ctl.ControllerUUID == controllerDetails.ControllerUUID {
var buf bytes.Buffer
if err := alreadyRegisteredMessageT.Execute(
&buf,
map[string]interface{}{
"ControllerName": name,
"UserName": accountDetails.User,
},
); err != nil {
return err
}
ctx.Warningf(buf.String())
return errors.Errorf("controller is already registered as %q", name)
}
}
if err := store.AddController(controllerName, controllerDetails); err != nil {
return errors.Trace(err)
}
if err := store.UpdateAccount(controllerName, accountDetails); err != nil {
return errors.Annotatef(err, "cannot update account information: %v", err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"registerCommand",
")",
"updateController",
"(",
"ctx",
"*",
"cmd",
".",
"Context",
",",
"store",
"jujuclient",
".",
"ClientStore",
",",
"controllerName",
"string",
",",
"controllerDetails",
"jujuclient",
".",
"ControllerDetails",
",",
"ac... | // updateController prompts for a controller name and updates the
// controller and account details in the given client store. | [
"updateController",
"prompts",
"for",
"a",
"controller",
"name",
"and",
"updates",
"the",
"controller",
"and",
"account",
"details",
"in",
"the",
"given",
"client",
"store",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/register.go#L320-L356 |
4,565 | juju/juju | cmd/juju/controller/register.go | getParameters | func (c *registerCommand) getParameters(ctx *cmd.Context) (*registrationParams, error) {
var params registrationParams
if strings.Contains(c.Arg, ".") || c.Arg == "localhost" {
// Looks like a host name - no URL-encoded base64 string should
// contain a dot and every public controller name should.
// Allow localhost for development purposes.
params.publicHost = c.Arg
// No need for password shenanigans if we're using a public controller.
return ¶ms, nil
}
// Decode key, username, controller addresses from the string supplied
// on the command line.
decodedData, err := base64.URLEncoding.DecodeString(c.Arg)
if err != nil {
return nil, errors.Trace(err)
}
var info jujuclient.RegistrationInfo
if _, err := asn1.Unmarshal(decodedData, &info); err != nil {
return nil, errors.Trace(err)
}
params.controllerAddrs = info.Addrs
params.userTag = names.NewUserTag(info.User)
if len(info.SecretKey) != len(params.key) {
return nil, errors.NotValidf("secret key")
}
copy(params.key[:], info.SecretKey)
params.defaultControllerName = info.ControllerName
// Prompt the user for the new password to set.
newPassword, err := c.promptNewPassword(ctx.Stderr, ctx.Stdin)
if err != nil {
return nil, errors.Trace(err)
}
params.newPassword = newPassword
// Generate a random nonce for encrypting the request.
if _, err := rand.Read(params.nonce[:]); err != nil {
return nil, errors.Trace(err)
}
return ¶ms, nil
} | go | func (c *registerCommand) getParameters(ctx *cmd.Context) (*registrationParams, error) {
var params registrationParams
if strings.Contains(c.Arg, ".") || c.Arg == "localhost" {
// Looks like a host name - no URL-encoded base64 string should
// contain a dot and every public controller name should.
// Allow localhost for development purposes.
params.publicHost = c.Arg
// No need for password shenanigans if we're using a public controller.
return ¶ms, nil
}
// Decode key, username, controller addresses from the string supplied
// on the command line.
decodedData, err := base64.URLEncoding.DecodeString(c.Arg)
if err != nil {
return nil, errors.Trace(err)
}
var info jujuclient.RegistrationInfo
if _, err := asn1.Unmarshal(decodedData, &info); err != nil {
return nil, errors.Trace(err)
}
params.controllerAddrs = info.Addrs
params.userTag = names.NewUserTag(info.User)
if len(info.SecretKey) != len(params.key) {
return nil, errors.NotValidf("secret key")
}
copy(params.key[:], info.SecretKey)
params.defaultControllerName = info.ControllerName
// Prompt the user for the new password to set.
newPassword, err := c.promptNewPassword(ctx.Stderr, ctx.Stdin)
if err != nil {
return nil, errors.Trace(err)
}
params.newPassword = newPassword
// Generate a random nonce for encrypting the request.
if _, err := rand.Read(params.nonce[:]); err != nil {
return nil, errors.Trace(err)
}
return ¶ms, nil
} | [
"func",
"(",
"c",
"*",
"registerCommand",
")",
"getParameters",
"(",
"ctx",
"*",
"cmd",
".",
"Context",
")",
"(",
"*",
"registrationParams",
",",
"error",
")",
"{",
"var",
"params",
"registrationParams",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"c",
... | // getParameters gets all of the parameters required for registering, prompting
// the user as necessary. | [
"getParameters",
"gets",
"all",
"of",
"the",
"parameters",
"required",
"for",
"registering",
"prompting",
"the",
"user",
"as",
"necessary",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/register.go#L438-L480 |
4,566 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | NewProvisionerAPIV4 | func NewProvisionerAPIV4(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV4, error) {
provisionerAPI, err := NewProvisionerAPIV5(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV4{provisionerAPI}, nil
} | go | func NewProvisionerAPIV4(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV4, error) {
provisionerAPI, err := NewProvisionerAPIV5(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV4{provisionerAPI}, nil
} | [
"func",
"NewProvisionerAPIV4",
"(",
"st",
"*",
"state",
".",
"State",
",",
"resources",
"facade",
".",
"Resources",
",",
"authorizer",
"facade",
".",
"Authorizer",
")",
"(",
"*",
"ProvisionerAPIV4",
",",
"error",
")",
"{",
"provisionerAPI",
",",
"err",
":=",... | // NewProvisionerAPIV4 creates a new server-side version 4 Provisioner API facade. | [
"NewProvisionerAPIV4",
"creates",
"a",
"new",
"server",
"-",
"side",
"version",
"4",
"Provisioner",
"API",
"facade",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L197-L203 |
4,567 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | NewProvisionerAPIV5 | func NewProvisionerAPIV5(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV5, error) {
provisionerAPI, err := NewProvisionerAPIV6(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV5{provisionerAPI}, nil
} | go | func NewProvisionerAPIV5(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV5, error) {
provisionerAPI, err := NewProvisionerAPIV6(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV5{provisionerAPI}, nil
} | [
"func",
"NewProvisionerAPIV5",
"(",
"st",
"*",
"state",
".",
"State",
",",
"resources",
"facade",
".",
"Resources",
",",
"authorizer",
"facade",
".",
"Authorizer",
")",
"(",
"*",
"ProvisionerAPIV5",
",",
"error",
")",
"{",
"provisionerAPI",
",",
"err",
":=",... | // NewProvisionerAPIV5 creates a new server-side Provisioner API facade. | [
"NewProvisionerAPIV5",
"creates",
"a",
"new",
"server",
"-",
"side",
"Provisioner",
"API",
"facade",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L206-L212 |
4,568 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | NewProvisionerAPIV6 | func NewProvisionerAPIV6(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV6, error) {
provisionerAPI, err := NewProvisionerAPIV7(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV6{provisionerAPI}, nil
} | go | func NewProvisionerAPIV6(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV6, error) {
provisionerAPI, err := NewProvisionerAPIV7(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV6{provisionerAPI}, nil
} | [
"func",
"NewProvisionerAPIV6",
"(",
"st",
"*",
"state",
".",
"State",
",",
"resources",
"facade",
".",
"Resources",
",",
"authorizer",
"facade",
".",
"Authorizer",
")",
"(",
"*",
"ProvisionerAPIV6",
",",
"error",
")",
"{",
"provisionerAPI",
",",
"err",
":=",... | // NewProvisionerAPIV6 creates a new server-side Provisioner API facade. | [
"NewProvisionerAPIV6",
"creates",
"a",
"new",
"server",
"-",
"side",
"Provisioner",
"API",
"facade",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L215-L221 |
4,569 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | NewProvisionerAPIV7 | func NewProvisionerAPIV7(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV7, error) {
provisionerAPI, err := NewProvisionerAPIV8(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV7{provisionerAPI}, nil
} | go | func NewProvisionerAPIV7(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV7, error) {
provisionerAPI, err := NewProvisionerAPIV8(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV7{provisionerAPI}, nil
} | [
"func",
"NewProvisionerAPIV7",
"(",
"st",
"*",
"state",
".",
"State",
",",
"resources",
"facade",
".",
"Resources",
",",
"authorizer",
"facade",
".",
"Authorizer",
")",
"(",
"*",
"ProvisionerAPIV7",
",",
"error",
")",
"{",
"provisionerAPI",
",",
"err",
":=",... | // NewProvisionerAPIV7 creates a new server-side Provisioner API facade. | [
"NewProvisionerAPIV7",
"creates",
"a",
"new",
"server",
"-",
"side",
"Provisioner",
"API",
"facade",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L224-L230 |
4,570 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | NewProvisionerAPIV8 | func NewProvisionerAPIV8(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV8, error) {
provisionerAPI, err := NewProvisionerAPIV9(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV8{provisionerAPI}, nil
} | go | func NewProvisionerAPIV8(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV8, error) {
provisionerAPI, err := NewProvisionerAPIV9(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV8{provisionerAPI}, nil
} | [
"func",
"NewProvisionerAPIV8",
"(",
"st",
"*",
"state",
".",
"State",
",",
"resources",
"facade",
".",
"Resources",
",",
"authorizer",
"facade",
".",
"Authorizer",
")",
"(",
"*",
"ProvisionerAPIV8",
",",
"error",
")",
"{",
"provisionerAPI",
",",
"err",
":=",... | // NewProvisionerAPIV8 creates a new server-side Provisioner API facade. | [
"NewProvisionerAPIV8",
"creates",
"a",
"new",
"server",
"-",
"side",
"Provisioner",
"API",
"facade",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L233-L239 |
4,571 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | NewProvisionerAPIV9 | func NewProvisionerAPIV9(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV9, error) {
provisionerAPI, err := NewProvisionerAPI(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV9{provisionerAPI}, nil
} | go | func NewProvisionerAPIV9(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*ProvisionerAPIV9, error) {
provisionerAPI, err := NewProvisionerAPI(st, resources, authorizer)
if err != nil {
return nil, errors.Trace(err)
}
return &ProvisionerAPIV9{provisionerAPI}, nil
} | [
"func",
"NewProvisionerAPIV9",
"(",
"st",
"*",
"state",
".",
"State",
",",
"resources",
"facade",
".",
"Resources",
",",
"authorizer",
"facade",
".",
"Authorizer",
")",
"(",
"*",
"ProvisionerAPIV9",
",",
"error",
")",
"{",
"provisionerAPI",
",",
"err",
":=",... | // NewProvisionerAPIV9 creates a new server-side Provisioner API facade. | [
"NewProvisionerAPIV9",
"creates",
"a",
"new",
"server",
"-",
"side",
"Provisioner",
"API",
"facade",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L242-L248 |
4,572 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | WatchContainers | func (p *ProvisionerAPI) WatchContainers(args params.WatchContainers) (params.StringsWatchResults, error) {
result := params.StringsWatchResults{
Results: make([]params.StringsWatchResult, len(args.Params)),
}
for i, arg := range args.Params {
watcherResult, err := p.watchOneMachineContainers(arg)
result.Results[i] = watcherResult
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (p *ProvisionerAPI) WatchContainers(args params.WatchContainers) (params.StringsWatchResults, error) {
result := params.StringsWatchResults{
Results: make([]params.StringsWatchResult, len(args.Params)),
}
for i, arg := range args.Params {
watcherResult, err := p.watchOneMachineContainers(arg)
result.Results[i] = watcherResult
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"WatchContainers",
"(",
"args",
"params",
".",
"WatchContainers",
")",
"(",
"params",
".",
"StringsWatchResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"StringsWatchResults",
"{",
"Results",
":",
... | // WatchContainers starts a StringsWatcher to watch containers deployed to
// any machine passed in args. | [
"WatchContainers",
"starts",
"a",
"StringsWatcher",
"to",
"watch",
"containers",
"deployed",
"to",
"any",
"machine",
"passed",
"in",
"args",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L298-L308 |
4,573 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | WatchAllContainers | func (p *ProvisionerAPI) WatchAllContainers(args params.WatchContainers) (params.StringsWatchResults, error) {
return p.WatchContainers(args)
} | go | func (p *ProvisionerAPI) WatchAllContainers(args params.WatchContainers) (params.StringsWatchResults, error) {
return p.WatchContainers(args)
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"WatchAllContainers",
"(",
"args",
"params",
".",
"WatchContainers",
")",
"(",
"params",
".",
"StringsWatchResults",
",",
"error",
")",
"{",
"return",
"p",
".",
"WatchContainers",
"(",
"args",
")",
"\n",
"}"
] | // WatchAllContainers starts a StringsWatcher to watch all containers deployed to
// any machine passed in args. | [
"WatchAllContainers",
"starts",
"a",
"StringsWatcher",
"to",
"watch",
"all",
"containers",
"deployed",
"to",
"any",
"machine",
"passed",
"in",
"args",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L312-L314 |
4,574 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | SetSupportedContainers | func (p *ProvisionerAPI) SetSupportedContainers(args params.MachineContainersParams) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Params)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, arg := range args.Params {
tag, err := names.ParseMachineTag(arg.MachineTag)
if err != nil {
logger.Warningf("SetSupportedContainers called with %q which is not a valid machine tag: %v", arg.MachineTag, err)
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
if len(arg.ContainerTypes) == 0 {
err = machine.SupportsNoContainers()
} else {
err = machine.SetSupportedContainers(arg.ContainerTypes)
}
if err != nil {
result.Results[i].Error = common.ServerError(err)
}
}
return result, nil
} | go | func (p *ProvisionerAPI) SetSupportedContainers(args params.MachineContainersParams) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Params)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, arg := range args.Params {
tag, err := names.ParseMachineTag(arg.MachineTag)
if err != nil {
logger.Warningf("SetSupportedContainers called with %q which is not a valid machine tag: %v", arg.MachineTag, err)
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
if len(arg.ContainerTypes) == 0 {
err = machine.SupportsNoContainers()
} else {
err = machine.SetSupportedContainers(arg.ContainerTypes)
}
if err != nil {
result.Results[i].Error = common.ServerError(err)
}
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"SetSupportedContainers",
"(",
"args",
"params",
".",
"MachineContainersParams",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
... | // SetSupportedContainers updates the list of containers supported by the machines passed in args. | [
"SetSupportedContainers",
"updates",
"the",
"list",
"of",
"containers",
"supported",
"by",
"the",
"machines",
"passed",
"in",
"args",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L330-L361 |
4,575 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | SupportedContainers | func (p *ProvisionerAPI) SupportedContainers(args params.Entities) (params.MachineContainerResults, error) {
result := params.MachineContainerResults{
Results: make([]params.MachineContainerResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, arg := range args.Entities {
tag, err := names.ParseMachineTag(arg.Tag)
if err != nil {
logger.Warningf("SupportedContainers called with %q which is not a valid machine tag: %v", arg.Tag, err)
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
containerTypes, determined := machine.SupportedContainers()
result.Results[i].ContainerTypes = containerTypes
result.Results[i].Determined = determined
}
return result, nil
} | go | func (p *ProvisionerAPI) SupportedContainers(args params.Entities) (params.MachineContainerResults, error) {
result := params.MachineContainerResults{
Results: make([]params.MachineContainerResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, arg := range args.Entities {
tag, err := names.ParseMachineTag(arg.Tag)
if err != nil {
logger.Warningf("SupportedContainers called with %q which is not a valid machine tag: %v", arg.Tag, err)
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
containerTypes, determined := machine.SupportedContainers()
result.Results[i].ContainerTypes = containerTypes
result.Results[i].Determined = determined
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"SupportedContainers",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"MachineContainerResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"MachineContainerResults",
"{",
"Results",
"... | // SupportedContainers returns the list of containers supported by the machines passed in args. | [
"SupportedContainers",
"returns",
"the",
"list",
"of",
"containers",
"supported",
"by",
"the",
"machines",
"passed",
"in",
"args",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L368-L394 |
4,576 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | MachinesWithTransientErrors | func (p *ProvisionerAPI) MachinesWithTransientErrors() (params.StatusResults, error) {
var results params.StatusResults
canAccessFunc, err := p.getAuthFunc()
if err != nil {
return results, err
}
// TODO (wallyworld) - add state.State API for more efficient machines query
machines, err := p.st.AllMachines()
if err != nil {
return results, err
}
for _, machine := range machines {
if !canAccessFunc(machine.Tag()) {
continue
}
if _, provisionedErr := machine.InstanceId(); provisionedErr == nil {
// Machine may have been provisioned but machiner hasn't set the
// status to Started yet.
continue
}
var result params.StatusResult
statusInfo, err := machine.InstanceStatus()
if err != nil {
continue
}
result.Status = statusInfo.Status.String()
result.Info = statusInfo.Message
result.Data = statusInfo.Data
if statusInfo.Status != status.Error && statusInfo.Status != status.ProvisioningError {
continue
}
// Transient errors are marked as such in the status data.
if transient, ok := result.Data["transient"].(bool); !ok || !transient {
continue
}
result.Id = machine.Id()
result.Life = params.Life(machine.Life().String())
results.Results = append(results.Results, result)
}
return results, nil
} | go | func (p *ProvisionerAPI) MachinesWithTransientErrors() (params.StatusResults, error) {
var results params.StatusResults
canAccessFunc, err := p.getAuthFunc()
if err != nil {
return results, err
}
// TODO (wallyworld) - add state.State API for more efficient machines query
machines, err := p.st.AllMachines()
if err != nil {
return results, err
}
for _, machine := range machines {
if !canAccessFunc(machine.Tag()) {
continue
}
if _, provisionedErr := machine.InstanceId(); provisionedErr == nil {
// Machine may have been provisioned but machiner hasn't set the
// status to Started yet.
continue
}
var result params.StatusResult
statusInfo, err := machine.InstanceStatus()
if err != nil {
continue
}
result.Status = statusInfo.Status.String()
result.Info = statusInfo.Message
result.Data = statusInfo.Data
if statusInfo.Status != status.Error && statusInfo.Status != status.ProvisioningError {
continue
}
// Transient errors are marked as such in the status data.
if transient, ok := result.Data["transient"].(bool); !ok || !transient {
continue
}
result.Id = machine.Id()
result.Life = params.Life(machine.Life().String())
results.Results = append(results.Results, result)
}
return results, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"MachinesWithTransientErrors",
"(",
")",
"(",
"params",
".",
"StatusResults",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"StatusResults",
"\n",
"canAccessFunc",
",",
"err",
":=",
"p",
".",
"getAuthF... | // MachinesWithTransientErrors returns status data for machines with provisioning
// errors which are transient. | [
"MachinesWithTransientErrors",
"returns",
"status",
"data",
"for",
"machines",
"with",
"provisioning",
"errors",
"which",
"are",
"transient",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L470-L510 |
4,577 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | Series | func (p *ProvisionerAPI) Series(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
result.Results[i].Result = machine.Series()
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (p *ProvisionerAPI) Series(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
result.Results[i].Result = machine.Series()
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"Series",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"StringResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"StringResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]"... | // Series returns the deployed series for each given machine entity. | [
"Series",
"returns",
"the",
"deployed",
"series",
"for",
"each",
"given",
"machine",
"entity",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L513-L534 |
4,578 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | KeepInstance | func (p *ProvisionerAPI) KeepInstance(args params.Entities) (params.BoolResults, error) {
result := params.BoolResults{
Results: make([]params.BoolResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
keep, err := machine.KeepInstance()
result.Results[i].Result = keep
result.Results[i].Error = common.ServerError(err)
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (p *ProvisionerAPI) KeepInstance(args params.Entities) (params.BoolResults, error) {
result := params.BoolResults{
Results: make([]params.BoolResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
keep, err := machine.KeepInstance()
result.Results[i].Result = keep
result.Results[i].Error = common.ServerError(err)
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"KeepInstance",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"BoolResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"BoolResults",
"{",
"Results",
":",
"make",
"(",
"[",
"... | // KeepInstance returns the keep-instance value for each given machine entity. | [
"KeepInstance",
"returns",
"the",
"keep",
"-",
"instance",
"value",
"for",
"each",
"given",
"machine",
"entity",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L569-L593 |
4,579 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | DistributionGroup | func (p *ProvisionerAPI) DistributionGroup(args params.Entities) (params.DistributionGroupResults, error) {
result := params.DistributionGroupResults{
Results: make([]params.DistributionGroupResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
// If the machine is a controller, return
// controller instances. Otherwise, return
// instances with services in common with the machine
// being provisioned.
if machine.IsManager() {
result.Results[i].Result, err = controllerInstances(p.st)
} else {
result.Results[i].Result, err = commonServiceInstances(p.st, machine)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (p *ProvisionerAPI) DistributionGroup(args params.Entities) (params.DistributionGroupResults, error) {
result := params.DistributionGroupResults{
Results: make([]params.DistributionGroupResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
// If the machine is a controller, return
// controller instances. Otherwise, return
// instances with services in common with the machine
// being provisioned.
if machine.IsManager() {
result.Results[i].Result, err = controllerInstances(p.st)
} else {
result.Results[i].Result, err = commonServiceInstances(p.st, machine)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"DistributionGroup",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"DistributionGroupResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"DistributionGroupResults",
"{",
"Results",
"... | // DistributionGroup returns, for each given machine entity,
// a slice of instance.Ids that belong to the same distribution
// group as that machine. This information may be used to
// distribute instances for high availability. | [
"DistributionGroup",
"returns",
"for",
"each",
"given",
"machine",
"entity",
"a",
"slice",
"of",
"instance",
".",
"Ids",
"that",
"belong",
"to",
"the",
"same",
"distribution",
"group",
"as",
"that",
"machine",
".",
"This",
"information",
"may",
"be",
"used",
... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L599-L628 |
4,580 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | controllerInstances | func controllerInstances(st *state.State) ([]instance.Id, error) {
info, err := st.ControllerInfo()
if err != nil {
return nil, err
}
instances := make([]instance.Id, 0, len(info.MachineIds))
for _, id := range info.MachineIds {
machine, err := st.Machine(id)
if err != nil {
return nil, err
}
instanceId, err := machine.InstanceId()
if err == nil {
instances = append(instances, instanceId)
} else if !errors.IsNotProvisioned(err) {
return nil, err
}
}
return instances, nil
} | go | func controllerInstances(st *state.State) ([]instance.Id, error) {
info, err := st.ControllerInfo()
if err != nil {
return nil, err
}
instances := make([]instance.Id, 0, len(info.MachineIds))
for _, id := range info.MachineIds {
machine, err := st.Machine(id)
if err != nil {
return nil, err
}
instanceId, err := machine.InstanceId()
if err == nil {
instances = append(instances, instanceId)
} else if !errors.IsNotProvisioned(err) {
return nil, err
}
}
return instances, nil
} | [
"func",
"controllerInstances",
"(",
"st",
"*",
"state",
".",
"State",
")",
"(",
"[",
"]",
"instance",
".",
"Id",
",",
"error",
")",
"{",
"info",
",",
"err",
":=",
"st",
".",
"ControllerInfo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",... | // controllerInstances returns all environ manager instances. | [
"controllerInstances",
"returns",
"all",
"environ",
"manager",
"instances",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L631-L650 |
4,581 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | commonServiceInstances | func commonServiceInstances(st *state.State, m *state.Machine) ([]instance.Id, error) {
units, err := m.Units()
if err != nil {
return nil, err
}
instanceIdSet := make(set.Strings)
for _, unit := range units {
if !unit.IsPrincipal() {
continue
}
instanceIds, err := state.ApplicationInstances(st, unit.ApplicationName())
if err != nil {
return nil, err
}
for _, instanceId := range instanceIds {
instanceIdSet.Add(string(instanceId))
}
}
instanceIds := make([]instance.Id, instanceIdSet.Size())
// Sort values to simplify testing.
for i, instanceId := range instanceIdSet.SortedValues() {
instanceIds[i] = instance.Id(instanceId)
}
return instanceIds, nil
} | go | func commonServiceInstances(st *state.State, m *state.Machine) ([]instance.Id, error) {
units, err := m.Units()
if err != nil {
return nil, err
}
instanceIdSet := make(set.Strings)
for _, unit := range units {
if !unit.IsPrincipal() {
continue
}
instanceIds, err := state.ApplicationInstances(st, unit.ApplicationName())
if err != nil {
return nil, err
}
for _, instanceId := range instanceIds {
instanceIdSet.Add(string(instanceId))
}
}
instanceIds := make([]instance.Id, instanceIdSet.Size())
// Sort values to simplify testing.
for i, instanceId := range instanceIdSet.SortedValues() {
instanceIds[i] = instance.Id(instanceId)
}
return instanceIds, nil
} | [
"func",
"commonServiceInstances",
"(",
"st",
"*",
"state",
".",
"State",
",",
"m",
"*",
"state",
".",
"Machine",
")",
"(",
"[",
"]",
"instance",
".",
"Id",
",",
"error",
")",
"{",
"units",
",",
"err",
":=",
"m",
".",
"Units",
"(",
")",
"\n",
"if"... | // commonServiceInstances returns instances with
// services in common with the specified machine. | [
"commonServiceInstances",
"returns",
"instances",
"with",
"services",
"in",
"common",
"with",
"the",
"specified",
"machine",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L654-L678 |
4,582 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | DistributionGroupByMachineId | func (p *ProvisionerAPI) DistributionGroupByMachineId(args params.Entities) (params.StringsResults, error) {
result := params.StringsResults{
Results: make([]params.StringsResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return params.StringsResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
// If the machine is a controller, return
// controller instances. Otherwise, return
// instances with services in common with the machine
// being provisioned.
if machine.IsManager() {
result.Results[i].Result, err = controllerMachineIds(p.st, machine)
} else {
result.Results[i].Result, err = commonApplicationMachineId(p.st, machine)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (p *ProvisionerAPI) DistributionGroupByMachineId(args params.Entities) (params.StringsResults, error) {
result := params.StringsResults{
Results: make([]params.StringsResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return params.StringsResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
// If the machine is a controller, return
// controller instances. Otherwise, return
// instances with services in common with the machine
// being provisioned.
if machine.IsManager() {
result.Results[i].Result, err = controllerMachineIds(p.st, machine)
} else {
result.Results[i].Result, err = commonApplicationMachineId(p.st, machine)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"DistributionGroupByMachineId",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"StringsResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"StringsResults",
"{",
"Results",
":",
"ma... | // DistributionGroupByMachineId returns, for each given machine entity,
// a slice of machine.Ids that belong to the same distribution
// group as that machine. This information may be used to
// distribute instances for high availability. | [
"DistributionGroupByMachineId",
"returns",
"for",
"each",
"given",
"machine",
"entity",
"a",
"slice",
"of",
"machine",
".",
"Ids",
"that",
"belong",
"to",
"the",
"same",
"distribution",
"group",
"as",
"that",
"machine",
".",
"This",
"information",
"may",
"be",
... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L687-L716 |
4,583 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | controllerMachineIds | func controllerMachineIds(st *state.State, m *state.Machine) ([]string, error) {
info, err := st.ControllerInfo()
if err != nil {
return nil, err
}
result := set.NewStrings(info.MachineIds...)
result.Remove(m.Id())
return result.SortedValues(), nil
} | go | func controllerMachineIds(st *state.State, m *state.Machine) ([]string, error) {
info, err := st.ControllerInfo()
if err != nil {
return nil, err
}
result := set.NewStrings(info.MachineIds...)
result.Remove(m.Id())
return result.SortedValues(), nil
} | [
"func",
"controllerMachineIds",
"(",
"st",
"*",
"state",
".",
"State",
",",
"m",
"*",
"state",
".",
"Machine",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"info",
",",
"err",
":=",
"st",
".",
"ControllerInfo",
"(",
")",
"\n",
"if",
"err",... | // controllerMachineIds returns a slice of all other environ manager machine.Ids. | [
"controllerMachineIds",
"returns",
"a",
"slice",
"of",
"all",
"other",
"environ",
"manager",
"machine",
".",
"Ids",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L719-L727 |
4,584 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | commonApplicationMachineId | func commonApplicationMachineId(st *state.State, m *state.Machine) ([]string, error) {
applications := m.Principals()
var union set.Strings
for _, app := range applications {
machines, err := state.ApplicationMachines(st, app)
if err != nil {
return nil, err
}
union = union.Union(set.NewStrings(machines...))
}
union.Remove(m.Id())
return union.SortedValues(), nil
} | go | func commonApplicationMachineId(st *state.State, m *state.Machine) ([]string, error) {
applications := m.Principals()
var union set.Strings
for _, app := range applications {
machines, err := state.ApplicationMachines(st, app)
if err != nil {
return nil, err
}
union = union.Union(set.NewStrings(machines...))
}
union.Remove(m.Id())
return union.SortedValues(), nil
} | [
"func",
"commonApplicationMachineId",
"(",
"st",
"*",
"state",
".",
"State",
",",
"m",
"*",
"state",
".",
"Machine",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"applications",
":=",
"m",
".",
"Principals",
"(",
")",
"\n",
"var",
"union",
"... | // commonApplicationMachineId returns a slice of machine.Ids with
// applications in common with the specified machine. | [
"commonApplicationMachineId",
"returns",
"a",
"slice",
"of",
"machine",
".",
"Ids",
"with",
"applications",
"in",
"common",
"with",
"the",
"specified",
"machine",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L731-L743 |
4,585 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | Constraints | func (p *ProvisionerAPI) Constraints(args params.Entities) (params.ConstraintsResults, error) {
result := params.ConstraintsResults{
Results: make([]params.ConstraintsResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
var cons constraints.Value
cons, err = machine.Constraints()
if err == nil {
result.Results[i].Constraints = cons
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (p *ProvisionerAPI) Constraints(args params.Entities) (params.ConstraintsResults, error) {
result := params.ConstraintsResults{
Results: make([]params.ConstraintsResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
var cons constraints.Value
cons, err = machine.Constraints()
if err == nil {
result.Results[i].Constraints = cons
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"Constraints",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ConstraintsResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ConstraintsResults",
"{",
"Results",
":",
"make",
"(... | // Constraints returns the constraints for each given machine entity. | [
"Constraints",
"returns",
"the",
"constraints",
"for",
"each",
"given",
"machine",
"entity",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L746-L771 |
4,586 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | SetInstanceInfo | func (p *ProvisionerAPI) SetInstanceInfo(args params.InstancesInfo) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Machines)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
setInstanceInfo := func(arg params.InstanceInfo) error {
tag, err := names.ParseMachineTag(arg.Tag)
if err != nil {
return common.ErrPerm
}
machine, err := p.getMachine(canAccess, tag)
if err != nil {
return err
}
volumes, err := storagecommon.VolumesToState(arg.Volumes)
if err != nil {
return err
}
volumeAttachments, err := storagecommon.VolumeAttachmentInfosToState(arg.VolumeAttachments)
if err != nil {
return err
}
devicesArgs, devicesAddrs := networkingcommon.NetworkConfigsToStateArgs(arg.NetworkConfig)
err = machine.SetInstanceInfo(
arg.InstanceId, arg.DisplayName, arg.Nonce, arg.Characteristics,
devicesArgs, devicesAddrs,
volumes, volumeAttachments, arg.CharmProfiles,
)
if err != nil {
return errors.Annotatef(err, "cannot record provisioning info for %q", arg.InstanceId)
}
return nil
}
for i, arg := range args.Machines {
err := setInstanceInfo(arg)
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (p *ProvisionerAPI) SetInstanceInfo(args params.InstancesInfo) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Machines)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
setInstanceInfo := func(arg params.InstanceInfo) error {
tag, err := names.ParseMachineTag(arg.Tag)
if err != nil {
return common.ErrPerm
}
machine, err := p.getMachine(canAccess, tag)
if err != nil {
return err
}
volumes, err := storagecommon.VolumesToState(arg.Volumes)
if err != nil {
return err
}
volumeAttachments, err := storagecommon.VolumeAttachmentInfosToState(arg.VolumeAttachments)
if err != nil {
return err
}
devicesArgs, devicesAddrs := networkingcommon.NetworkConfigsToStateArgs(arg.NetworkConfig)
err = machine.SetInstanceInfo(
arg.InstanceId, arg.DisplayName, arg.Nonce, arg.Characteristics,
devicesArgs, devicesAddrs,
volumes, volumeAttachments, arg.CharmProfiles,
)
if err != nil {
return errors.Annotatef(err, "cannot record provisioning info for %q", arg.InstanceId)
}
return nil
}
for i, arg := range args.Machines {
err := setInstanceInfo(arg)
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"SetInstanceInfo",
"(",
"args",
"params",
".",
"InstancesInfo",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
"make",
"(",
... | // SetInstanceInfo sets the provider specific machine id, nonce,
// metadata and network info for each given machine. Once set, the
// instance id cannot be changed. | [
"SetInstanceInfo",
"sets",
"the",
"provider",
"specific",
"machine",
"id",
"nonce",
"metadata",
"and",
"network",
"info",
"for",
"each",
"given",
"machine",
".",
"Once",
"set",
"the",
"instance",
"id",
"cannot",
"be",
"changed",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L776-L819 |
4,587 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | WatchMachineErrorRetry | func (p *ProvisionerAPI) WatchMachineErrorRetry() (params.NotifyWatchResult, error) {
result := params.NotifyWatchResult{}
if !p.authorizer.AuthController() {
return result, common.ErrPerm
}
watch := newWatchMachineErrorRetry()
// Consume any initial event and forward it to the result.
if _, ok := <-watch.Changes(); ok {
result.NotifyWatcherId = p.resources.Register(watch)
} else {
return result, watcher.EnsureErr(watch)
}
return result, nil
} | go | func (p *ProvisionerAPI) WatchMachineErrorRetry() (params.NotifyWatchResult, error) {
result := params.NotifyWatchResult{}
if !p.authorizer.AuthController() {
return result, common.ErrPerm
}
watch := newWatchMachineErrorRetry()
// Consume any initial event and forward it to the result.
if _, ok := <-watch.Changes(); ok {
result.NotifyWatcherId = p.resources.Register(watch)
} else {
return result, watcher.EnsureErr(watch)
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"WatchMachineErrorRetry",
"(",
")",
"(",
"params",
".",
"NotifyWatchResult",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"NotifyWatchResult",
"{",
"}",
"\n",
"if",
"!",
"p",
".",
"authorizer",
".",
... | // WatchMachineErrorRetry returns a NotifyWatcher that notifies when
// the provisioner should retry provisioning machines with transient errors. | [
"WatchMachineErrorRetry",
"returns",
"a",
"NotifyWatcher",
"that",
"notifies",
"when",
"the",
"provisioner",
"should",
"retry",
"provisioning",
"machines",
"with",
"transient",
"errors",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L823-L836 |
4,588 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | ReleaseContainerAddresses | func (p *ProvisionerAPI) ReleaseContainerAddresses(args params.Entities) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
logger.Errorf("failed to get an authorisation function: %v", err)
return result, errors.Trace(err)
}
// Loop over the passed container tags.
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
logger.Warningf("failed to parse machine tag %q: %v", entity.Tag, err)
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
// The auth function (canAccess) checks that the machine is a
// top level machine (we filter those out next) or that the
// machine has the host as a parent.
guest, err := p.getMachine(canAccess, tag)
if err != nil {
logger.Warningf("failed to get machine %q: %v", tag, err)
result.Results[i].Error = common.ServerError(err)
continue
} else if !guest.IsContainer() {
err = errors.Errorf("cannot mark addresses for removal for %q: not a container", tag)
result.Results[i].Error = common.ServerError(err)
continue
}
// TODO(dimitern): Release those via the provider once we have
// Environ.ReleaseContainerAddresses. See LP bug http://pad.lv/1585878
err = guest.RemoveAllAddresses()
if err != nil {
logger.Warningf("failed to remove container %q addresses: %v", tag, err)
result.Results[i].Error = common.ServerError(err)
continue
}
}
return result, nil
} | go | func (p *ProvisionerAPI) ReleaseContainerAddresses(args params.Entities) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
logger.Errorf("failed to get an authorisation function: %v", err)
return result, errors.Trace(err)
}
// Loop over the passed container tags.
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
logger.Warningf("failed to parse machine tag %q: %v", entity.Tag, err)
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
// The auth function (canAccess) checks that the machine is a
// top level machine (we filter those out next) or that the
// machine has the host as a parent.
guest, err := p.getMachine(canAccess, tag)
if err != nil {
logger.Warningf("failed to get machine %q: %v", tag, err)
result.Results[i].Error = common.ServerError(err)
continue
} else if !guest.IsContainer() {
err = errors.Errorf("cannot mark addresses for removal for %q: not a container", tag)
result.Results[i].Error = common.ServerError(err)
continue
}
// TODO(dimitern): Release those via the provider once we have
// Environ.ReleaseContainerAddresses. See LP bug http://pad.lv/1585878
err = guest.RemoveAllAddresses()
if err != nil {
logger.Warningf("failed to remove container %q addresses: %v", tag, err)
result.Results[i].Error = common.ServerError(err)
continue
}
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"ReleaseContainerAddresses",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
"make",
... | // ReleaseContainerAddresses finds addresses allocated to a container and marks
// them as Dead, to be released and removed. It accepts container tags as
// arguments. | [
"ReleaseContainerAddresses",
"finds",
"addresses",
"allocated",
"to",
"a",
"container",
"and",
"marks",
"them",
"as",
"Dead",
"to",
"be",
"released",
"and",
"removed",
".",
"It",
"accepts",
"container",
"tags",
"as",
"arguments",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L853-L897 |
4,589 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | prepareContainerAccessEnvironment | func (p *ProvisionerAPI) prepareContainerAccessEnvironment() (environs.Environ, *state.Machine, common.AuthFunc, error) {
env, err := environs.GetEnviron(p.configGetter, environs.New)
if err != nil {
return nil, nil, nil, errors.Trace(err)
}
// TODO(jam): 2017-02-01 NetworkingEnvironFromModelConfig used to do this, but it doesn't feel good
if env.Config().Type() == "dummy" {
return nil, nil, nil, errors.NotSupportedf("dummy provider network config")
}
canAccess, err := p.getAuthFunc()
if err != nil {
return nil, nil, nil, errors.Annotate(err, "cannot authenticate request")
}
hostAuthTag := p.authorizer.GetAuthTag()
if hostAuthTag == nil {
return nil, nil, nil, errors.Errorf("authenticated entity tag is nil")
}
hostTag, err := names.ParseMachineTag(hostAuthTag.String())
if err != nil {
return nil, nil, nil, errors.Trace(err)
}
host, err := p.getMachine(canAccess, hostTag)
if err != nil {
return nil, nil, nil, errors.Trace(err)
}
return env, host, canAccess, nil
} | go | func (p *ProvisionerAPI) prepareContainerAccessEnvironment() (environs.Environ, *state.Machine, common.AuthFunc, error) {
env, err := environs.GetEnviron(p.configGetter, environs.New)
if err != nil {
return nil, nil, nil, errors.Trace(err)
}
// TODO(jam): 2017-02-01 NetworkingEnvironFromModelConfig used to do this, but it doesn't feel good
if env.Config().Type() == "dummy" {
return nil, nil, nil, errors.NotSupportedf("dummy provider network config")
}
canAccess, err := p.getAuthFunc()
if err != nil {
return nil, nil, nil, errors.Annotate(err, "cannot authenticate request")
}
hostAuthTag := p.authorizer.GetAuthTag()
if hostAuthTag == nil {
return nil, nil, nil, errors.Errorf("authenticated entity tag is nil")
}
hostTag, err := names.ParseMachineTag(hostAuthTag.String())
if err != nil {
return nil, nil, nil, errors.Trace(err)
}
host, err := p.getMachine(canAccess, hostTag)
if err != nil {
return nil, nil, nil, errors.Trace(err)
}
return env, host, canAccess, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"prepareContainerAccessEnvironment",
"(",
")",
"(",
"environs",
".",
"Environ",
",",
"*",
"state",
".",
"Machine",
",",
"common",
".",
"AuthFunc",
",",
"error",
")",
"{",
"env",
",",
"err",
":=",
"environs",
... | // prepareContainerAccessEnvironment retrieves the environment, host machine, and access
// for working with containers. | [
"prepareContainerAccessEnvironment",
"retrieves",
"the",
"environment",
"host",
"machine",
"and",
"access",
"for",
"working",
"with",
"containers",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L1158-L1185 |
4,590 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | HostChangesForContainers | func (p *ProvisionerAPI) HostChangesForContainers(args params.Entities) (params.HostNetworkChangeResults, error) {
ctx := &hostChangesContext{
result: params.HostNetworkChangeResults{
Results: make([]params.HostNetworkChange, len(args.Entities)),
},
}
if err := p.processEachContainer(args, ctx); err != nil {
return ctx.result, errors.Trace(err)
}
return ctx.result, nil
} | go | func (p *ProvisionerAPI) HostChangesForContainers(args params.Entities) (params.HostNetworkChangeResults, error) {
ctx := &hostChangesContext{
result: params.HostNetworkChangeResults{
Results: make([]params.HostNetworkChange, len(args.Entities)),
},
}
if err := p.processEachContainer(args, ctx); err != nil {
return ctx.result, errors.Trace(err)
}
return ctx.result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"HostChangesForContainers",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"HostNetworkChangeResults",
",",
"error",
")",
"{",
"ctx",
":=",
"&",
"hostChangesContext",
"{",
"result",
":",
"params",... | // HostChangesForContainers returns the set of changes that need to be done
// to the host machine to prepare it for the containers to be created.
// Pass in a list of the containers that you want the changes for. | [
"HostChangesForContainers",
"returns",
"the",
"set",
"of",
"changes",
"that",
"need",
"to",
"be",
"done",
"to",
"the",
"host",
"machine",
"to",
"prepare",
"it",
"for",
"the",
"containers",
"to",
"be",
"created",
".",
"Pass",
"in",
"a",
"list",
"of",
"the",... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L1230-L1240 |
4,591 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | SetError | func (ctx *containerProfileContext) SetError(idx int, err error) {
ctx.result.Results[idx].Error = common.ServerError(err)
} | go | func (ctx *containerProfileContext) SetError(idx int, err error) {
ctx.result.Results[idx].Error = common.ServerError(err)
} | [
"func",
"(",
"ctx",
"*",
"containerProfileContext",
")",
"SetError",
"(",
"idx",
"int",
",",
"err",
"error",
")",
"{",
"ctx",
".",
"result",
".",
"Results",
"[",
"idx",
"]",
".",
"Error",
"=",
"common",
".",
"ServerError",
"(",
"err",
")",
"\n",
"}"
... | // Implements perContainerHandler.SetError | [
"Implements",
"perContainerHandler",
".",
"SetError"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L1288-L1290 |
4,592 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | SetModificationStatus | func (p *ProvisionerAPI) SetModificationStatus(args params.SetStatus) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
logger.Errorf("failed to get an authorisation function: %v", err)
return result, errors.Trace(err)
}
for i, arg := range args.Entities {
err = p.setOneModificationStatus(canAccess, arg)
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | go | func (p *ProvisionerAPI) SetModificationStatus(args params.SetStatus) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
logger.Errorf("failed to get an authorisation function: %v", err)
return result, errors.Trace(err)
}
for i, arg := range args.Entities {
err = p.setOneModificationStatus(canAccess, arg)
result.Results[i].Error = common.ServerError(err)
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"SetModificationStatus",
"(",
"args",
"params",
".",
"SetStatus",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
"make",
"("... | // SetModificationStatus updates the instance whilst changes are occurring. This
// is different from SetStatus and SetInstanceStatus, by the fact this holds
// information about the ongoing changes that are happening to instances.
// Consider LXD Profile updates that can modify a instance, but may not cause
// the instance to be placed into a error state. This modification status
// serves the purpose of highlighting that to the operator.
// Only machine tags are accepted. | [
"SetModificationStatus",
"updates",
"the",
"instance",
"whilst",
"changes",
"are",
"occurring",
".",
"This",
"is",
"different",
"from",
"SetStatus",
"and",
"SetInstanceStatus",
"by",
"the",
"fact",
"this",
"holds",
"information",
"about",
"the",
"ongoing",
"changes"... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L1413-L1427 |
4,593 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | MarkMachinesForRemoval | func (p *ProvisionerAPI) MarkMachinesForRemoval(machines params.Entities) (params.ErrorResults, error) {
results := make([]params.ErrorResult, len(machines.Entities))
canAccess, err := p.getAuthFunc()
if err != nil {
logger.Errorf("failed to get an authorisation function: %v", err)
return params.ErrorResults{}, errors.Trace(err)
}
for i, machine := range machines.Entities {
results[i].Error = common.ServerError(p.markOneMachineForRemoval(machine.Tag, canAccess))
}
return params.ErrorResults{Results: results}, nil
} | go | func (p *ProvisionerAPI) MarkMachinesForRemoval(machines params.Entities) (params.ErrorResults, error) {
results := make([]params.ErrorResult, len(machines.Entities))
canAccess, err := p.getAuthFunc()
if err != nil {
logger.Errorf("failed to get an authorisation function: %v", err)
return params.ErrorResults{}, errors.Trace(err)
}
for i, machine := range machines.Entities {
results[i].Error = common.ServerError(p.markOneMachineForRemoval(machine.Tag, canAccess))
}
return params.ErrorResults{Results: results}, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPI",
")",
"MarkMachinesForRemoval",
"(",
"machines",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"results",
":=",
"make",
"(",
"[",
"]",
"params",
".",
"ErrorResult",
",",
... | // MarkMachinesForRemoval indicates that the specified machines are
// ready to have any provider-level resources cleaned up and then be
// removed. | [
"MarkMachinesForRemoval",
"indicates",
"that",
"the",
"specified",
"machines",
"are",
"ready",
"to",
"have",
"any",
"provider",
"-",
"level",
"resources",
"cleaned",
"up",
"and",
"then",
"be",
"removed",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L1462-L1473 |
4,594 | juju/juju | apiserver/facades/agent/provisioner/provisioner.go | RemoveUpgradeCharmProfileData | func (p *ProvisionerAPIV8) RemoveUpgradeCharmProfileData(args params.Entities) (params.ErrorResults, error) {
results := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
return results, nil
} | go | func (p *ProvisionerAPIV8) RemoveUpgradeCharmProfileData(args params.Entities) (params.ErrorResults, error) {
results := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
return results, nil
} | [
"func",
"(",
"p",
"*",
"ProvisionerAPIV8",
")",
"RemoveUpgradeCharmProfileData",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"ErrorResults",
",",
"error",
")",
"{",
"results",
":=",
"params",
".",
"ErrorResults",
"{",
"Results",
":",
"ma... | // RemoveUpgradeCharmProfileData completely removes the instance charm profile
// data for a machine, even if the machine is dead.
//
// Remove in juju 3. Upgrading existing charm profiles is now handled
// in the instance mutater worker. This is for compatibility only with
// older provisioners. | [
"RemoveUpgradeCharmProfileData",
"completely",
"removes",
"the",
"instance",
"charm",
"profile",
"data",
"for",
"a",
"machine",
"even",
"if",
"the",
"machine",
"is",
"dead",
".",
"Remove",
"in",
"juju",
"3",
".",
"Upgrading",
"existing",
"charm",
"profiles",
"is... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/provisioner.go#L1558-L1563 |
4,595 | juju/juju | caas/kubernetes/provider/dockerconfig.go | extractRegistryURL | func extractRegistryURL(imagePath string) (string, error) {
imageNamed, err := reference.ParseNormalizedNamed(imagePath)
if err != nil {
return "", errors.Annotate(err, "extracting registry from path")
}
return reference.Domain(imageNamed), nil
} | go | func extractRegistryURL(imagePath string) (string, error) {
imageNamed, err := reference.ParseNormalizedNamed(imagePath)
if err != nil {
return "", errors.Annotate(err, "extracting registry from path")
}
return reference.Domain(imageNamed), nil
} | [
"func",
"extractRegistryURL",
"(",
"imagePath",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"imageNamed",
",",
"err",
":=",
"reference",
".",
"ParseNormalizedNamed",
"(",
"imagePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\""... | // extractRegistryName returns the registry URL part of an images path | [
"extractRegistryName",
"returns",
"the",
"registry",
"URL",
"part",
"of",
"an",
"images",
"path"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/dockerconfig.go#L58-L64 |
4,596 | juju/juju | worker/uniter/relation/state.go | copy | func (s *State) copy() *State {
copy := &State{
RelationId: s.RelationId,
ChangedPending: s.ChangedPending,
}
if s.Members != nil {
copy.Members = map[string]int64{}
for m, v := range s.Members {
copy.Members[m] = v
}
}
return copy
} | go | func (s *State) copy() *State {
copy := &State{
RelationId: s.RelationId,
ChangedPending: s.ChangedPending,
}
if s.Members != nil {
copy.Members = map[string]int64{}
for m, v := range s.Members {
copy.Members[m] = v
}
}
return copy
} | [
"func",
"(",
"s",
"*",
"State",
")",
"copy",
"(",
")",
"*",
"State",
"{",
"copy",
":=",
"&",
"State",
"{",
"RelationId",
":",
"s",
".",
"RelationId",
",",
"ChangedPending",
":",
"s",
".",
"ChangedPending",
",",
"}",
"\n",
"if",
"s",
".",
"Members",... | // copy returns an independent copy of the state. | [
"copy",
"returns",
"an",
"independent",
"copy",
"of",
"the",
"state",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/uniter/relation/state.go#L38-L50 |
4,597 | juju/juju | worker/uniter/relation/state.go | Validate | func (s *State) Validate(hi hook.Info) (err error) {
defer errors.DeferredAnnotatef(&err, "inappropriate %q for %q", hi.Kind, hi.RemoteUnit)
if hi.RelationId != s.RelationId {
return fmt.Errorf("expected relation %d, got relation %d", s.RelationId, hi.RelationId)
}
if s.Members == nil {
return fmt.Errorf(`relation is broken and cannot be changed further`)
}
unit, kind := hi.RemoteUnit, hi.Kind
if kind == hooks.RelationBroken {
if len(s.Members) == 0 {
return nil
}
return fmt.Errorf(`cannot run "relation-broken" while units still present`)
}
if s.ChangedPending != "" {
if unit != s.ChangedPending || kind != hooks.RelationChanged {
return fmt.Errorf(`expected "relation-changed" for %q`, s.ChangedPending)
}
} else if _, joined := s.Members[unit]; joined && kind == hooks.RelationJoined {
return fmt.Errorf("unit already joined")
} else if !joined && kind != hooks.RelationJoined {
return fmt.Errorf("unit has not joined")
}
return nil
} | go | func (s *State) Validate(hi hook.Info) (err error) {
defer errors.DeferredAnnotatef(&err, "inappropriate %q for %q", hi.Kind, hi.RemoteUnit)
if hi.RelationId != s.RelationId {
return fmt.Errorf("expected relation %d, got relation %d", s.RelationId, hi.RelationId)
}
if s.Members == nil {
return fmt.Errorf(`relation is broken and cannot be changed further`)
}
unit, kind := hi.RemoteUnit, hi.Kind
if kind == hooks.RelationBroken {
if len(s.Members) == 0 {
return nil
}
return fmt.Errorf(`cannot run "relation-broken" while units still present`)
}
if s.ChangedPending != "" {
if unit != s.ChangedPending || kind != hooks.RelationChanged {
return fmt.Errorf(`expected "relation-changed" for %q`, s.ChangedPending)
}
} else if _, joined := s.Members[unit]; joined && kind == hooks.RelationJoined {
return fmt.Errorf("unit already joined")
} else if !joined && kind != hooks.RelationJoined {
return fmt.Errorf("unit has not joined")
}
return nil
} | [
"func",
"(",
"s",
"*",
"State",
")",
"Validate",
"(",
"hi",
"hook",
".",
"Info",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"errors",
".",
"DeferredAnnotatef",
"(",
"&",
"err",
",",
"\"",
"\"",
",",
"hi",
".",
"Kind",
",",
"hi",
".",
"RemoteUni... | // Validate returns an error if the supplied hook.Info does not represent
// a valid change to the relation state. Hooks must always be validated
// against the current state before they are run, to ensure that the system
// meets its guarantees about hook execution order. | [
"Validate",
"returns",
"an",
"error",
"if",
"the",
"supplied",
"hook",
".",
"Info",
"does",
"not",
"represent",
"a",
"valid",
"change",
"to",
"the",
"relation",
"state",
".",
"Hooks",
"must",
"always",
"be",
"validated",
"against",
"the",
"current",
"state",... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/uniter/relation/state.go#L56-L81 |
4,598 | juju/juju | worker/uniter/relation/state.go | ReadStateDir | func ReadStateDir(dirPath string, relationId int) (d *StateDir, err error) {
d = &StateDir{
filepath.Join(dirPath, strconv.Itoa(relationId)),
State{relationId, map[string]int64{}, ""},
}
defer errors.DeferredAnnotatef(&err, "cannot load relation state from %q", d.path)
if _, err := os.Stat(d.path); os.IsNotExist(err) {
return d, nil
} else if err != nil {
return nil, err
}
fis, err := ioutil.ReadDir(d.path)
if err != nil {
return nil, err
}
for _, fi := range fis {
// Entries with names ending in "-" followed by an integer must be
// files containing valid unit data; all other names are ignored.
name := fi.Name()
i := strings.LastIndex(name, "-")
if i == -1 {
continue
}
svcName := name[:i]
unitId := name[i+1:]
if _, err := strconv.Atoi(unitId); err != nil {
continue
}
unitName := svcName + "/" + unitId
var info diskInfo
if err = utils.ReadYaml(filepath.Join(d.path, name), &info); err != nil {
return nil, fmt.Errorf("invalid unit file %q: %v", name, err)
}
if info.ChangeVersion == nil {
return nil, fmt.Errorf(`invalid unit file %q: "changed-version" not set`, name)
}
d.state.Members[unitName] = *info.ChangeVersion
if info.ChangedPending {
if d.state.ChangedPending != "" {
return nil, fmt.Errorf("%q and %q both have pending changed hooks", d.state.ChangedPending, unitName)
}
d.state.ChangedPending = unitName
}
}
return d, nil
} | go | func ReadStateDir(dirPath string, relationId int) (d *StateDir, err error) {
d = &StateDir{
filepath.Join(dirPath, strconv.Itoa(relationId)),
State{relationId, map[string]int64{}, ""},
}
defer errors.DeferredAnnotatef(&err, "cannot load relation state from %q", d.path)
if _, err := os.Stat(d.path); os.IsNotExist(err) {
return d, nil
} else if err != nil {
return nil, err
}
fis, err := ioutil.ReadDir(d.path)
if err != nil {
return nil, err
}
for _, fi := range fis {
// Entries with names ending in "-" followed by an integer must be
// files containing valid unit data; all other names are ignored.
name := fi.Name()
i := strings.LastIndex(name, "-")
if i == -1 {
continue
}
svcName := name[:i]
unitId := name[i+1:]
if _, err := strconv.Atoi(unitId); err != nil {
continue
}
unitName := svcName + "/" + unitId
var info diskInfo
if err = utils.ReadYaml(filepath.Join(d.path, name), &info); err != nil {
return nil, fmt.Errorf("invalid unit file %q: %v", name, err)
}
if info.ChangeVersion == nil {
return nil, fmt.Errorf(`invalid unit file %q: "changed-version" not set`, name)
}
d.state.Members[unitName] = *info.ChangeVersion
if info.ChangedPending {
if d.state.ChangedPending != "" {
return nil, fmt.Errorf("%q and %q both have pending changed hooks", d.state.ChangedPending, unitName)
}
d.state.ChangedPending = unitName
}
}
return d, nil
} | [
"func",
"ReadStateDir",
"(",
"dirPath",
"string",
",",
"relationId",
"int",
")",
"(",
"d",
"*",
"StateDir",
",",
"err",
"error",
")",
"{",
"d",
"=",
"&",
"StateDir",
"{",
"filepath",
".",
"Join",
"(",
"dirPath",
",",
"strconv",
".",
"Itoa",
"(",
"rel... | // ReadStateDir loads a StateDir from the subdirectory of dirPath named
// for the supplied RelationId. If the directory does not exist, no error
// is returned, | [
"ReadStateDir",
"loads",
"a",
"StateDir",
"from",
"the",
"subdirectory",
"of",
"dirPath",
"named",
"for",
"the",
"supplied",
"RelationId",
".",
"If",
"the",
"directory",
"does",
"not",
"exist",
"no",
"error",
"is",
"returned"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/uniter/relation/state.go#L104-L149 |
4,599 | juju/juju | worker/uniter/relation/state.go | ReadAllStateDirs | func ReadAllStateDirs(dirPath string) (dirs map[int]*StateDir, err error) {
defer errors.DeferredAnnotatef(&err, "cannot load relations state from %q", dirPath)
if _, err := os.Stat(dirPath); os.IsNotExist(err) {
return nil, nil
} else if err != nil {
return nil, err
}
fis, err := ioutil.ReadDir(dirPath)
if err != nil {
return nil, err
}
dirs = map[int]*StateDir{}
for _, fi := range fis {
// Entries with integer names must be directories containing StateDir
// data; all other names will be ignored.
relationId, err := strconv.Atoi(fi.Name())
if err != nil {
// This doesn't look like a relation.
continue
}
dir, err := ReadStateDir(dirPath, relationId)
if err != nil {
return nil, err
}
dirs[relationId] = dir
}
return dirs, nil
} | go | func ReadAllStateDirs(dirPath string) (dirs map[int]*StateDir, err error) {
defer errors.DeferredAnnotatef(&err, "cannot load relations state from %q", dirPath)
if _, err := os.Stat(dirPath); os.IsNotExist(err) {
return nil, nil
} else if err != nil {
return nil, err
}
fis, err := ioutil.ReadDir(dirPath)
if err != nil {
return nil, err
}
dirs = map[int]*StateDir{}
for _, fi := range fis {
// Entries with integer names must be directories containing StateDir
// data; all other names will be ignored.
relationId, err := strconv.Atoi(fi.Name())
if err != nil {
// This doesn't look like a relation.
continue
}
dir, err := ReadStateDir(dirPath, relationId)
if err != nil {
return nil, err
}
dirs[relationId] = dir
}
return dirs, nil
} | [
"func",
"ReadAllStateDirs",
"(",
"dirPath",
"string",
")",
"(",
"dirs",
"map",
"[",
"int",
"]",
"*",
"StateDir",
",",
"err",
"error",
")",
"{",
"defer",
"errors",
".",
"DeferredAnnotatef",
"(",
"&",
"err",
",",
"\"",
"\"",
",",
"dirPath",
")",
"\n",
... | // ReadAllStateDirs loads and returns every StateDir persisted directly inside
// the supplied dirPath. If dirPath does not exist, no error is returned. | [
"ReadAllStateDirs",
"loads",
"and",
"returns",
"every",
"StateDir",
"persisted",
"directly",
"inside",
"the",
"supplied",
"dirPath",
".",
"If",
"dirPath",
"does",
"not",
"exist",
"no",
"error",
"is",
"returned",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/uniter/relation/state.go#L153-L180 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.