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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
3,800 | juju/juju | api/provisioner/machine.go | InstanceStatus | func (m *Machine) InstanceStatus() (status.Status, string, error) {
var results params.StatusResults
args := params.Entities{Entities: []params.Entity{
{Tag: m.tag.String()},
}}
err := m.st.facade.FacadeCall("InstanceStatus", args, &results)
if err != nil {
return "", "", err
}
if len(results.Results) != 1 {
return "", "", fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return "", "", result.Error
}
// TODO(perrito666) add status validation.
return status.Status(result.Status), result.Info, nil
} | go | func (m *Machine) InstanceStatus() (status.Status, string, error) {
var results params.StatusResults
args := params.Entities{Entities: []params.Entity{
{Tag: m.tag.String()},
}}
err := m.st.facade.FacadeCall("InstanceStatus", args, &results)
if err != nil {
return "", "", err
}
if len(results.Results) != 1 {
return "", "", fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return "", "", result.Error
}
// TODO(perrito666) add status validation.
return status.Status(result.Status), result.Info, nil
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"InstanceStatus",
"(",
")",
"(",
"status",
".",
"Status",
",",
"string",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"StatusResults",
"\n",
"args",
":=",
"params",
".",
"Entities",
"{",
"Entities",
":... | // InstanceStatus implements MachineProvisioner.InstanceStatus. | [
"InstanceStatus",
"implements",
"MachineProvisioner",
".",
"InstanceStatus",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/provisioner/machine.go#L215-L233 |
3,801 | juju/juju | api/provisioner/machine.go | SetModificationStatus | func (m *Machine) SetModificationStatus(status status.Status, info string, data map[string]interface{}) error {
var result params.ErrorResults
args := params.SetStatus{
Entities: []params.EntityStatusArgs{
{Tag: m.tag.String(), Status: status.String(), Info: info, Data: data},
},
}
err := m.st.facade.FacadeCall("SetModificationStatus", args, &result)
if err != nil {
return err
}
return result.OneError()
} | go | func (m *Machine) SetModificationStatus(status status.Status, info string, data map[string]interface{}) error {
var result params.ErrorResults
args := params.SetStatus{
Entities: []params.EntityStatusArgs{
{Tag: m.tag.String(), Status: status.String(), Info: info, Data: data},
},
}
err := m.st.facade.FacadeCall("SetModificationStatus", args, &result)
if err != nil {
return err
}
return result.OneError()
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"SetModificationStatus",
"(",
"status",
"status",
".",
"Status",
",",
"info",
"string",
",",
"data",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"var",
"result",
"params",
".",
"ErrorResults... | // SetModificationStatus implements MachineProvisioner.SetModificationStatus. | [
"SetModificationStatus",
"implements",
"MachineProvisioner",
".",
"SetModificationStatus",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/provisioner/machine.go#L272-L284 |
3,802 | juju/juju | api/provisioner/machine.go | AvailabilityZone | func (m *Machine) AvailabilityZone() (string, error) {
var results params.StringResults
args := params.Entities{
Entities: []params.Entity{{Tag: m.tag.String()}},
}
err := m.st.facade.FacadeCall("AvailabilityZone", args, &results)
if err != nil {
return "", err
}
if len(results.Results) != 1 {
return "", fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return "", result.Error
}
return result.Result, nil
} | go | func (m *Machine) AvailabilityZone() (string, error) {
var results params.StringResults
args := params.Entities{
Entities: []params.Entity{{Tag: m.tag.String()}},
}
err := m.st.facade.FacadeCall("AvailabilityZone", args, &results)
if err != nil {
return "", err
}
if len(results.Results) != 1 {
return "", fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return "", result.Error
}
return result.Result, nil
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"AvailabilityZone",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"StringResults",
"\n",
"args",
":=",
"params",
".",
"Entities",
"{",
"Entities",
":",
"[",
"]",
"params",
".",
... | // AvailabilityZone implements MachineProvisioner.AvailabilityZone. | [
"AvailabilityZone",
"implements",
"MachineProvisioner",
".",
"AvailabilityZone",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/provisioner/machine.go#L326-L343 |
3,803 | juju/juju | api/provisioner/machine.go | SetInstanceInfo | func (m *Machine) SetInstanceInfo(
id instance.Id, displayName string, nonce string, characteristics *instance.HardwareCharacteristics,
networkConfig []params.NetworkConfig, volumes []params.Volume,
volumeAttachments map[string]params.VolumeAttachmentInfo, charmProfiles []string,
) error {
var result params.ErrorResults
args := params.InstancesInfo{
Machines: []params.InstanceInfo{{
Tag: m.tag.String(),
InstanceId: id,
DisplayName: displayName,
Nonce: nonce,
Characteristics: characteristics,
Volumes: volumes,
VolumeAttachments: volumeAttachments,
NetworkConfig: networkConfig,
CharmProfiles: charmProfiles,
}},
}
err := m.st.facade.FacadeCall("SetInstanceInfo", args, &result)
if err != nil {
return err
}
return result.OneError()
} | go | func (m *Machine) SetInstanceInfo(
id instance.Id, displayName string, nonce string, characteristics *instance.HardwareCharacteristics,
networkConfig []params.NetworkConfig, volumes []params.Volume,
volumeAttachments map[string]params.VolumeAttachmentInfo, charmProfiles []string,
) error {
var result params.ErrorResults
args := params.InstancesInfo{
Machines: []params.InstanceInfo{{
Tag: m.tag.String(),
InstanceId: id,
DisplayName: displayName,
Nonce: nonce,
Characteristics: characteristics,
Volumes: volumes,
VolumeAttachments: volumeAttachments,
NetworkConfig: networkConfig,
CharmProfiles: charmProfiles,
}},
}
err := m.st.facade.FacadeCall("SetInstanceInfo", args, &result)
if err != nil {
return err
}
return result.OneError()
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"SetInstanceInfo",
"(",
"id",
"instance",
".",
"Id",
",",
"displayName",
"string",
",",
"nonce",
"string",
",",
"characteristics",
"*",
"instance",
".",
"HardwareCharacteristics",
",",
"networkConfig",
"[",
"]",
"params",... | // SetInstanceInfo implements MachineProvisioner.SetInstanceInfo. | [
"SetInstanceInfo",
"implements",
"MachineProvisioner",
".",
"SetInstanceInfo",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/provisioner/machine.go#L366-L390 |
3,804 | juju/juju | api/provisioner/machine.go | WatchContainers | func (m *Machine) WatchContainers(ctype instance.ContainerType) (watcher.StringsWatcher, error) {
if string(ctype) == "" {
return nil, fmt.Errorf("container type must be specified")
}
supported := false
for _, c := range instance.ContainerTypes {
if ctype == c {
supported = true
break
}
}
if !supported {
return nil, fmt.Errorf("unsupported container type %q", ctype)
}
var results params.StringsWatchResults
args := params.WatchContainers{
Params: []params.WatchContainer{
{MachineTag: m.tag.String(), ContainerType: string(ctype)},
},
}
err := m.st.facade.FacadeCall("WatchContainers", args, &results)
if err != nil {
return nil, err
}
if len(results.Results) != 1 {
return nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
w := apiwatcher.NewStringsWatcher(m.st.facade.RawAPICaller(), result)
return w, nil
} | go | func (m *Machine) WatchContainers(ctype instance.ContainerType) (watcher.StringsWatcher, error) {
if string(ctype) == "" {
return nil, fmt.Errorf("container type must be specified")
}
supported := false
for _, c := range instance.ContainerTypes {
if ctype == c {
supported = true
break
}
}
if !supported {
return nil, fmt.Errorf("unsupported container type %q", ctype)
}
var results params.StringsWatchResults
args := params.WatchContainers{
Params: []params.WatchContainer{
{MachineTag: m.tag.String(), ContainerType: string(ctype)},
},
}
err := m.st.facade.FacadeCall("WatchContainers", args, &results)
if err != nil {
return nil, err
}
if len(results.Results) != 1 {
return nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
w := apiwatcher.NewStringsWatcher(m.st.facade.RawAPICaller(), result)
return w, nil
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"WatchContainers",
"(",
"ctype",
"instance",
".",
"ContainerType",
")",
"(",
"watcher",
".",
"StringsWatcher",
",",
"error",
")",
"{",
"if",
"string",
"(",
"ctype",
")",
"==",
"\"",
"\"",
"{",
"return",
"nil",
","... | // WatchContainers implements MachineProvisioner.WatchContainers. | [
"WatchContainers",
"implements",
"MachineProvisioner",
".",
"WatchContainers",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/provisioner/machine.go#L451-L484 |
3,805 | juju/juju | api/provisioner/machine.go | WatchAllContainers | func (m *Machine) WatchAllContainers() (watcher.StringsWatcher, error) {
var results params.StringsWatchResults
args := params.WatchContainers{
Params: []params.WatchContainer{
{MachineTag: m.tag.String()},
},
}
err := m.st.facade.FacadeCall("WatchContainers", args, &results)
if err != nil {
return nil, err
}
if len(results.Results) != 1 {
return nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
w := apiwatcher.NewStringsWatcher(m.st.facade.RawAPICaller(), result)
return w, nil
} | go | func (m *Machine) WatchAllContainers() (watcher.StringsWatcher, error) {
var results params.StringsWatchResults
args := params.WatchContainers{
Params: []params.WatchContainer{
{MachineTag: m.tag.String()},
},
}
err := m.st.facade.FacadeCall("WatchContainers", args, &results)
if err != nil {
return nil, err
}
if len(results.Results) != 1 {
return nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
w := apiwatcher.NewStringsWatcher(m.st.facade.RawAPICaller(), result)
return w, nil
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"WatchAllContainers",
"(",
")",
"(",
"watcher",
".",
"StringsWatcher",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"StringsWatchResults",
"\n",
"args",
":=",
"params",
".",
"WatchContainers",
"{",
"Params",... | // WatchAllContainers implements MachineProvisioner.WatchAllContainers. | [
"WatchAllContainers",
"implements",
"MachineProvisioner",
".",
"WatchAllContainers",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/provisioner/machine.go#L487-L507 |
3,806 | juju/juju | api/provisioner/machine.go | SetSupportedContainers | func (m *Machine) SetSupportedContainers(containerTypes ...instance.ContainerType) error {
var results params.ErrorResults
args := params.MachineContainersParams{
Params: []params.MachineContainers{
{MachineTag: m.tag.String(), ContainerTypes: containerTypes},
},
}
err := m.st.facade.FacadeCall("SetSupportedContainers", args, &results)
if err != nil {
return err
}
if len(results.Results) != 1 {
return fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
apiError := results.Results[0].Error
if apiError != nil {
return apiError
}
return nil
} | go | func (m *Machine) SetSupportedContainers(containerTypes ...instance.ContainerType) error {
var results params.ErrorResults
args := params.MachineContainersParams{
Params: []params.MachineContainers{
{MachineTag: m.tag.String(), ContainerTypes: containerTypes},
},
}
err := m.st.facade.FacadeCall("SetSupportedContainers", args, &results)
if err != nil {
return err
}
if len(results.Results) != 1 {
return fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
apiError := results.Results[0].Error
if apiError != nil {
return apiError
}
return nil
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"SetSupportedContainers",
"(",
"containerTypes",
"...",
"instance",
".",
"ContainerType",
")",
"error",
"{",
"var",
"results",
"params",
".",
"ErrorResults",
"\n",
"args",
":=",
"params",
".",
"MachineContainersParams",
"{"... | // SetSupportedContainers implements MachineProvisioner.SetSupportedContainers. | [
"SetSupportedContainers",
"implements",
"MachineProvisioner",
".",
"SetSupportedContainers",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/provisioner/machine.go#L510-L529 |
3,807 | juju/juju | api/provisioner/machine.go | SupportedContainers | func (m *Machine) SupportedContainers() ([]instance.ContainerType, bool, error) {
var results params.MachineContainerResults
args := params.Entities{
Entities: []params.Entity{
{Tag: m.tag.String()},
},
}
err := m.st.facade.FacadeCall("SupportedContainers", args, &results)
if err != nil {
return nil, false, err
}
if len(results.Results) != 1 {
return nil, false, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
apiError := results.Results[0].Error
if apiError != nil {
return nil, false, apiError
}
result := results.Results[0]
return result.ContainerTypes, result.Determined, nil
} | go | func (m *Machine) SupportedContainers() ([]instance.ContainerType, bool, error) {
var results params.MachineContainerResults
args := params.Entities{
Entities: []params.Entity{
{Tag: m.tag.String()},
},
}
err := m.st.facade.FacadeCall("SupportedContainers", args, &results)
if err != nil {
return nil, false, err
}
if len(results.Results) != 1 {
return nil, false, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
apiError := results.Results[0].Error
if apiError != nil {
return nil, false, apiError
}
result := results.Results[0]
return result.ContainerTypes, result.Determined, nil
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"SupportedContainers",
"(",
")",
"(",
"[",
"]",
"instance",
".",
"ContainerType",
",",
"bool",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"MachineContainerResults",
"\n",
"args",
":=",
"params",
".",
"... | // SupportedContainers implements MachineProvisioner.SupportedContainers. | [
"SupportedContainers",
"implements",
"MachineProvisioner",
".",
"SupportedContainers",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/provisioner/machine.go#L537-L557 |
3,808 | juju/juju | api/provisioner/machine.go | SetCharmProfiles | func (m *Machine) SetCharmProfiles(profiles []string) error {
var results params.ErrorResults
args := params.SetProfileArgs{
Args: []params.SetProfileArg{
{
Entity: params.Entity{Tag: m.tag.String()},
Profiles: profiles,
},
},
}
err := m.st.facade.FacadeCall("SetCharmProfiles", args, &results)
if err != nil {
return err
}
if len(results.Results) != 1 {
return fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return result.Error
}
return nil
} | go | func (m *Machine) SetCharmProfiles(profiles []string) error {
var results params.ErrorResults
args := params.SetProfileArgs{
Args: []params.SetProfileArg{
{
Entity: params.Entity{Tag: m.tag.String()},
Profiles: profiles,
},
},
}
err := m.st.facade.FacadeCall("SetCharmProfiles", args, &results)
if err != nil {
return err
}
if len(results.Results) != 1 {
return fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return result.Error
}
return nil
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"SetCharmProfiles",
"(",
"profiles",
"[",
"]",
"string",
")",
"error",
"{",
"var",
"results",
"params",
".",
"ErrorResults",
"\n",
"args",
":=",
"params",
".",
"SetProfileArgs",
"{",
"Args",
":",
"[",
"]",
"params",... | // SetCharmProfiles implements MachineProvisioner.SetCharmProfiles. | [
"SetCharmProfiles",
"implements",
"MachineProvisioner",
".",
"SetCharmProfiles",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/provisioner/machine.go#L560-L582 |
3,809 | juju/juju | cmd/juju/romulus/agree/agree.go | Init | func (c *agreeCommand) Init(args []string) error {
if len(args) < 1 {
return errors.New("missing arguments")
}
for _, t := range args {
termId, err := charm.ParseTerm(t)
if err != nil {
return errors.Annotate(err, "invalid term format")
}
if termId.Revision == 0 {
return errors.Errorf("must specify a valid term revision %q", t)
}
c.terms = append(c.terms, term{owner: termId.Owner, name: termId.Name, revision: termId.Revision})
c.termIds = append(c.termIds, t)
}
if len(c.terms) == 0 {
return errors.New("must specify a valid term revision")
}
return c.CommandBase.Init([]string{})
} | go | func (c *agreeCommand) Init(args []string) error {
if len(args) < 1 {
return errors.New("missing arguments")
}
for _, t := range args {
termId, err := charm.ParseTerm(t)
if err != nil {
return errors.Annotate(err, "invalid term format")
}
if termId.Revision == 0 {
return errors.Errorf("must specify a valid term revision %q", t)
}
c.terms = append(c.terms, term{owner: termId.Owner, name: termId.Name, revision: termId.Revision})
c.termIds = append(c.termIds, t)
}
if len(c.terms) == 0 {
return errors.New("must specify a valid term revision")
}
return c.CommandBase.Init([]string{})
} | [
"func",
"(",
"c",
"*",
"agreeCommand",
")",
"Init",
"(",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"args",
")",
"<",
"1",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"t... | // Init read and verifies the arguments. | [
"Init",
"read",
"and",
"verifies",
"the",
"arguments",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/romulus/agree/agree.go#L87-L107 |
3,810 | juju/juju | state/leadership.go | LeadershipClaimer | func (st *State) LeadershipClaimer() leadership.Claimer {
return leadershipClaimer{
lazyLeaseClaimer{func() (lease.Claimer, error) {
manager := st.workers.leadershipManager()
return manager.Claimer(applicationLeadershipNamespace, st.modelUUID())
}},
}
} | go | func (st *State) LeadershipClaimer() leadership.Claimer {
return leadershipClaimer{
lazyLeaseClaimer{func() (lease.Claimer, error) {
manager := st.workers.leadershipManager()
return manager.Claimer(applicationLeadershipNamespace, st.modelUUID())
}},
}
} | [
"func",
"(",
"st",
"*",
"State",
")",
"LeadershipClaimer",
"(",
")",
"leadership",
".",
"Claimer",
"{",
"return",
"leadershipClaimer",
"{",
"lazyLeaseClaimer",
"{",
"func",
"(",
")",
"(",
"lease",
".",
"Claimer",
",",
"error",
")",
"{",
"manager",
":=",
... | // LeadershipClaimer returns a leadership.Claimer for units and applications in the
// state's model. | [
"LeadershipClaimer",
"returns",
"a",
"leadership",
".",
"Claimer",
"for",
"units",
"and",
"applications",
"in",
"the",
"state",
"s",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/leadership.go#L28-L35 |
3,811 | juju/juju | state/leadership.go | LeadershipChecker | func (st *State) LeadershipChecker() leadership.Checker {
return leadershipChecker{
lazyLeaseChecker{func() (lease.Checker, error) {
manager := st.workers.leadershipManager()
return manager.Checker(applicationLeadershipNamespace, st.modelUUID())
}},
}
} | go | func (st *State) LeadershipChecker() leadership.Checker {
return leadershipChecker{
lazyLeaseChecker{func() (lease.Checker, error) {
manager := st.workers.leadershipManager()
return manager.Checker(applicationLeadershipNamespace, st.modelUUID())
}},
}
} | [
"func",
"(",
"st",
"*",
"State",
")",
"LeadershipChecker",
"(",
")",
"leadership",
".",
"Checker",
"{",
"return",
"leadershipChecker",
"{",
"lazyLeaseChecker",
"{",
"func",
"(",
")",
"(",
"lease",
".",
"Checker",
",",
"error",
")",
"{",
"manager",
":=",
... | // LeadershipChecker returns a leadership.Checker for units and applications in the
// state's model. | [
"LeadershipChecker",
"returns",
"a",
"leadership",
".",
"Checker",
"for",
"units",
"and",
"applications",
"in",
"the",
"state",
"s",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/leadership.go#L39-L46 |
3,812 | juju/juju | state/leadership.go | buildTxnWithLeadership | func buildTxnWithLeadership(buildTxn jujutxn.TransactionSource, token leadership.Token) jujutxn.TransactionSource {
return func(attempt int) ([]txn.Op, error) {
var prereqs []txn.Op
if err := token.Check(attempt, &prereqs); err != nil {
return nil, errors.Annotatef(err, "prerequisites failed")
}
ops, err := buildTxn(attempt)
if err == jujutxn.ErrNoOperations {
return nil, jujutxn.ErrNoOperations
} else if err != nil {
return nil, errors.Trace(err)
}
return append(prereqs, ops...), nil
}
} | go | func buildTxnWithLeadership(buildTxn jujutxn.TransactionSource, token leadership.Token) jujutxn.TransactionSource {
return func(attempt int) ([]txn.Op, error) {
var prereqs []txn.Op
if err := token.Check(attempt, &prereqs); err != nil {
return nil, errors.Annotatef(err, "prerequisites failed")
}
ops, err := buildTxn(attempt)
if err == jujutxn.ErrNoOperations {
return nil, jujutxn.ErrNoOperations
} else if err != nil {
return nil, errors.Trace(err)
}
return append(prereqs, ops...), nil
}
} | [
"func",
"buildTxnWithLeadership",
"(",
"buildTxn",
"jujutxn",
".",
"TransactionSource",
",",
"token",
"leadership",
".",
"Token",
")",
"jujutxn",
".",
"TransactionSource",
"{",
"return",
"func",
"(",
"attempt",
"int",
")",
"(",
"[",
"]",
"txn",
".",
"Op",
",... | // buildTxnWithLeadership returns a transaction source that combines the supplied source
// with checks and asserts on the supplied token. | [
"buildTxnWithLeadership",
"returns",
"a",
"transaction",
"source",
"that",
"combines",
"the",
"supplied",
"source",
"with",
"checks",
"and",
"asserts",
"on",
"the",
"supplied",
"token",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/leadership.go#L50-L64 |
3,813 | juju/juju | state/logs.go | InitDbLogs | func InitDbLogs(session *mgo.Session, modelUUID string) error {
logsColl := session.DB(logsDB).C(logCollectionName(modelUUID))
for _, key := range logIndexes {
err := logsColl.EnsureIndex(mgo.Index{Key: key})
if err != nil {
return errors.Annotate(err, "cannot create index for logs collection")
}
}
return nil
} | go | func InitDbLogs(session *mgo.Session, modelUUID string) error {
logsColl := session.DB(logsDB).C(logCollectionName(modelUUID))
for _, key := range logIndexes {
err := logsColl.EnsureIndex(mgo.Index{Key: key})
if err != nil {
return errors.Annotate(err, "cannot create index for logs collection")
}
}
return nil
} | [
"func",
"InitDbLogs",
"(",
"session",
"*",
"mgo",
".",
"Session",
",",
"modelUUID",
"string",
")",
"error",
"{",
"logsColl",
":=",
"session",
".",
"DB",
"(",
"logsDB",
")",
".",
"C",
"(",
"logCollectionName",
"(",
"modelUUID",
")",
")",
"\n",
"for",
"_... | // InitDbLogs sets up the indexes for the logs collection. It should
// be called as state is opened. It is idempotent. | [
"InitDbLogs",
"sets",
"up",
"the",
"indexes",
"for",
"the",
"logs",
"collection",
".",
"It",
"should",
"be",
"called",
"as",
"state",
"is",
"opened",
".",
"It",
"is",
"idempotent",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L80-L89 |
3,814 | juju/juju | state/logs.go | NewLastSentLogTracker | func NewLastSentLogTracker(st ModelSessioner, modelUUID, sink string) *LastSentLogTracker {
session := st.MongoSession().Copy()
return &LastSentLogTracker{
id: fmt.Sprintf("%s#%s", modelUUID, sink),
model: modelUUID,
sink: sink,
session: session,
}
} | go | func NewLastSentLogTracker(st ModelSessioner, modelUUID, sink string) *LastSentLogTracker {
session := st.MongoSession().Copy()
return &LastSentLogTracker{
id: fmt.Sprintf("%s#%s", modelUUID, sink),
model: modelUUID,
sink: sink,
session: session,
}
} | [
"func",
"NewLastSentLogTracker",
"(",
"st",
"ModelSessioner",
",",
"modelUUID",
",",
"sink",
"string",
")",
"*",
"LastSentLogTracker",
"{",
"session",
":=",
"st",
".",
"MongoSession",
"(",
")",
".",
"Copy",
"(",
")",
"\n",
"return",
"&",
"LastSentLogTracker",
... | // NewLastSentLogTracker returns a new tracker that records and retrieves
// the timestamps of the most recent log records forwarded to the
// identified log sink for the current model. | [
"NewLastSentLogTracker",
"returns",
"a",
"new",
"tracker",
"that",
"records",
"and",
"retrieves",
"the",
"timestamps",
"of",
"the",
"most",
"recent",
"log",
"records",
"forwarded",
"to",
"the",
"identified",
"log",
"sink",
"for",
"the",
"current",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L144-L152 |
3,815 | juju/juju | state/logs.go | Set | func (logger *LastSentLogTracker) Set(recID, recTimestamp int64) error {
collection := logger.session.DB(logsDB).C(forwardedC)
_, err := collection.UpsertId(
logger.id,
lastSentDoc{
ID: logger.id,
ModelUUID: logger.model,
Sink: logger.sink,
RecordID: recID,
RecordTimestamp: recTimestamp,
},
)
return errors.Trace(err)
} | go | func (logger *LastSentLogTracker) Set(recID, recTimestamp int64) error {
collection := logger.session.DB(logsDB).C(forwardedC)
_, err := collection.UpsertId(
logger.id,
lastSentDoc{
ID: logger.id,
ModelUUID: logger.model,
Sink: logger.sink,
RecordID: recID,
RecordTimestamp: recTimestamp,
},
)
return errors.Trace(err)
} | [
"func",
"(",
"logger",
"*",
"LastSentLogTracker",
")",
"Set",
"(",
"recID",
",",
"recTimestamp",
"int64",
")",
"error",
"{",
"collection",
":=",
"logger",
".",
"session",
".",
"DB",
"(",
"logsDB",
")",
".",
"C",
"(",
"forwardedC",
")",
"\n",
"_",
",",
... | // Set records the timestamp. | [
"Set",
"records",
"the",
"timestamp",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L161-L174 |
3,816 | juju/juju | state/logs.go | Get | func (logger *LastSentLogTracker) Get() (int64, int64, error) {
collection := logger.session.DB(logsDB).C(forwardedC)
var doc lastSentDoc
err := collection.FindId(logger.id).One(&doc)
if err != nil {
if err == mgo.ErrNotFound {
return 0, 0, errors.Trace(ErrNeverForwarded)
}
return 0, 0, errors.Trace(err)
}
return doc.RecordID, doc.RecordTimestamp, nil
} | go | func (logger *LastSentLogTracker) Get() (int64, int64, error) {
collection := logger.session.DB(logsDB).C(forwardedC)
var doc lastSentDoc
err := collection.FindId(logger.id).One(&doc)
if err != nil {
if err == mgo.ErrNotFound {
return 0, 0, errors.Trace(ErrNeverForwarded)
}
return 0, 0, errors.Trace(err)
}
return doc.RecordID, doc.RecordTimestamp, nil
} | [
"func",
"(",
"logger",
"*",
"LastSentLogTracker",
")",
"Get",
"(",
")",
"(",
"int64",
",",
"int64",
",",
"error",
")",
"{",
"collection",
":=",
"logger",
".",
"session",
".",
"DB",
"(",
"logsDB",
")",
".",
"C",
"(",
"forwardedC",
")",
"\n",
"var",
... | // Get retrieves the id and timestamp. | [
"Get",
"retrieves",
"the",
"id",
"and",
"timestamp",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L177-L188 |
3,817 | juju/juju | state/logs.go | Log | func (logger *DbLogger) Log(records []LogRecord) error {
for _, r := range records {
if err := validateInputLogRecord(r); err != nil {
return errors.Annotate(err, "validating input log record")
}
}
bulk := logger.logsColl.Bulk()
for _, r := range records {
var versionString string
if r.Version != version.Zero {
versionString = r.Version.String()
}
bulk.Insert(&logDoc{
// TODO(axw) Use a controller-global int
// sequence for Id, so we can order by
// insertion.
Id: bson.NewObjectId(),
Time: r.Time.UnixNano(),
Entity: r.Entity.String(),
Version: versionString,
Module: r.Module,
Location: r.Location,
Level: int(r.Level),
Message: r.Message,
})
}
_, err := bulk.Run()
return errors.Annotatef(err, "inserting %d log record(s)", len(records))
} | go | func (logger *DbLogger) Log(records []LogRecord) error {
for _, r := range records {
if err := validateInputLogRecord(r); err != nil {
return errors.Annotate(err, "validating input log record")
}
}
bulk := logger.logsColl.Bulk()
for _, r := range records {
var versionString string
if r.Version != version.Zero {
versionString = r.Version.String()
}
bulk.Insert(&logDoc{
// TODO(axw) Use a controller-global int
// sequence for Id, so we can order by
// insertion.
Id: bson.NewObjectId(),
Time: r.Time.UnixNano(),
Entity: r.Entity.String(),
Version: versionString,
Module: r.Module,
Location: r.Location,
Level: int(r.Level),
Message: r.Message,
})
}
_, err := bulk.Run()
return errors.Annotatef(err, "inserting %d log record(s)", len(records))
} | [
"func",
"(",
"logger",
"*",
"DbLogger",
")",
"Log",
"(",
"records",
"[",
"]",
"LogRecord",
")",
"error",
"{",
"for",
"_",
",",
"r",
":=",
"range",
"records",
"{",
"if",
"err",
":=",
"validateInputLogRecord",
"(",
"r",
")",
";",
"err",
"!=",
"nil",
... | // Log writes log messages to the database. Log records
// are written to the database in bulk; callers should
// buffer log records to and call Log with a batch to
// minimise database writes.
//
// The ModelUUID and ID fields of records are ignored;
// DbLogger is scoped to a single model, and ID is
// controlled by the DbLogger code. | [
"Log",
"writes",
"log",
"messages",
"to",
"the",
"database",
".",
"Log",
"records",
"are",
"written",
"to",
"the",
"database",
"in",
"bulk",
";",
"callers",
"should",
"buffer",
"log",
"records",
"to",
"and",
"call",
"Log",
"with",
"a",
"batch",
"to",
"mi... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L230-L258 |
3,818 | juju/juju | state/logs.go | Close | func (logger *DbLogger) Close() {
if logger.logsColl != nil {
logger.logsColl.Database.Session.Close()
}
} | go | func (logger *DbLogger) Close() {
if logger.logsColl != nil {
logger.logsColl.Database.Session.Close()
}
} | [
"func",
"(",
"logger",
"*",
"DbLogger",
")",
"Close",
"(",
")",
"{",
"if",
"logger",
".",
"logsColl",
"!=",
"nil",
"{",
"logger",
".",
"logsColl",
".",
"Database",
".",
"Session",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Close cleans up resources used by the DbLogger instance. | [
"Close",
"cleans",
"up",
"resources",
"used",
"by",
"the",
"DbLogger",
"instance",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L268-L272 |
3,819 | juju/juju | state/logs.go | NewLogTailer | func NewLogTailer(st LogTailerState, params LogTailerParams) (LogTailer, error) {
session := st.MongoSession().Copy()
t := &logTailer{
modelUUID: st.ModelUUID(),
session: session,
logsColl: session.DB(logsDB).C(logCollectionName(st.ModelUUID())).With(session),
params: params,
logCh: make(chan *LogRecord),
recentIds: newRecentIdTracker(maxRecentLogIds),
maxInitialLines: maxInitialLines,
}
t.tomb.Go(func() error {
defer close(t.logCh)
defer session.Close()
err := t.loop()
return errors.Cause(err)
})
return t, nil
} | go | func NewLogTailer(st LogTailerState, params LogTailerParams) (LogTailer, error) {
session := st.MongoSession().Copy()
t := &logTailer{
modelUUID: st.ModelUUID(),
session: session,
logsColl: session.DB(logsDB).C(logCollectionName(st.ModelUUID())).With(session),
params: params,
logCh: make(chan *LogRecord),
recentIds: newRecentIdTracker(maxRecentLogIds),
maxInitialLines: maxInitialLines,
}
t.tomb.Go(func() error {
defer close(t.logCh)
defer session.Close()
err := t.loop()
return errors.Cause(err)
})
return t, nil
} | [
"func",
"NewLogTailer",
"(",
"st",
"LogTailerState",
",",
"params",
"LogTailerParams",
")",
"(",
"LogTailer",
",",
"error",
")",
"{",
"session",
":=",
"st",
".",
"MongoSession",
"(",
")",
".",
"Copy",
"(",
")",
"\n",
"t",
":=",
"&",
"logTailer",
"{",
"... | // NewLogTailer returns a LogTailer which filters according to the
// parameters given. | [
"NewLogTailer",
"returns",
"a",
"LogTailer",
"which",
"filters",
"according",
"to",
"the",
"parameters",
"given",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L362-L380 |
3,820 | juju/juju | state/logs.go | Stop | func (t *logTailer) Stop() error {
t.tomb.Kill(nil)
return t.tomb.Wait()
} | go | func (t *logTailer) Stop() error {
t.tomb.Kill(nil)
return t.tomb.Wait()
} | [
"func",
"(",
"t",
"*",
"logTailer",
")",
"Stop",
"(",
")",
"error",
"{",
"t",
".",
"tomb",
".",
"Kill",
"(",
"nil",
")",
"\n",
"return",
"t",
".",
"tomb",
".",
"Wait",
"(",
")",
"\n",
"}"
] | // Stop implements the LogTailer interface. | [
"Stop",
"implements",
"the",
"LogTailer",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L406-L409 |
3,821 | juju/juju | state/logs.go | initLogsSession | func initLogsSession(st ModelSessioner) (*mgo.Session, *mgo.Collection) {
session, db := initLogsSessionDB(st)
return session, db.C(logCollectionName(st.ModelUUID()))
} | go | func initLogsSession(st ModelSessioner) (*mgo.Session, *mgo.Collection) {
session, db := initLogsSessionDB(st)
return session, db.C(logCollectionName(st.ModelUUID()))
} | [
"func",
"initLogsSession",
"(",
"st",
"ModelSessioner",
")",
"(",
"*",
"mgo",
".",
"Session",
",",
"*",
"mgo",
".",
"Collection",
")",
"{",
"session",
",",
"db",
":=",
"initLogsSessionDB",
"(",
"st",
")",
"\n",
"return",
"session",
",",
"db",
".",
"C",... | // initLogsSession creates a new session suitable for logging updates,
// returning the session and a logs mgo.Collection connected to that
// session. | [
"initLogsSession",
"creates",
"a",
"new",
"session",
"suitable",
"for",
"logging",
"updates",
"returning",
"the",
"session",
"and",
"a",
"logs",
"mgo",
".",
"Collection",
"connected",
"to",
"that",
"session",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L881-L884 |
3,822 | juju/juju | state/logs.go | getCollectionTotalMB | func getCollectionTotalMB(colls map[string]*mgo.Collection) (int, error) {
total := 0
for _, coll := range colls {
size, err := getCollectionMB(coll)
if err != nil {
return 0, errors.Trace(err)
}
total += size
}
return total, nil
} | go | func getCollectionTotalMB(colls map[string]*mgo.Collection) (int, error) {
total := 0
for _, coll := range colls {
size, err := getCollectionMB(coll)
if err != nil {
return 0, errors.Trace(err)
}
total += size
}
return total, nil
} | [
"func",
"getCollectionTotalMB",
"(",
"colls",
"map",
"[",
"string",
"]",
"*",
"mgo",
".",
"Collection",
")",
"(",
"int",
",",
"error",
")",
"{",
"total",
":=",
"0",
"\n",
"for",
"_",
",",
"coll",
":=",
"range",
"colls",
"{",
"size",
",",
"err",
":=... | // getCollectionTotalMB returns the total size of the log collections
// passed. | [
"getCollectionTotalMB",
"returns",
"the",
"total",
"size",
"of",
"the",
"log",
"collections",
"passed",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L931-L941 |
3,823 | juju/juju | state/logs.go | getLogCollections | func getLogCollections(db *mgo.Database) (map[string]*mgo.Collection, error) {
result := make(map[string]*mgo.Collection)
names, err := db.CollectionNames()
if err != nil {
return nil, errors.Trace(err)
}
for _, name := range names {
if !strings.HasPrefix(name, logsCPrefix) {
continue
}
uuid := name[len(logsCPrefix):]
result[uuid] = db.C(name)
}
return result, nil
} | go | func getLogCollections(db *mgo.Database) (map[string]*mgo.Collection, error) {
result := make(map[string]*mgo.Collection)
names, err := db.CollectionNames()
if err != nil {
return nil, errors.Trace(err)
}
for _, name := range names {
if !strings.HasPrefix(name, logsCPrefix) {
continue
}
uuid := name[len(logsCPrefix):]
result[uuid] = db.C(name)
}
return result, nil
} | [
"func",
"getLogCollections",
"(",
"db",
"*",
"mgo",
".",
"Database",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"mgo",
".",
"Collection",
",",
"error",
")",
"{",
"result",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"mgo",
".",
"Collection",
... | // getLogCollections returns all of the log collections in the DB by
// model UUID. | [
"getLogCollections",
"returns",
"all",
"of",
"the",
"log",
"collections",
"in",
"the",
"DB",
"by",
"model",
"UUID",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L945-L959 |
3,824 | juju/juju | state/logs.go | findModelWithMostLogs | func findModelWithMostLogs(colls map[string]*mgo.Collection) (string, int, error) {
var maxModelUUID string
var maxCount int
for modelUUID, coll := range colls {
count, err := getRowCountForCollection(coll)
if err != nil {
return "", -1, errors.Trace(err)
}
if count > maxCount {
maxModelUUID = modelUUID
maxCount = count
}
}
return maxModelUUID, maxCount, nil
} | go | func findModelWithMostLogs(colls map[string]*mgo.Collection) (string, int, error) {
var maxModelUUID string
var maxCount int
for modelUUID, coll := range colls {
count, err := getRowCountForCollection(coll)
if err != nil {
return "", -1, errors.Trace(err)
}
if count > maxCount {
maxModelUUID = modelUUID
maxCount = count
}
}
return maxModelUUID, maxCount, nil
} | [
"func",
"findModelWithMostLogs",
"(",
"colls",
"map",
"[",
"string",
"]",
"*",
"mgo",
".",
"Collection",
")",
"(",
"string",
",",
"int",
",",
"error",
")",
"{",
"var",
"maxModelUUID",
"string",
"\n",
"var",
"maxCount",
"int",
"\n",
"for",
"modelUUID",
",... | // findModelWithMostLogs returns the modelUUID and row count for the
// collection with the most logs in the logs DB. | [
"findModelWithMostLogs",
"returns",
"the",
"modelUUID",
"and",
"row",
"count",
"for",
"the",
"collection",
"with",
"the",
"most",
"logs",
"in",
"the",
"logs",
"DB",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L963-L977 |
3,825 | juju/juju | state/logs.go | getRowCountForCollection | func getRowCountForCollection(coll *mgo.Collection) (int, error) {
count, err := coll.Count()
if err != nil {
return -1, errors.Annotate(err, "failed to get log count")
}
return count, nil
} | go | func getRowCountForCollection(coll *mgo.Collection) (int, error) {
count, err := coll.Count()
if err != nil {
return -1, errors.Annotate(err, "failed to get log count")
}
return count, nil
} | [
"func",
"getRowCountForCollection",
"(",
"coll",
"*",
"mgo",
".",
"Collection",
")",
"(",
"int",
",",
"error",
")",
"{",
"count",
",",
"err",
":=",
"coll",
".",
"Count",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"error... | // getRowCountForCollection returns the number of log records stored for a
// given model log collection. | [
"getRowCountForCollection",
"returns",
"the",
"number",
"of",
"log",
"records",
"stored",
"for",
"a",
"given",
"model",
"log",
"collection",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/logs.go#L981-L987 |
3,826 | juju/juju | provider/openstack/legacy_firewaller.go | SetUpGroups | func (c *legacyNovaFirewaller) SetUpGroups(ctx context.ProviderCallContext, controllerUUID, machineId string, apiPort int) ([]string, error) {
jujuGroup, err := c.setUpGlobalGroup(ctx, c.jujuGroupName(controllerUUID), apiPort)
if err != nil {
return nil, errors.Trace(err)
}
var machineGroup nova.SecurityGroup
switch c.environ.Config().FirewallMode() {
case config.FwInstance:
machineGroup, err = c.ensureGroup(ctx, c.machineGroupName(controllerUUID, machineId), nil)
case config.FwGlobal:
machineGroup, err = c.ensureGroup(ctx, c.globalGroupName(controllerUUID), nil)
}
if err != nil {
return nil, errors.Trace(err)
}
groupNames := []string{jujuGroup.Name, machineGroup.Name}
if c.environ.ecfg().useDefaultSecurityGroup() {
groupNames = append(groupNames, "default")
}
return groupNames, nil
} | go | func (c *legacyNovaFirewaller) SetUpGroups(ctx context.ProviderCallContext, controllerUUID, machineId string, apiPort int) ([]string, error) {
jujuGroup, err := c.setUpGlobalGroup(ctx, c.jujuGroupName(controllerUUID), apiPort)
if err != nil {
return nil, errors.Trace(err)
}
var machineGroup nova.SecurityGroup
switch c.environ.Config().FirewallMode() {
case config.FwInstance:
machineGroup, err = c.ensureGroup(ctx, c.machineGroupName(controllerUUID, machineId), nil)
case config.FwGlobal:
machineGroup, err = c.ensureGroup(ctx, c.globalGroupName(controllerUUID), nil)
}
if err != nil {
return nil, errors.Trace(err)
}
groupNames := []string{jujuGroup.Name, machineGroup.Name}
if c.environ.ecfg().useDefaultSecurityGroup() {
groupNames = append(groupNames, "default")
}
return groupNames, nil
} | [
"func",
"(",
"c",
"*",
"legacyNovaFirewaller",
")",
"SetUpGroups",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"controllerUUID",
",",
"machineId",
"string",
",",
"apiPort",
"int",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"jujuGroup",... | // SetUpGroups creates the security groups for the new machine, and
// returns them.
//
// Instances are tagged with a group so they can be distinguished from
// other instances that might be running on the same OpenStack account.
// In addition, a specific machine security group is created for each
// machine, so that its firewall rules can be configured per machine. | [
"SetUpGroups",
"creates",
"the",
"security",
"groups",
"for",
"the",
"new",
"machine",
"and",
"returns",
"them",
".",
"Instances",
"are",
"tagged",
"with",
"a",
"group",
"so",
"they",
"can",
"be",
"distinguished",
"from",
"other",
"instances",
"that",
"might",... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/openstack/legacy_firewaller.go#L35-L55 |
3,827 | juju/juju | provider/openstack/legacy_firewaller.go | ensureGroup | func (c *legacyNovaFirewaller) ensureGroup(ctx context.ProviderCallContext, name string, rules []nova.RuleInfo) (nova.SecurityGroup, error) {
novaClient := c.environ.nova()
// First attempt to look up an existing group by name.
group, err := novaClient.SecurityGroupByName(name)
if err == nil {
common.HandleCredentialError(IsAuthorisationFailure, err, ctx)
// Group exists, so assume it is correctly set up and return it.
// TODO(jam): 2013-09-18 http://pad.lv/121795
// We really should verify the group is set up correctly,
// because deleting and re-creating environments can get us bad
// groups (especially if they were set up under Python)
return *group, nil
}
// Doesn't exist, so try and create it.
group, err = novaClient.CreateSecurityGroup(name, "juju group")
if err != nil {
if !gooseerrors.IsDuplicateValue(err) {
return legacyZeroGroup, err
} else {
// We just tried to create a duplicate group, so load the existing group.
group, err = novaClient.SecurityGroupByName(name)
if err != nil {
common.HandleCredentialError(IsAuthorisationFailure, err, ctx)
return legacyZeroGroup, err
}
return *group, nil
}
}
// The new group is created so now add the rules.
group.Rules = make([]nova.SecurityGroupRule, len(rules))
for i, rule := range rules {
rule.ParentGroupId = group.Id
if rule.Cidr == "" {
// http://pad.lv/1226996 Rules that don't have a CIDR
// are meant to apply only to this group. If you don't
// supply CIDR or GroupId then openstack assumes you
// mean CIDR=0.0.0.0/0
rule.GroupId = &group.Id
}
groupRule, err := novaClient.CreateSecurityGroupRule(rule)
if err != nil && !gooseerrors.IsDuplicateValue(err) {
common.HandleCredentialError(IsAuthorisationFailure, err, ctx)
return legacyZeroGroup, err
}
group.Rules[i] = *groupRule
}
return *group, nil
} | go | func (c *legacyNovaFirewaller) ensureGroup(ctx context.ProviderCallContext, name string, rules []nova.RuleInfo) (nova.SecurityGroup, error) {
novaClient := c.environ.nova()
// First attempt to look up an existing group by name.
group, err := novaClient.SecurityGroupByName(name)
if err == nil {
common.HandleCredentialError(IsAuthorisationFailure, err, ctx)
// Group exists, so assume it is correctly set up and return it.
// TODO(jam): 2013-09-18 http://pad.lv/121795
// We really should verify the group is set up correctly,
// because deleting and re-creating environments can get us bad
// groups (especially if they were set up under Python)
return *group, nil
}
// Doesn't exist, so try and create it.
group, err = novaClient.CreateSecurityGroup(name, "juju group")
if err != nil {
if !gooseerrors.IsDuplicateValue(err) {
return legacyZeroGroup, err
} else {
// We just tried to create a duplicate group, so load the existing group.
group, err = novaClient.SecurityGroupByName(name)
if err != nil {
common.HandleCredentialError(IsAuthorisationFailure, err, ctx)
return legacyZeroGroup, err
}
return *group, nil
}
}
// The new group is created so now add the rules.
group.Rules = make([]nova.SecurityGroupRule, len(rules))
for i, rule := range rules {
rule.ParentGroupId = group.Id
if rule.Cidr == "" {
// http://pad.lv/1226996 Rules that don't have a CIDR
// are meant to apply only to this group. If you don't
// supply CIDR or GroupId then openstack assumes you
// mean CIDR=0.0.0.0/0
rule.GroupId = &group.Id
}
groupRule, err := novaClient.CreateSecurityGroupRule(rule)
if err != nil && !gooseerrors.IsDuplicateValue(err) {
common.HandleCredentialError(IsAuthorisationFailure, err, ctx)
return legacyZeroGroup, err
}
group.Rules[i] = *groupRule
}
return *group, nil
} | [
"func",
"(",
"c",
"*",
"legacyNovaFirewaller",
")",
"ensureGroup",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"name",
"string",
",",
"rules",
"[",
"]",
"nova",
".",
"RuleInfo",
")",
"(",
"nova",
".",
"SecurityGroup",
",",
"error",
")",
"{",
... | // ensureGroup returns the security group with name and perms.
// If a group with name does not exist, one will be created.
// If it exists, its permissions are set to perms. | [
"ensureGroup",
"returns",
"the",
"security",
"group",
"with",
"name",
"and",
"perms",
".",
"If",
"a",
"group",
"with",
"name",
"does",
"not",
"exist",
"one",
"will",
"be",
"created",
".",
"If",
"it",
"exists",
"its",
"permissions",
"are",
"set",
"to",
"p... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/openstack/legacy_firewaller.go#L96-L143 |
3,828 | juju/juju | provider/openstack/legacy_firewaller.go | DeleteAllModelGroups | func (c *legacyNovaFirewaller) DeleteAllModelGroups(ctx context.ProviderCallContext) error {
return deleteSecurityGroupsMatchingName(ctx, c.deleteSecurityGroups, c.jujuGroupRegexp())
} | go | func (c *legacyNovaFirewaller) DeleteAllModelGroups(ctx context.ProviderCallContext) error {
return deleteSecurityGroupsMatchingName(ctx, c.deleteSecurityGroups, c.jujuGroupRegexp())
} | [
"func",
"(",
"c",
"*",
"legacyNovaFirewaller",
")",
"DeleteAllModelGroups",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
")",
"error",
"{",
"return",
"deleteSecurityGroupsMatchingName",
"(",
"ctx",
",",
"c",
".",
"deleteSecurityGroups",
",",
"c",
".",
"jujuG... | // DeleteAllModelGroups implements Firewaller interface. | [
"DeleteAllModelGroups",
"implements",
"Firewaller",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/openstack/legacy_firewaller.go#L171-L173 |
3,829 | juju/juju | provider/openstack/legacy_firewaller.go | DeleteGroups | func (c *legacyNovaFirewaller) DeleteGroups(ctx context.ProviderCallContext, names ...string) error {
return deleteSecurityGroupsOneOfNames(ctx, c.deleteSecurityGroups, names...)
} | go | func (c *legacyNovaFirewaller) DeleteGroups(ctx context.ProviderCallContext, names ...string) error {
return deleteSecurityGroupsOneOfNames(ctx, c.deleteSecurityGroups, names...)
} | [
"func",
"(",
"c",
"*",
"legacyNovaFirewaller",
")",
"DeleteGroups",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"names",
"...",
"string",
")",
"error",
"{",
"return",
"deleteSecurityGroupsOneOfNames",
"(",
"ctx",
",",
"c",
".",
"deleteSecurityGroups",
... | // DeleteGroups implements Firewaller interface. | [
"DeleteGroups",
"implements",
"Firewaller",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/openstack/legacy_firewaller.go#L176-L178 |
3,830 | juju/juju | provider/openstack/legacy_firewaller.go | legacyRuleMatchesPortRange | func legacyRuleMatchesPortRange(rule nova.SecurityGroupRule, portRange network.IngressRule) bool {
if rule.IPProtocol == nil || rule.FromPort == nil || rule.ToPort == nil {
return false
}
return *rule.IPProtocol == portRange.Protocol &&
*rule.FromPort == portRange.FromPort &&
*rule.ToPort == portRange.ToPort
} | go | func legacyRuleMatchesPortRange(rule nova.SecurityGroupRule, portRange network.IngressRule) bool {
if rule.IPProtocol == nil || rule.FromPort == nil || rule.ToPort == nil {
return false
}
return *rule.IPProtocol == portRange.Protocol &&
*rule.FromPort == portRange.FromPort &&
*rule.ToPort == portRange.ToPort
} | [
"func",
"legacyRuleMatchesPortRange",
"(",
"rule",
"nova",
".",
"SecurityGroupRule",
",",
"portRange",
"network",
".",
"IngressRule",
")",
"bool",
"{",
"if",
"rule",
".",
"IPProtocol",
"==",
"nil",
"||",
"rule",
".",
"FromPort",
"==",
"nil",
"||",
"rule",
".... | // ruleMatchesPortRange checks if supplied nova security group rule matches the port range | [
"ruleMatchesPortRange",
"checks",
"if",
"supplied",
"nova",
"security",
"group",
"rule",
"matches",
"the",
"port",
"range"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/openstack/legacy_firewaller.go#L310-L317 |
3,831 | juju/juju | apiserver/facades/client/backups/list.go | List | func (a *API) List(args params.BackupsListArgs) (params.BackupsListResult, error) {
var result params.BackupsListResult
backups, closer := newBackups(a.backend)
defer closer.Close()
metaList, err := backups.List()
if err != nil {
return result, errors.Trace(err)
}
result.List = make([]params.BackupsMetadataResult, len(metaList))
for i, meta := range metaList {
result.List[i] = CreateResult(meta, "")
}
return result, nil
} | go | func (a *API) List(args params.BackupsListArgs) (params.BackupsListResult, error) {
var result params.BackupsListResult
backups, closer := newBackups(a.backend)
defer closer.Close()
metaList, err := backups.List()
if err != nil {
return result, errors.Trace(err)
}
result.List = make([]params.BackupsMetadataResult, len(metaList))
for i, meta := range metaList {
result.List[i] = CreateResult(meta, "")
}
return result, nil
} | [
"func",
"(",
"a",
"*",
"API",
")",
"List",
"(",
"args",
"params",
".",
"BackupsListArgs",
")",
"(",
"params",
".",
"BackupsListResult",
",",
"error",
")",
"{",
"var",
"result",
"params",
".",
"BackupsListResult",
"\n\n",
"backups",
",",
"closer",
":=",
"... | // List provides the implementation of the API method. | [
"List",
"provides",
"the",
"implementation",
"of",
"the",
"API",
"method",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/client/backups/list.go#L13-L30 |
3,832 | juju/juju | api/keyupdater/authorisedkeys.go | AuthorisedKeys | func (st *State) AuthorisedKeys(tag names.MachineTag) ([]string, error) {
var results params.StringsResults
args := params.Entities{
Entities: []params.Entity{{Tag: tag.String()}},
}
err := st.facade.FacadeCall("AuthorisedKeys", args, &results)
if err != nil {
// TODO: Not directly tested
return nil, err
}
if len(results.Results) != 1 {
// TODO: Not directly tested
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if err := result.Error; err != nil {
return nil, err
}
return result.Result, nil
} | go | func (st *State) AuthorisedKeys(tag names.MachineTag) ([]string, error) {
var results params.StringsResults
args := params.Entities{
Entities: []params.Entity{{Tag: tag.String()}},
}
err := st.facade.FacadeCall("AuthorisedKeys", args, &results)
if err != nil {
// TODO: Not directly tested
return nil, err
}
if len(results.Results) != 1 {
// TODO: Not directly tested
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if err := result.Error; err != nil {
return nil, err
}
return result.Result, nil
} | [
"func",
"(",
"st",
"*",
"State",
")",
"AuthorisedKeys",
"(",
"tag",
"names",
".",
"MachineTag",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"StringsResults",
"\n",
"args",
":=",
"params",
".",
"Entities",
"{",... | // AuthorisedKeys returns the authorised ssh keys for the machine specified by machineTag. | [
"AuthorisedKeys",
"returns",
"the",
"authorised",
"ssh",
"keys",
"for",
"the",
"machine",
"specified",
"by",
"machineTag",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/keyupdater/authorisedkeys.go#L27-L46 |
3,833 | juju/juju | api/keyupdater/authorisedkeys.go | WatchAuthorisedKeys | func (st *State) WatchAuthorisedKeys(tag names.MachineTag) (watcher.NotifyWatcher, error) {
var results params.NotifyWatchResults
args := params.Entities{
Entities: []params.Entity{{Tag: tag.String()}},
}
err := st.facade.FacadeCall("WatchAuthorisedKeys", args, &results)
if err != nil {
// TODO: Not directly tested
return nil, err
}
if len(results.Results) != 1 {
// TODO: Not directly tested
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
// TODO: Not directly tested
return nil, result.Error
}
w := apiwatcher.NewNotifyWatcher(st.facade.RawAPICaller(), result)
return w, nil
} | go | func (st *State) WatchAuthorisedKeys(tag names.MachineTag) (watcher.NotifyWatcher, error) {
var results params.NotifyWatchResults
args := params.Entities{
Entities: []params.Entity{{Tag: tag.String()}},
}
err := st.facade.FacadeCall("WatchAuthorisedKeys", args, &results)
if err != nil {
// TODO: Not directly tested
return nil, err
}
if len(results.Results) != 1 {
// TODO: Not directly tested
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
// TODO: Not directly tested
return nil, result.Error
}
w := apiwatcher.NewNotifyWatcher(st.facade.RawAPICaller(), result)
return w, nil
} | [
"func",
"(",
"st",
"*",
"State",
")",
"WatchAuthorisedKeys",
"(",
"tag",
"names",
".",
"MachineTag",
")",
"(",
"watcher",
".",
"NotifyWatcher",
",",
"error",
")",
"{",
"var",
"results",
"params",
".",
"NotifyWatchResults",
"\n",
"args",
":=",
"params",
"."... | // WatchAuthorisedKeys returns a notify watcher that looks for changes in the
// authorised ssh keys for the machine specified by machineTag. | [
"WatchAuthorisedKeys",
"returns",
"a",
"notify",
"watcher",
"that",
"looks",
"for",
"changes",
"in",
"the",
"authorised",
"ssh",
"keys",
"for",
"the",
"machine",
"specified",
"by",
"machineTag",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/keyupdater/authorisedkeys.go#L50-L71 |
3,834 | juju/juju | state/policy.go | precheckInstance | func (st *State) precheckInstance(
series string,
cons constraints.Value,
placement string,
volumeAttachments []storage.VolumeAttachmentParams,
) error {
if st.policy == nil {
return nil
}
prechecker, err := st.policy.Prechecker()
if errors.IsNotImplemented(err) {
return nil
} else if err != nil {
return err
}
if prechecker == nil {
return errors.New("policy returned nil prechecker without an error")
}
return prechecker.PrecheckInstance(
CallContext(st),
environs.PrecheckInstanceParams{
Series: series,
Constraints: cons,
Placement: placement,
VolumeAttachments: volumeAttachments,
})
} | go | func (st *State) precheckInstance(
series string,
cons constraints.Value,
placement string,
volumeAttachments []storage.VolumeAttachmentParams,
) error {
if st.policy == nil {
return nil
}
prechecker, err := st.policy.Prechecker()
if errors.IsNotImplemented(err) {
return nil
} else if err != nil {
return err
}
if prechecker == nil {
return errors.New("policy returned nil prechecker without an error")
}
return prechecker.PrecheckInstance(
CallContext(st),
environs.PrecheckInstanceParams{
Series: series,
Constraints: cons,
Placement: placement,
VolumeAttachments: volumeAttachments,
})
} | [
"func",
"(",
"st",
"*",
"State",
")",
"precheckInstance",
"(",
"series",
"string",
",",
"cons",
"constraints",
".",
"Value",
",",
"placement",
"string",
",",
"volumeAttachments",
"[",
"]",
"storage",
".",
"VolumeAttachmentParams",
",",
")",
"error",
"{",
"if... | // precheckInstance calls the state's assigned policy, if non-nil, to obtain
// a Prechecker, and calls PrecheckInstance if a non-nil Prechecker is returned. | [
"precheckInstance",
"calls",
"the",
"state",
"s",
"assigned",
"policy",
"if",
"non",
"-",
"nil",
"to",
"obtain",
"a",
"Prechecker",
"and",
"calls",
"PrecheckInstance",
"if",
"a",
"non",
"-",
"nil",
"Prechecker",
"is",
"returned",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/policy.go#L53-L79 |
3,835 | juju/juju | state/policy.go | ResolveConstraints | func (st *State) ResolveConstraints(cons constraints.Value) (constraints.Value, error) {
validator, err := st.constraintsValidator()
if err != nil {
return constraints.Value{}, err
}
modelCons, err := st.ModelConstraints()
if err != nil {
return constraints.Value{}, err
}
return validator.Merge(modelCons, cons)
} | go | func (st *State) ResolveConstraints(cons constraints.Value) (constraints.Value, error) {
validator, err := st.constraintsValidator()
if err != nil {
return constraints.Value{}, err
}
modelCons, err := st.ModelConstraints()
if err != nil {
return constraints.Value{}, err
}
return validator.Merge(modelCons, cons)
} | [
"func",
"(",
"st",
"*",
"State",
")",
"ResolveConstraints",
"(",
"cons",
"constraints",
".",
"Value",
")",
"(",
"constraints",
".",
"Value",
",",
"error",
")",
"{",
"validator",
",",
"err",
":=",
"st",
".",
"constraintsValidator",
"(",
")",
"\n",
"if",
... | // ResolveConstraints combines the given constraints with the environ constraints to get
// a constraints which will be used to create a new instance. | [
"ResolveConstraints",
"combines",
"the",
"given",
"constraints",
"with",
"the",
"environ",
"constraints",
"to",
"get",
"a",
"constraints",
"which",
"will",
"be",
"used",
"to",
"create",
"a",
"new",
"instance",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/policy.go#L133-L143 |
3,836 | juju/juju | state/policy.go | validateConstraints | func (st *State) validateConstraints(cons constraints.Value) ([]string, error) {
validator, err := st.constraintsValidator()
if err != nil {
return nil, err
}
return validator.Validate(cons)
} | go | func (st *State) validateConstraints(cons constraints.Value) ([]string, error) {
validator, err := st.constraintsValidator()
if err != nil {
return nil, err
}
return validator.Validate(cons)
} | [
"func",
"(",
"st",
"*",
"State",
")",
"validateConstraints",
"(",
"cons",
"constraints",
".",
"Value",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"validator",
",",
"err",
":=",
"st",
".",
"constraintsValidator",
"(",
")",
"\n",
"if",
"err",
... | // validateConstraints returns an error if the given constraints are not valid for the
// current model, and also any unsupported attributes. | [
"validateConstraints",
"returns",
"an",
"error",
"if",
"the",
"given",
"constraints",
"are",
"not",
"valid",
"for",
"the",
"current",
"model",
"and",
"also",
"any",
"unsupported",
"attributes",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/policy.go#L147-L153 |
3,837 | juju/juju | state/policy.go | validate | func (st *State) validate(cfg, old *config.Config) (valid *config.Config, err error) {
if st.policy == nil {
return cfg, nil
}
configValidator, err := st.policy.ConfigValidator()
if errors.IsNotImplemented(err) {
return cfg, nil
} else if err != nil {
return nil, err
}
if configValidator == nil {
return nil, errors.New("policy returned nil configValidator without an error")
}
return configValidator.Validate(cfg, old)
} | go | func (st *State) validate(cfg, old *config.Config) (valid *config.Config, err error) {
if st.policy == nil {
return cfg, nil
}
configValidator, err := st.policy.ConfigValidator()
if errors.IsNotImplemented(err) {
return cfg, nil
} else if err != nil {
return nil, err
}
if configValidator == nil {
return nil, errors.New("policy returned nil configValidator without an error")
}
return configValidator.Validate(cfg, old)
} | [
"func",
"(",
"st",
"*",
"State",
")",
"validate",
"(",
"cfg",
",",
"old",
"*",
"config",
".",
"Config",
")",
"(",
"valid",
"*",
"config",
".",
"Config",
",",
"err",
"error",
")",
"{",
"if",
"st",
".",
"policy",
"==",
"nil",
"{",
"return",
"cfg",
... | // validate calls the state's assigned policy, if non-nil, to obtain
// a config.Validator, and calls Validate if a non-nil config.Validator is
// returned. | [
"validate",
"calls",
"the",
"state",
"s",
"assigned",
"policy",
"if",
"non",
"-",
"nil",
"to",
"obtain",
"a",
"config",
".",
"Validator",
"and",
"calls",
"Validate",
"if",
"a",
"non",
"-",
"nil",
"config",
".",
"Validator",
"is",
"returned",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/policy.go#L158-L172 |
3,838 | juju/juju | core/cache/machine.go | Id | func (m *Machine) Id() string {
m.mu.Lock()
defer m.mu.Unlock()
return m.details.Id
} | go | func (m *Machine) Id() string {
m.mu.Lock()
defer m.mu.Unlock()
return m.details.Id
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"Id",
"(",
")",
"string",
"{",
"m",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"m",
".",
"details",
".",
"Id",
"\n",
"}"
] | // Id returns the id string of this machine. | [
"Id",
"returns",
"the",
"id",
"string",
"of",
"this",
"machine",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/machine.go#L44-L48 |
3,839 | juju/juju | core/cache/machine.go | InstanceId | func (m *Machine) InstanceId() (instance.Id, error) {
m.mu.Lock()
defer m.mu.Unlock()
if m.details.InstanceId == "" {
return "", errors.NotProvisionedf("machine %v", m.details.Id)
}
return instance.Id(m.details.InstanceId), nil
} | go | func (m *Machine) InstanceId() (instance.Id, error) {
m.mu.Lock()
defer m.mu.Unlock()
if m.details.InstanceId == "" {
return "", errors.NotProvisionedf("machine %v", m.details.Id)
}
return instance.Id(m.details.InstanceId), nil
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"InstanceId",
"(",
")",
"(",
"instance",
".",
"Id",
",",
"error",
")",
"{",
"m",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
".",
"details... | // InstanceId returns the provider specific instance id for this machine and
// returns not provisioned if instance id is empty | [
"InstanceId",
"returns",
"the",
"provider",
"specific",
"instance",
"id",
"for",
"this",
"machine",
"and",
"returns",
"not",
"provisioned",
"if",
"instance",
"id",
"is",
"empty"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/machine.go#L52-L60 |
3,840 | juju/juju | core/cache/machine.go | CharmProfiles | func (m *Machine) CharmProfiles() []string {
m.mu.Lock()
defer m.mu.Unlock()
return m.details.CharmProfiles
} | go | func (m *Machine) CharmProfiles() []string {
m.mu.Lock()
defer m.mu.Unlock()
return m.details.CharmProfiles
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"CharmProfiles",
"(",
")",
"[",
"]",
"string",
"{",
"m",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"m",
".",
"details",
".",
"CharmProfiles",
... | // CharmProfiles returns the cached list of charm profiles for the machine | [
"CharmProfiles",
"returns",
"the",
"cached",
"list",
"of",
"charm",
"profiles",
"for",
"the",
"machine"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/machine.go#L63-L67 |
3,841 | juju/juju | core/cache/machine.go | Units | func (m *Machine) Units() ([]*Unit, error) {
m.mu.Lock()
defer m.mu.Unlock()
result := make([]*Unit, 0)
for unitName, unit := range m.model.units {
if unit.details.MachineId == m.details.Id {
result = append(result, unit)
}
if unit.details.Subordinate {
principalUnit, found := m.model.units[unit.details.Principal]
if !found {
return result, errors.NotFoundf("principal unit %q for subordinate %s", unit.details.Principal, unitName)
}
if principalUnit.details.MachineId == m.details.Id {
result = append(result, unit)
}
}
}
return result, nil
} | go | func (m *Machine) Units() ([]*Unit, error) {
m.mu.Lock()
defer m.mu.Unlock()
result := make([]*Unit, 0)
for unitName, unit := range m.model.units {
if unit.details.MachineId == m.details.Id {
result = append(result, unit)
}
if unit.details.Subordinate {
principalUnit, found := m.model.units[unit.details.Principal]
if !found {
return result, errors.NotFoundf("principal unit %q for subordinate %s", unit.details.Principal, unitName)
}
if principalUnit.details.MachineId == m.details.Id {
result = append(result, unit)
}
}
}
return result, nil
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"Units",
"(",
")",
"(",
"[",
"]",
"*",
"Unit",
",",
"error",
")",
"{",
"m",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"result",
":=",
"make",
"("... | // Units returns all the units that have been assigned to the machine
// including subordinates. | [
"Units",
"returns",
"all",
"the",
"units",
"that",
"have",
"been",
"assigned",
"to",
"the",
"machine",
"including",
"subordinates",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/cache/machine.go#L71-L91 |
3,842 | juju/juju | provider/azure/instancetype.go | newInstanceType | func newInstanceType(size compute.VirtualMachineSize) instances.InstanceType {
// We're not doing real costs for now; just made-up, relative
// costs, to ensure we choose the right VMs given matching
// constraints. This was based on the pricing for West US,
// and assumes that all regions have the same relative costs.
//
// DS is the same price as D, but is targeted at Premium Storage.
// Likewise for GS and G. We put the premium storage variants
// directly after their non-premium counterparts.
machineSizeCost := []string{
"Standard_A0",
"Standard_A1",
"Standard_D1",
"Standard_DS1",
"Standard_D1_v2",
"Standard_A2",
"Standard_D2",
"Standard_DS2",
"Standard_D2_v2",
"Standard_D11",
"Standard_DS11",
"Standard_D11_v2",
"Standard_A3",
"Standard_D3",
"Standard_DS3",
"Standard_D3_v2",
"Standard_D12",
"Standard_DS12",
"Standard_D12_v2",
"Standard_A5", // Yes, A5 is cheaper than A4.
"Standard_A4",
"Standard_A6",
"Standard_G1",
"Standard_GS1",
"Standard_D4",
"Standard_DS4",
"Standard_D4_v2",
"Standard_D13",
"Standard_DS13",
"Standard_D13_v2",
"Standard_A7",
"Standard_A10",
"Standard_G2",
"Standard_GS2",
"Standard_D5_v2",
"Standard_D14",
"Standard_DS14",
"Standard_D14_v2",
"Standard_A8",
"Standard_A11",
"Standard_G3",
"Standard_GS3",
"Standard_A9",
"Standard_G4",
"Standard_GS4",
"Standard_GS5",
"Standard_G5",
// Basic instances are less capable than standard
// ones, so we don't want to be providing them as
// a default. This is achieved by costing them at
// a higher price, even though they are cheaper
// in reality.
"Basic_A0",
"Basic_A1",
"Basic_A2",
"Basic_A3",
"Basic_A4",
}
// Anything not in the list is more expensive that is in the list.
cost := len(machineSizeCost)
sizeName := to.String(size.Name)
for i, name := range machineSizeCost {
if sizeName == name {
cost = i
break
}
}
if cost == len(machineSizeCost) {
logger.Debugf("found unknown VM size %q", sizeName)
}
vtype := "Hyper-V"
return instances.InstanceType{
Id: sizeName,
Name: sizeName,
Arches: []string{arch.AMD64},
CpuCores: uint64(to.Int32(size.NumberOfCores)),
Mem: uint64(to.Int32(size.MemoryInMB)),
// NOTE(axw) size.OsDiskSizeInMB is the *maximum*
// OS-disk size. When we create a VM, we can create
// one that is smaller.
RootDisk: mbToMib(uint64(to.Int32(size.OsDiskSizeInMB))),
Cost: uint64(cost),
VirtType: &vtype,
// tags are not currently supported by azure
}
} | go | func newInstanceType(size compute.VirtualMachineSize) instances.InstanceType {
// We're not doing real costs for now; just made-up, relative
// costs, to ensure we choose the right VMs given matching
// constraints. This was based on the pricing for West US,
// and assumes that all regions have the same relative costs.
//
// DS is the same price as D, but is targeted at Premium Storage.
// Likewise for GS and G. We put the premium storage variants
// directly after their non-premium counterparts.
machineSizeCost := []string{
"Standard_A0",
"Standard_A1",
"Standard_D1",
"Standard_DS1",
"Standard_D1_v2",
"Standard_A2",
"Standard_D2",
"Standard_DS2",
"Standard_D2_v2",
"Standard_D11",
"Standard_DS11",
"Standard_D11_v2",
"Standard_A3",
"Standard_D3",
"Standard_DS3",
"Standard_D3_v2",
"Standard_D12",
"Standard_DS12",
"Standard_D12_v2",
"Standard_A5", // Yes, A5 is cheaper than A4.
"Standard_A4",
"Standard_A6",
"Standard_G1",
"Standard_GS1",
"Standard_D4",
"Standard_DS4",
"Standard_D4_v2",
"Standard_D13",
"Standard_DS13",
"Standard_D13_v2",
"Standard_A7",
"Standard_A10",
"Standard_G2",
"Standard_GS2",
"Standard_D5_v2",
"Standard_D14",
"Standard_DS14",
"Standard_D14_v2",
"Standard_A8",
"Standard_A11",
"Standard_G3",
"Standard_GS3",
"Standard_A9",
"Standard_G4",
"Standard_GS4",
"Standard_GS5",
"Standard_G5",
// Basic instances are less capable than standard
// ones, so we don't want to be providing them as
// a default. This is achieved by costing them at
// a higher price, even though they are cheaper
// in reality.
"Basic_A0",
"Basic_A1",
"Basic_A2",
"Basic_A3",
"Basic_A4",
}
// Anything not in the list is more expensive that is in the list.
cost := len(machineSizeCost)
sizeName := to.String(size.Name)
for i, name := range machineSizeCost {
if sizeName == name {
cost = i
break
}
}
if cost == len(machineSizeCost) {
logger.Debugf("found unknown VM size %q", sizeName)
}
vtype := "Hyper-V"
return instances.InstanceType{
Id: sizeName,
Name: sizeName,
Arches: []string{arch.AMD64},
CpuCores: uint64(to.Int32(size.NumberOfCores)),
Mem: uint64(to.Int32(size.MemoryInMB)),
// NOTE(axw) size.OsDiskSizeInMB is the *maximum*
// OS-disk size. When we create a VM, we can create
// one that is smaller.
RootDisk: mbToMib(uint64(to.Int32(size.OsDiskSizeInMB))),
Cost: uint64(cost),
VirtType: &vtype,
// tags are not currently supported by azure
}
} | [
"func",
"newInstanceType",
"(",
"size",
"compute",
".",
"VirtualMachineSize",
")",
"instances",
".",
"InstanceType",
"{",
"// We're not doing real costs for now; just made-up, relative",
"// costs, to ensure we choose the right VMs given matching",
"// constraints. This was based on the ... | // newInstanceType creates an InstanceType based on a VirtualMachineSize. | [
"newInstanceType",
"creates",
"an",
"InstanceType",
"based",
"on",
"a",
"VirtualMachineSize",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/azure/instancetype.go#L21-L119 |
3,843 | juju/juju | provider/azure/instancetype.go | defaultToBaselineSpec | func defaultToBaselineSpec(constraint constraints.Value) constraints.Value {
result := constraint
if !result.HasInstanceType() && result.Mem == nil {
var value uint64 = defaultMem
result.Mem = &value
}
return result
} | go | func defaultToBaselineSpec(constraint constraints.Value) constraints.Value {
result := constraint
if !result.HasInstanceType() && result.Mem == nil {
var value uint64 = defaultMem
result.Mem = &value
}
return result
} | [
"func",
"defaultToBaselineSpec",
"(",
"constraint",
"constraints",
".",
"Value",
")",
"constraints",
".",
"Value",
"{",
"result",
":=",
"constraint",
"\n",
"if",
"!",
"result",
".",
"HasInstanceType",
"(",
")",
"&&",
"result",
".",
"Mem",
"==",
"nil",
"{",
... | // If you specify no constraints at all, you're going to get the smallest
// instance type available. In practice that one's a bit small, so unless
// the constraints are deliberately set lower, this gives you a set of
// baseline constraints that are just slightly more ambitious than that. | [
"If",
"you",
"specify",
"no",
"constraints",
"at",
"all",
"you",
"re",
"going",
"to",
"get",
"the",
"smallest",
"instance",
"type",
"available",
".",
"In",
"practice",
"that",
"one",
"s",
"a",
"bit",
"small",
"so",
"unless",
"the",
"constraints",
"are",
... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/azure/instancetype.go#L171-L178 |
3,844 | juju/juju | worker/firewaller/shim.go | NewFirewallerFacade | func NewFirewallerFacade(apiCaller base.APICaller) (FirewallerAPI, error) {
facade, err := firewaller.NewClient(apiCaller)
if err != nil {
return nil, errors.Trace(err)
}
return facade, nil
} | go | func NewFirewallerFacade(apiCaller base.APICaller) (FirewallerAPI, error) {
facade, err := firewaller.NewClient(apiCaller)
if err != nil {
return nil, errors.Trace(err)
}
return facade, nil
} | [
"func",
"NewFirewallerFacade",
"(",
"apiCaller",
"base",
".",
"APICaller",
")",
"(",
"FirewallerAPI",
",",
"error",
")",
"{",
"facade",
",",
"err",
":=",
"firewaller",
".",
"NewClient",
"(",
"apiCaller",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
... | // NewFirewallerFacade creates a firewaller API facade. | [
"NewFirewallerFacade",
"creates",
"a",
"firewaller",
"API",
"facade",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/firewaller/shim.go#L28-L34 |
3,845 | juju/juju | worker/firewaller/shim.go | NewWorker | func NewWorker(cfg Config) (worker.Worker, error) {
w, err := NewFirewaller(cfg)
if err != nil {
return nil, errors.Trace(err)
}
return w, nil
} | go | func NewWorker(cfg Config) (worker.Worker, error) {
w, err := NewFirewaller(cfg)
if err != nil {
return nil, errors.Trace(err)
}
return w, nil
} | [
"func",
"NewWorker",
"(",
"cfg",
"Config",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"w",
",",
"err",
":=",
"NewFirewaller",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
... | // NewWorker creates a firewaller worker. | [
"NewWorker",
"creates",
"a",
"firewaller",
"worker",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/firewaller/shim.go#L37-L43 |
3,846 | juju/juju | worker/firewaller/shim.go | crossmodelFirewallerFacadeFunc | func crossmodelFirewallerFacadeFunc(
connectionFunc apicaller.NewExternalControllerConnectionFunc,
) newCrossModelFacadeFunc {
return func(apiInfo *api.Info) (CrossModelFirewallerFacadeCloser, error) {
apiInfo.Tag = names.NewUserTag(api.AnonymousUsername)
conn, err := connectionFunc(apiInfo)
if err != nil {
return nil, errors.Trace(err)
}
facade := crossmodelrelations.NewClient(conn)
return &crossModelFirewallerFacadeCloser{facade, conn}, nil
}
} | go | func crossmodelFirewallerFacadeFunc(
connectionFunc apicaller.NewExternalControllerConnectionFunc,
) newCrossModelFacadeFunc {
return func(apiInfo *api.Info) (CrossModelFirewallerFacadeCloser, error) {
apiInfo.Tag = names.NewUserTag(api.AnonymousUsername)
conn, err := connectionFunc(apiInfo)
if err != nil {
return nil, errors.Trace(err)
}
facade := crossmodelrelations.NewClient(conn)
return &crossModelFirewallerFacadeCloser{facade, conn}, nil
}
} | [
"func",
"crossmodelFirewallerFacadeFunc",
"(",
"connectionFunc",
"apicaller",
".",
"NewExternalControllerConnectionFunc",
",",
")",
"newCrossModelFacadeFunc",
"{",
"return",
"func",
"(",
"apiInfo",
"*",
"api",
".",
"Info",
")",
"(",
"CrossModelFirewallerFacadeCloser",
","... | // crossmodelFirewallerFacadeFunc returns a function that
// can be used to construct instances which manage remote relation
// firewall changes for a given model.
// For now we use a facade, but in future this may evolve into a REST caller. | [
"crossmodelFirewallerFacadeFunc",
"returns",
"a",
"function",
"that",
"can",
"be",
"used",
"to",
"construct",
"instances",
"which",
"manage",
"remote",
"relation",
"firewall",
"changes",
"for",
"a",
"given",
"model",
".",
"For",
"now",
"we",
"use",
"a",
"facade"... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/firewaller/shim.go#L50-L62 |
3,847 | juju/juju | worker/globalclockupdater/worker.go | NewWorker | func NewWorker(config Config) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Annotate(err, "validating config")
}
updater, err := config.NewUpdater()
if err != nil {
return nil, errors.Annotate(err, "getting new updater")
}
w := &updaterWorker{
config: config,
updater: updater,
}
w.tomb.Go(w.loop)
return w, nil
} | go | func NewWorker(config Config) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Annotate(err, "validating config")
}
updater, err := config.NewUpdater()
if err != nil {
return nil, errors.Annotate(err, "getting new updater")
}
w := &updaterWorker{
config: config,
updater: updater,
}
w.tomb.Go(w.loop)
return w, nil
} | [
"func",
"NewWorker",
"(",
"config",
"Config",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Annotate",
"(",
"er... | // NewWorker returns a new global clock updater worker, using the given
// configuration. | [
"NewWorker",
"returns",
"a",
"new",
"global",
"clock",
"updater",
"worker",
"using",
"the",
"given",
"configuration",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/globalclockupdater/worker.go#L65-L79 |
3,848 | juju/juju | api/uniter/relation.go | SetStatus | func (r *Relation) SetStatus(status relation.Status) error {
return r.st.setRelationStatus(r.id, status)
} | go | func (r *Relation) SetStatus(status relation.Status) error {
return r.st.setRelationStatus(r.id, status)
} | [
"func",
"(",
"r",
"*",
"Relation",
")",
"SetStatus",
"(",
"status",
"relation",
".",
"Status",
")",
"error",
"{",
"return",
"r",
".",
"st",
".",
"setRelationStatus",
"(",
"r",
".",
"id",
",",
"status",
")",
"\n",
"}"
] | // SetStatus updates the status of the relation. | [
"SetStatus",
"updates",
"the",
"status",
"of",
"the",
"relation",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/uniter/relation.go#L89-L91 |
3,849 | juju/juju | api/uniter/relation.go | Endpoint | func (r *Relation) Endpoint() (*Endpoint, error) {
// NOTE: This differs from state.Relation.Endpoint(), because when
// talking to the API, there's already an authenticated entity - the
// unit, and we can find out its application name.
result, err := r.st.relation(r.tag, r.st.unitTag)
if err != nil {
return nil, err
}
return &Endpoint{r.toCharmRelation(result.Endpoint.Relation)}, nil
} | go | func (r *Relation) Endpoint() (*Endpoint, error) {
// NOTE: This differs from state.Relation.Endpoint(), because when
// talking to the API, there's already an authenticated entity - the
// unit, and we can find out its application name.
result, err := r.st.relation(r.tag, r.st.unitTag)
if err != nil {
return nil, err
}
return &Endpoint{r.toCharmRelation(result.Endpoint.Relation)}, nil
} | [
"func",
"(",
"r",
"*",
"Relation",
")",
"Endpoint",
"(",
")",
"(",
"*",
"Endpoint",
",",
"error",
")",
"{",
"// NOTE: This differs from state.Relation.Endpoint(), because when",
"// talking to the API, there's already an authenticated entity - the",
"// unit, and we can find out ... | // Endpoint returns the endpoint of the relation for the application the
// uniter's managed unit belongs to. | [
"Endpoint",
"returns",
"the",
"endpoint",
"of",
"the",
"relation",
"for",
"the",
"application",
"the",
"uniter",
"s",
"managed",
"unit",
"belongs",
"to",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/api/uniter/relation.go#L106-L115 |
3,850 | juju/juju | cmd/juju/resource/list.go | NewListCommand | func NewListCommand(deps ListDeps) modelcmd.ModelCommand {
return modelcmd.Wrap(&ListCommand{deps: deps})
} | go | func NewListCommand(deps ListDeps) modelcmd.ModelCommand {
return modelcmd.Wrap(&ListCommand{deps: deps})
} | [
"func",
"NewListCommand",
"(",
"deps",
"ListDeps",
")",
"modelcmd",
".",
"ModelCommand",
"{",
"return",
"modelcmd",
".",
"Wrap",
"(",
"&",
"ListCommand",
"{",
"deps",
":",
"deps",
"}",
")",
"\n",
"}"
] | // NewListCommand returns a new command that lists resources defined
// by a charm. | [
"NewListCommand",
"returns",
"a",
"new",
"command",
"that",
"lists",
"resources",
"defined",
"by",
"a",
"charm",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/resource/list.go#L46-L48 |
3,851 | juju/juju | apiserver/facades/agent/machine/machiner.go | NewMachinerAPI | func NewMachinerAPI(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*MachinerAPI, error) {
if !authorizer.AuthMachineAgent() {
return nil, common.ErrPerm
}
getCanModify := func() (common.AuthFunc, error) {
return authorizer.AuthOwner, nil
}
getCanRead := func() (common.AuthFunc, error) {
return authorizer.AuthOwner, nil
}
return &MachinerAPI{
LifeGetter: common.NewLifeGetter(st, getCanRead),
StatusSetter: common.NewStatusSetter(st, getCanModify),
DeadEnsurer: common.NewDeadEnsurer(st, getCanModify),
AgentEntityWatcher: common.NewAgentEntityWatcher(st, resources, getCanRead),
APIAddresser: common.NewAPIAddresser(st, resources),
NetworkConfigAPI: networkingcommon.NewNetworkConfigAPI(st, state.CallContext(st), getCanModify),
st: st,
auth: authorizer,
getCanModify: getCanModify,
getCanRead: getCanRead,
}, nil
} | go | func NewMachinerAPI(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*MachinerAPI, error) {
if !authorizer.AuthMachineAgent() {
return nil, common.ErrPerm
}
getCanModify := func() (common.AuthFunc, error) {
return authorizer.AuthOwner, nil
}
getCanRead := func() (common.AuthFunc, error) {
return authorizer.AuthOwner, nil
}
return &MachinerAPI{
LifeGetter: common.NewLifeGetter(st, getCanRead),
StatusSetter: common.NewStatusSetter(st, getCanModify),
DeadEnsurer: common.NewDeadEnsurer(st, getCanModify),
AgentEntityWatcher: common.NewAgentEntityWatcher(st, resources, getCanRead),
APIAddresser: common.NewAPIAddresser(st, resources),
NetworkConfigAPI: networkingcommon.NewNetworkConfigAPI(st, state.CallContext(st), getCanModify),
st: st,
auth: authorizer,
getCanModify: getCanModify,
getCanRead: getCanRead,
}, nil
} | [
"func",
"NewMachinerAPI",
"(",
"st",
"*",
"state",
".",
"State",
",",
"resources",
"facade",
".",
"Resources",
",",
"authorizer",
"facade",
".",
"Authorizer",
")",
"(",
"*",
"MachinerAPI",
",",
"error",
")",
"{",
"if",
"!",
"authorizer",
".",
"AuthMachineA... | // NewMachinerAPI creates a new instance of the Machiner API. | [
"NewMachinerAPI",
"creates",
"a",
"new",
"instance",
"of",
"the",
"Machiner",
"API",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/machine/machiner.go#L39-L61 |
3,852 | juju/juju | apiserver/facades/agent/machine/machiner.go | Jobs | func (api *MachinerAPI) Jobs(args params.Entities) (params.JobsResults, error) {
result := params.JobsResults{
Results: make([]params.JobsResult, len(args.Entities)),
}
canRead, err := api.getCanRead()
if err != nil {
return result, err
}
for i, agent := range args.Entities {
tag, err := names.ParseMachineTag(agent.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
if !canRead(tag) {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := api.getMachine(tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
machineJobs := machine.Jobs()
jobs := make([]multiwatcher.MachineJob, len(machineJobs))
for i, job := range machineJobs {
jobs[i] = job.ToParams()
}
result.Results[i].Jobs = jobs
}
return result, nil
} | go | func (api *MachinerAPI) Jobs(args params.Entities) (params.JobsResults, error) {
result := params.JobsResults{
Results: make([]params.JobsResult, len(args.Entities)),
}
canRead, err := api.getCanRead()
if err != nil {
return result, err
}
for i, agent := range args.Entities {
tag, err := names.ParseMachineTag(agent.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
if !canRead(tag) {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := api.getMachine(tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
machineJobs := machine.Jobs()
jobs := make([]multiwatcher.MachineJob, len(machineJobs))
for i, job := range machineJobs {
jobs[i] = job.ToParams()
}
result.Results[i].Jobs = jobs
}
return result, nil
} | [
"func",
"(",
"api",
"*",
"MachinerAPI",
")",
"Jobs",
"(",
"args",
"params",
".",
"Entities",
")",
"(",
"params",
".",
"JobsResults",
",",
"error",
")",
"{",
"result",
":=",
"params",
".",
"JobsResults",
"{",
"Results",
":",
"make",
"(",
"[",
"]",
"pa... | // Jobs returns the jobs assigned to the given entities. | [
"Jobs",
"returns",
"the",
"jobs",
"assigned",
"to",
"the",
"given",
"entities",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/machine/machiner.go#L102-L137 |
3,853 | juju/juju | state/mongo.go | GetCollection | func (m *environMongo) GetCollection(name string) (mongo.Collection, func()) {
return m.state.db().GetCollection(name)
} | go | func (m *environMongo) GetCollection(name string) (mongo.Collection, func()) {
return m.state.db().GetCollection(name)
} | [
"func",
"(",
"m",
"*",
"environMongo",
")",
"GetCollection",
"(",
"name",
"string",
")",
"(",
"mongo",
".",
"Collection",
",",
"func",
"(",
")",
")",
"{",
"return",
"m",
".",
"state",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"name",
")",
"\n... | // GetCollection is part of the lease.Mongo interface. | [
"GetCollection",
"is",
"part",
"of",
"the",
"lease",
".",
"Mongo",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mongo.go#L23-L25 |
3,854 | juju/juju | state/mongo.go | RunTransaction | func (m *environMongo) RunTransaction(buildTxn jujutxn.TransactionSource) error {
return m.state.db().Run(buildTxn)
} | go | func (m *environMongo) RunTransaction(buildTxn jujutxn.TransactionSource) error {
return m.state.db().Run(buildTxn)
} | [
"func",
"(",
"m",
"*",
"environMongo",
")",
"RunTransaction",
"(",
"buildTxn",
"jujutxn",
".",
"TransactionSource",
")",
"error",
"{",
"return",
"m",
".",
"state",
".",
"db",
"(",
")",
".",
"Run",
"(",
"buildTxn",
")",
"\n",
"}"
] | // RunTransaction is part of the lease.Mongo interface. | [
"RunTransaction",
"is",
"part",
"of",
"the",
"lease",
".",
"Mongo",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mongo.go#L28-L30 |
3,855 | juju/juju | state/mongo.go | SetUpgradeMongoMode | func (st *State) SetUpgradeMongoMode(v mongo.Version) (UpgradeMongoParams, error) {
currentInfo, err := st.ControllerInfo()
if err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "could not obtain current controller information")
}
result := UpgradeMongoParams{}
machines := []*Machine{}
for _, mID := range currentInfo.MachineIds {
m, err := st.Machine(mID)
if err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "cannot change all the replicas")
}
isMaster, err := mongo.IsMaster(st.session, m)
if err != nil {
return UpgradeMongoParams{}, errors.Annotatef(err, "cannot determine if machine %q is master", mID)
}
paddr, err := m.PublicAddress()
if err != nil {
return UpgradeMongoParams{}, errors.Annotatef(err, "cannot obtain public address for machine: %v", m)
}
tag := m.Tag()
mtag := tag.(names.MachineTag)
member := HAMember{
Tag: mtag.Id(),
PublicAddress: paddr,
Series: m.Series(),
}
if isMaster {
result.Master = member
} else {
result.Members = append(result.Members, member)
}
machines = append(machines, m)
}
rsMembers, err := replicaset.CurrentMembers(st.session)
if err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "cannot obtain current replicaset members")
}
masterRs, err := replicaset.MasterHostPort(st.session)
if err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "cannot determine master on replicaset members")
}
for _, m := range rsMembers {
if m.Address != masterRs {
result.RsMembers = append(result.RsMembers, m)
}
}
for _, m := range machines {
if err := m.SetStopMongoUntilVersion(v); err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "cannot trigger replica shutdown")
}
}
return result, nil
} | go | func (st *State) SetUpgradeMongoMode(v mongo.Version) (UpgradeMongoParams, error) {
currentInfo, err := st.ControllerInfo()
if err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "could not obtain current controller information")
}
result := UpgradeMongoParams{}
machines := []*Machine{}
for _, mID := range currentInfo.MachineIds {
m, err := st.Machine(mID)
if err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "cannot change all the replicas")
}
isMaster, err := mongo.IsMaster(st.session, m)
if err != nil {
return UpgradeMongoParams{}, errors.Annotatef(err, "cannot determine if machine %q is master", mID)
}
paddr, err := m.PublicAddress()
if err != nil {
return UpgradeMongoParams{}, errors.Annotatef(err, "cannot obtain public address for machine: %v", m)
}
tag := m.Tag()
mtag := tag.(names.MachineTag)
member := HAMember{
Tag: mtag.Id(),
PublicAddress: paddr,
Series: m.Series(),
}
if isMaster {
result.Master = member
} else {
result.Members = append(result.Members, member)
}
machines = append(machines, m)
}
rsMembers, err := replicaset.CurrentMembers(st.session)
if err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "cannot obtain current replicaset members")
}
masterRs, err := replicaset.MasterHostPort(st.session)
if err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "cannot determine master on replicaset members")
}
for _, m := range rsMembers {
if m.Address != masterRs {
result.RsMembers = append(result.RsMembers, m)
}
}
for _, m := range machines {
if err := m.SetStopMongoUntilVersion(v); err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "cannot trigger replica shutdown")
}
}
return result, nil
} | [
"func",
"(",
"st",
"*",
"State",
")",
"SetUpgradeMongoMode",
"(",
"v",
"mongo",
".",
"Version",
")",
"(",
"UpgradeMongoParams",
",",
"error",
")",
"{",
"currentInfo",
",",
"err",
":=",
"st",
".",
"ControllerInfo",
"(",
")",
"\n",
"if",
"err",
"!=",
"ni... | // SetUpgradeMongoMode writes a value in the state server to be picked up
// by api servers to know that there is an upgrade ready to happen. | [
"SetUpgradeMongoMode",
"writes",
"a",
"value",
"in",
"the",
"state",
"server",
"to",
"be",
"picked",
"up",
"by",
"api",
"servers",
"to",
"know",
"that",
"there",
"is",
"an",
"upgrade",
"ready",
"to",
"happen",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mongo.go#L53-L106 |
3,856 | juju/juju | state/mongo.go | ResumeReplication | func (st *State) ResumeReplication(members []replicaset.Member) error {
return replicaset.Add(st.session, members...)
} | go | func (st *State) ResumeReplication(members []replicaset.Member) error {
return replicaset.Add(st.session, members...)
} | [
"func",
"(",
"st",
"*",
"State",
")",
"ResumeReplication",
"(",
"members",
"[",
"]",
"replicaset",
".",
"Member",
")",
"error",
"{",
"return",
"replicaset",
".",
"Add",
"(",
"st",
".",
"session",
",",
"members",
"...",
")",
"\n",
"}"
] | // ResumeReplication will add all passed members to replicaset. | [
"ResumeReplication",
"will",
"add",
"all",
"passed",
"members",
"to",
"replicaset",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mongo.go#L109-L111 |
3,857 | juju/juju | apiserver/facades/controller/cleaner/cleaner.go | NewCleanerAPI | func NewCleanerAPI(
st *state.State,
res facade.Resources,
authorizer facade.Authorizer,
) (*CleanerAPI, error) {
if !authorizer.AuthController() {
return nil, common.ErrPerm
}
return &CleanerAPI{
st: getState(st),
resources: res,
}, nil
} | go | func NewCleanerAPI(
st *state.State,
res facade.Resources,
authorizer facade.Authorizer,
) (*CleanerAPI, error) {
if !authorizer.AuthController() {
return nil, common.ErrPerm
}
return &CleanerAPI{
st: getState(st),
resources: res,
}, nil
} | [
"func",
"NewCleanerAPI",
"(",
"st",
"*",
"state",
".",
"State",
",",
"res",
"facade",
".",
"Resources",
",",
"authorizer",
"facade",
".",
"Authorizer",
",",
")",
"(",
"*",
"CleanerAPI",
",",
"error",
")",
"{",
"if",
"!",
"authorizer",
".",
"AuthControlle... | // NewCleanerAPI creates a new instance of the Cleaner API. | [
"NewCleanerAPI",
"creates",
"a",
"new",
"instance",
"of",
"the",
"Cleaner",
"API",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/controller/cleaner/cleaner.go#L24-L36 |
3,858 | juju/juju | apiserver/facades/controller/cleaner/cleaner.go | WatchCleanups | func (api *CleanerAPI) WatchCleanups() (params.NotifyWatchResult, error) {
watch := api.st.WatchCleanups()
if _, ok := <-watch.Changes(); ok {
return params.NotifyWatchResult{
NotifyWatcherId: api.resources.Register(watch),
}, nil
}
return params.NotifyWatchResult{
Error: common.ServerError(watcher.EnsureErr(watch)),
}, nil
} | go | func (api *CleanerAPI) WatchCleanups() (params.NotifyWatchResult, error) {
watch := api.st.WatchCleanups()
if _, ok := <-watch.Changes(); ok {
return params.NotifyWatchResult{
NotifyWatcherId: api.resources.Register(watch),
}, nil
}
return params.NotifyWatchResult{
Error: common.ServerError(watcher.EnsureErr(watch)),
}, nil
} | [
"func",
"(",
"api",
"*",
"CleanerAPI",
")",
"WatchCleanups",
"(",
")",
"(",
"params",
".",
"NotifyWatchResult",
",",
"error",
")",
"{",
"watch",
":=",
"api",
".",
"st",
".",
"WatchCleanups",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"<-",
"watch",
... | // WatchChanges watches for cleanups to be perfomed in state | [
"WatchChanges",
"watches",
"for",
"cleanups",
"to",
"be",
"perfomed",
"in",
"state"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/controller/cleaner/cleaner.go#L44-L54 |
3,859 | juju/juju | worker/upgrader/error.go | ChangeAgentTools | func (e *UpgradeReadyError) ChangeAgentTools() error {
agentTools, err := tools.ChangeAgentTools(e.DataDir, e.AgentName, e.NewTools)
if err != nil {
return err
}
logger.Infof("upgraded from %v to %v (%q)", e.OldTools, agentTools.Version, agentTools.URL)
return nil
} | go | func (e *UpgradeReadyError) ChangeAgentTools() error {
agentTools, err := tools.ChangeAgentTools(e.DataDir, e.AgentName, e.NewTools)
if err != nil {
return err
}
logger.Infof("upgraded from %v to %v (%q)", e.OldTools, agentTools.Version, agentTools.URL)
return nil
} | [
"func",
"(",
"e",
"*",
"UpgradeReadyError",
")",
"ChangeAgentTools",
"(",
")",
"error",
"{",
"agentTools",
",",
"err",
":=",
"tools",
".",
"ChangeAgentTools",
"(",
"e",
".",
"DataDir",
",",
"e",
".",
"AgentName",
",",
"e",
".",
"NewTools",
")",
"\n",
"... | // ChangeAgentTools does the actual agent upgrade.
// It should be called just before an agent exits, so that
// it will restart running the new tools. | [
"ChangeAgentTools",
"does",
"the",
"actual",
"agent",
"upgrade",
".",
"It",
"should",
"be",
"called",
"just",
"before",
"an",
"agent",
"exits",
"so",
"that",
"it",
"will",
"restart",
"running",
"the",
"new",
"tools",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/upgrader/error.go#L28-L35 |
3,860 | juju/juju | provider/oci/common/errors.go | IsAuthorisationFailure | func IsAuthorisationFailure(err error) bool {
if err == nil {
return false
}
serviceError, ok := err.(ociCommon.ServiceError)
if !ok {
// Just to double check, also try the SDK's
// implementation. This isn't checked first, because
// it is hard to test.
serviceError, ok = ociCommon.IsServiceError(err)
}
if ok && authErrorCodes.Contains(serviceError.GetCode()) {
return true
}
return false
} | go | func IsAuthorisationFailure(err error) bool {
if err == nil {
return false
}
serviceError, ok := err.(ociCommon.ServiceError)
if !ok {
// Just to double check, also try the SDK's
// implementation. This isn't checked first, because
// it is hard to test.
serviceError, ok = ociCommon.IsServiceError(err)
}
if ok && authErrorCodes.Contains(serviceError.GetCode()) {
return true
}
return false
} | [
"func",
"IsAuthorisationFailure",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"serviceError",
",",
"ok",
":=",
"err",
".",
"(",
"ociCommon",
".",
"ServiceError",
")",
"\n",
"if",
"!",
"ok"... | // IsAuthorisationFailure reports whether the error is related to
// attempting to access the provider with invalid or expired credentials. | [
"IsAuthorisationFailure",
"reports",
"whether",
"the",
"error",
"is",
"related",
"to",
"attempting",
"to",
"access",
"the",
"provider",
"with",
"invalid",
"or",
"expired",
"credentials",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/oci/common/errors.go#L37-L55 |
3,861 | juju/juju | provider/oci/common/errors.go | HandleCredentialError | func HandleCredentialError(err error, ctx context.ProviderCallContext) {
common.HandleCredentialError(IsAuthorisationFailure, err, ctx)
} | go | func HandleCredentialError(err error, ctx context.ProviderCallContext) {
common.HandleCredentialError(IsAuthorisationFailure, err, ctx)
} | [
"func",
"HandleCredentialError",
"(",
"err",
"error",
",",
"ctx",
"context",
".",
"ProviderCallContext",
")",
"{",
"common",
".",
"HandleCredentialError",
"(",
"IsAuthorisationFailure",
",",
"err",
",",
"ctx",
")",
"\n",
"}"
] | // HandleCredentialError marks the current credentials as invalid internally
// if Oracle believes that they are expired | [
"HandleCredentialError",
"marks",
"the",
"current",
"credentials",
"as",
"invalid",
"internally",
"if",
"Oracle",
"believes",
"that",
"they",
"are",
"expired"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/oci/common/errors.go#L59-L61 |
3,862 | juju/juju | worker/logforwarder/manifold.go | Manifold | func Manifold(config ManifoldConfig) dependency.Manifold {
openLogStream := config.OpenLogStream
if openLogStream == nil {
openLogStream = func(caller base.APICaller, cfg params.LogStreamConfig, controllerUUID string) (LogStream, error) {
return logstream.Open(caller, cfg, controllerUUID)
}
}
openForwarder := config.OpenLogForwarder
if openForwarder == nil {
openForwarder = NewLogForwarder
}
return dependency.Manifold{
Inputs: []string{
config.APICallerName,
},
Start: func(context dependency.Context) (worker.Worker, error) {
var apiCaller base.APICaller
if err := context.Get(config.APICallerName, &apiCaller); err != nil {
return nil, errors.Trace(err)
}
agentFacade, err := apiagent.NewState(apiCaller)
if err != nil {
return nil, errors.Trace(err)
}
controllerCfg, err := agentFacade.ControllerConfig()
if err != nil {
return nil, errors.Annotate(err, "cannot read controller config")
}
orchestrator, err := newOrchestratorForController(OrchestratorArgs{
ControllerUUID: controllerCfg.ControllerUUID(),
LogForwardConfig: agentFacade,
Caller: apiCaller,
Sinks: config.Sinks,
OpenLogStream: openLogStream,
OpenLogForwarder: openForwarder,
})
return orchestrator, errors.Annotate(err, "creating log forwarding orchestrator")
},
}
} | go | func Manifold(config ManifoldConfig) dependency.Manifold {
openLogStream := config.OpenLogStream
if openLogStream == nil {
openLogStream = func(caller base.APICaller, cfg params.LogStreamConfig, controllerUUID string) (LogStream, error) {
return logstream.Open(caller, cfg, controllerUUID)
}
}
openForwarder := config.OpenLogForwarder
if openForwarder == nil {
openForwarder = NewLogForwarder
}
return dependency.Manifold{
Inputs: []string{
config.APICallerName,
},
Start: func(context dependency.Context) (worker.Worker, error) {
var apiCaller base.APICaller
if err := context.Get(config.APICallerName, &apiCaller); err != nil {
return nil, errors.Trace(err)
}
agentFacade, err := apiagent.NewState(apiCaller)
if err != nil {
return nil, errors.Trace(err)
}
controllerCfg, err := agentFacade.ControllerConfig()
if err != nil {
return nil, errors.Annotate(err, "cannot read controller config")
}
orchestrator, err := newOrchestratorForController(OrchestratorArgs{
ControllerUUID: controllerCfg.ControllerUUID(),
LogForwardConfig: agentFacade,
Caller: apiCaller,
Sinks: config.Sinks,
OpenLogStream: openLogStream,
OpenLogForwarder: openForwarder,
})
return orchestrator, errors.Annotate(err, "creating log forwarding orchestrator")
},
}
} | [
"func",
"Manifold",
"(",
"config",
"ManifoldConfig",
")",
"dependency",
".",
"Manifold",
"{",
"openLogStream",
":=",
"config",
".",
"OpenLogStream",
"\n",
"if",
"openLogStream",
"==",
"nil",
"{",
"openLogStream",
"=",
"func",
"(",
"caller",
"base",
".",
"APICa... | // Manifold returns a dependency manifold that runs a log forwarding
// worker, using the resource names defined in the supplied config. | [
"Manifold",
"returns",
"a",
"dependency",
"manifold",
"that",
"runs",
"a",
"log",
"forwarding",
"worker",
"using",
"the",
"resource",
"names",
"defined",
"in",
"the",
"supplied",
"config",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/logforwarder/manifold.go#L37-L80 |
3,863 | juju/juju | provider/oci/provider.go | Open | func (e *EnvironProvider) Open(params environs.OpenParams) (environs.Environ, error) {
logger.Infof("opening model %q", params.Config.Name())
if err := validateCloudSpec(params.Cloud); err != nil {
return nil, errors.Trace(err)
}
creds := params.Cloud.Credential.Attributes()
jujuConfig := common.JujuConfigProvider{
Key: []byte(creds["key"]),
Fingerprint: creds["fingerprint"],
Passphrase: creds["pass-phrase"],
Tenancy: creds["tenancy"],
User: creds["user"],
OCIRegion: creds["region"],
}
provider, err := jujuConfig.Config()
if err != nil {
return nil, errors.Trace(err)
}
compute, err := ociCore.NewComputeClientWithConfigurationProvider(provider)
if err != nil {
return nil, errors.Trace(err)
}
networking, err := ociCore.NewVirtualNetworkClientWithConfigurationProvider(provider)
if err != nil {
return nil, errors.Trace(err)
}
storage, err := ociCore.NewBlockstorageClientWithConfigurationProvider(provider)
if err != nil {
return nil, errors.Trace(err)
}
identity, err := ociIdentity.NewIdentityClientWithConfigurationProvider(provider)
if err != nil {
return nil, errors.Trace(err)
}
env := &Environ{
Compute: compute,
Networking: networking,
Storage: storage,
Firewall: networking,
Identity: identity,
ociConfig: provider,
clock: clock.WallClock,
p: e,
}
if err := env.SetConfig(params.Config); err != nil {
return nil, err
}
env.namespace, err = instance.NewNamespace(env.Config().UUID())
cfg := env.ecfg()
if cfg.compartmentID() == nil {
return nil, errors.New("compartment-id may not be empty")
}
addressSpace := cfg.addressSpace()
if _, ipNET, err := net.ParseCIDR(*addressSpace); err == nil {
size, _ := ipNET.Mask.Size()
if size > 16 {
return nil, errors.Errorf("configured subnet (%q) is not large enough. Please use a prefix length in the range /8 to /16. Current prefix length is /%d", *addressSpace, size)
}
} else {
return nil, errors.Trace(err)
}
return env, nil
} | go | func (e *EnvironProvider) Open(params environs.OpenParams) (environs.Environ, error) {
logger.Infof("opening model %q", params.Config.Name())
if err := validateCloudSpec(params.Cloud); err != nil {
return nil, errors.Trace(err)
}
creds := params.Cloud.Credential.Attributes()
jujuConfig := common.JujuConfigProvider{
Key: []byte(creds["key"]),
Fingerprint: creds["fingerprint"],
Passphrase: creds["pass-phrase"],
Tenancy: creds["tenancy"],
User: creds["user"],
OCIRegion: creds["region"],
}
provider, err := jujuConfig.Config()
if err != nil {
return nil, errors.Trace(err)
}
compute, err := ociCore.NewComputeClientWithConfigurationProvider(provider)
if err != nil {
return nil, errors.Trace(err)
}
networking, err := ociCore.NewVirtualNetworkClientWithConfigurationProvider(provider)
if err != nil {
return nil, errors.Trace(err)
}
storage, err := ociCore.NewBlockstorageClientWithConfigurationProvider(provider)
if err != nil {
return nil, errors.Trace(err)
}
identity, err := ociIdentity.NewIdentityClientWithConfigurationProvider(provider)
if err != nil {
return nil, errors.Trace(err)
}
env := &Environ{
Compute: compute,
Networking: networking,
Storage: storage,
Firewall: networking,
Identity: identity,
ociConfig: provider,
clock: clock.WallClock,
p: e,
}
if err := env.SetConfig(params.Config); err != nil {
return nil, err
}
env.namespace, err = instance.NewNamespace(env.Config().UUID())
cfg := env.ecfg()
if cfg.compartmentID() == nil {
return nil, errors.New("compartment-id may not be empty")
}
addressSpace := cfg.addressSpace()
if _, ipNET, err := net.ParseCIDR(*addressSpace); err == nil {
size, _ := ipNET.Mask.Size()
if size > 16 {
return nil, errors.Errorf("configured subnet (%q) is not large enough. Please use a prefix length in the range /8 to /16. Current prefix length is /%d", *addressSpace, size)
}
} else {
return nil, errors.Trace(err)
}
return env, nil
} | [
"func",
"(",
"e",
"*",
"EnvironProvider",
")",
"Open",
"(",
"params",
"environs",
".",
"OpenParams",
")",
"(",
"environs",
".",
"Environ",
",",
"error",
")",
"{",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
",",
"params",
".",
"Config",
".",
"Name",
"("... | // Open implements environs.EnvironProvider. | [
"Open",
"implements",
"environs",
".",
"EnvironProvider",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/oci/provider.go#L222-L295 |
3,864 | juju/juju | provider/oci/provider.go | Validate | func (e EnvironProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {
if err := config.Validate(cfg, old); err != nil {
return nil, err
}
newAttrs, err := cfg.ValidateUnknownAttrs(
configFields, configDefaults,
)
if err != nil {
return nil, err
}
return cfg.Apply(newAttrs)
} | go | func (e EnvironProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {
if err := config.Validate(cfg, old); err != nil {
return nil, err
}
newAttrs, err := cfg.ValidateUnknownAttrs(
configFields, configDefaults,
)
if err != nil {
return nil, err
}
return cfg.Apply(newAttrs)
} | [
"func",
"(",
"e",
"EnvironProvider",
")",
"Validate",
"(",
"cfg",
",",
"old",
"*",
"config",
".",
"Config",
")",
"(",
"valid",
"*",
"config",
".",
"Config",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
"cfg",
",... | // Validate implements config.Validator. | [
"Validate",
"implements",
"config",
".",
"Validator",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/oci/provider.go#L398-L410 |
3,865 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | NewMockLinkLayerDevice | func NewMockLinkLayerDevice(ctrl *gomock.Controller) *MockLinkLayerDevice {
mock := &MockLinkLayerDevice{ctrl: ctrl}
mock.recorder = &MockLinkLayerDeviceMockRecorder{mock}
return mock
} | go | func NewMockLinkLayerDevice(ctrl *gomock.Controller) *MockLinkLayerDevice {
mock := &MockLinkLayerDevice{ctrl: ctrl}
mock.recorder = &MockLinkLayerDeviceMockRecorder{mock}
return mock
} | [
"func",
"NewMockLinkLayerDevice",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockLinkLayerDevice",
"{",
"mock",
":=",
"&",
"MockLinkLayerDevice",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockLinkLayerDeviceMockRecor... | // NewMockLinkLayerDevice creates a new mock instance | [
"NewMockLinkLayerDevice",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L28-L32 |
3,866 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | Addresses | func (m *MockLinkLayerDevice) Addresses() ([]*state.Address, error) {
ret := m.ctrl.Call(m, "Addresses")
ret0, _ := ret[0].([]*state.Address)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLinkLayerDevice) Addresses() ([]*state.Address, error) {
ret := m.ctrl.Call(m, "Addresses")
ret0, _ := ret[0].([]*state.Address)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLinkLayerDevice",
")",
"Addresses",
"(",
")",
"(",
"[",
"]",
"*",
"state",
".",
"Address",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
... | // Addresses mocks base method | [
"Addresses",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L40-L45 |
3,867 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | Addresses | func (mr *MockLinkLayerDeviceMockRecorder) Addresses() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Addresses", reflect.TypeOf((*MockLinkLayerDevice)(nil).Addresses))
} | go | func (mr *MockLinkLayerDeviceMockRecorder) Addresses() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Addresses", reflect.TypeOf((*MockLinkLayerDevice)(nil).Addresses))
} | [
"func",
"(",
"mr",
"*",
"MockLinkLayerDeviceMockRecorder",
")",
"Addresses",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".... | // Addresses indicates an expected call of Addresses | [
"Addresses",
"indicates",
"an",
"expected",
"call",
"of",
"Addresses"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L48-L50 |
3,868 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | EthernetDeviceForBridge | func (m *MockLinkLayerDevice) EthernetDeviceForBridge(arg0 string) (state.LinkLayerDeviceArgs, error) {
ret := m.ctrl.Call(m, "EthernetDeviceForBridge", arg0)
ret0, _ := ret[0].(state.LinkLayerDeviceArgs)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLinkLayerDevice) EthernetDeviceForBridge(arg0 string) (state.LinkLayerDeviceArgs, error) {
ret := m.ctrl.Call(m, "EthernetDeviceForBridge", arg0)
ret0, _ := ret[0].(state.LinkLayerDeviceArgs)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLinkLayerDevice",
")",
"EthernetDeviceForBridge",
"(",
"arg0",
"string",
")",
"(",
"state",
".",
"LinkLayerDeviceArgs",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg... | // EthernetDeviceForBridge mocks base method | [
"EthernetDeviceForBridge",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L53-L58 |
3,869 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | EthernetDeviceForBridge | func (mr *MockLinkLayerDeviceMockRecorder) EthernetDeviceForBridge(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EthernetDeviceForBridge", reflect.TypeOf((*MockLinkLayerDevice)(nil).EthernetDeviceForBridge), arg0)
} | go | func (mr *MockLinkLayerDeviceMockRecorder) EthernetDeviceForBridge(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EthernetDeviceForBridge", reflect.TypeOf((*MockLinkLayerDevice)(nil).EthernetDeviceForBridge), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockLinkLayerDeviceMockRecorder",
")",
"EthernetDeviceForBridge",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"m... | // EthernetDeviceForBridge indicates an expected call of EthernetDeviceForBridge | [
"EthernetDeviceForBridge",
"indicates",
"an",
"expected",
"call",
"of",
"EthernetDeviceForBridge"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L61-L63 |
3,870 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | IsUp | func (m *MockLinkLayerDevice) IsUp() bool {
ret := m.ctrl.Call(m, "IsUp")
ret0, _ := ret[0].(bool)
return ret0
} | go | func (m *MockLinkLayerDevice) IsUp() bool {
ret := m.ctrl.Call(m, "IsUp")
ret0, _ := ret[0].(bool)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockLinkLayerDevice",
")",
"IsUp",
"(",
")",
"bool",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"... | // IsUp mocks base method | [
"IsUp",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L78-L82 |
3,871 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | MTU | func (m *MockLinkLayerDevice) MTU() uint {
ret := m.ctrl.Call(m, "MTU")
ret0, _ := ret[0].(uint)
return ret0
} | go | func (m *MockLinkLayerDevice) MTU() uint {
ret := m.ctrl.Call(m, "MTU")
ret0, _ := ret[0].(uint)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockLinkLayerDevice",
")",
"MTU",
"(",
")",
"uint",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"uint",
")",
"\n",
"r... | // MTU mocks base method | [
"MTU",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L102-L106 |
3,872 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | ParentDevice | func (m *MockLinkLayerDevice) ParentDevice() (containerizer.LinkLayerDevice, error) {
ret := m.ctrl.Call(m, "ParentDevice")
ret0, _ := ret[0].(containerizer.LinkLayerDevice)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLinkLayerDevice) ParentDevice() (containerizer.LinkLayerDevice, error) {
ret := m.ctrl.Call(m, "ParentDevice")
ret0, _ := ret[0].(containerizer.LinkLayerDevice)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLinkLayerDevice",
")",
"ParentDevice",
"(",
")",
"(",
"containerizer",
".",
"LinkLayerDevice",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
"... | // ParentDevice mocks base method | [
"ParentDevice",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L126-L131 |
3,873 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | NewMockUnit | func NewMockUnit(ctrl *gomock.Controller) *MockUnit {
mock := &MockUnit{ctrl: ctrl}
mock.recorder = &MockUnitMockRecorder{mock}
return mock
} | go | func NewMockUnit(ctrl *gomock.Controller) *MockUnit {
mock := &MockUnit{ctrl: ctrl}
mock.recorder = &MockUnitMockRecorder{mock}
return mock
} | [
"func",
"NewMockUnit",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockUnit",
"{",
"mock",
":=",
"&",
"MockUnit",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockUnitMockRecorder",
"{",
"mock",
"}",
"\n",
"ret... | // NewMockUnit creates a new mock instance | [
"NewMockUnit",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L174-L178 |
3,874 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | NewMockApplication | func NewMockApplication(ctrl *gomock.Controller) *MockApplication {
mock := &MockApplication{ctrl: ctrl}
mock.recorder = &MockApplicationMockRecorder{mock}
return mock
} | go | func NewMockApplication(ctrl *gomock.Controller) *MockApplication {
mock := &MockApplication{ctrl: ctrl}
mock.recorder = &MockApplicationMockRecorder{mock}
return mock
} | [
"func",
"NewMockApplication",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockApplication",
"{",
"mock",
":=",
"&",
"MockApplication",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockApplicationMockRecorder",
"{",
"... | // NewMockApplication creates a new mock instance | [
"NewMockApplication",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L222-L226 |
3,875 | juju/juju | apiserver/facades/agent/provisioner/mocks/containerizer_mock.go | NewMockCharm | func NewMockCharm(ctrl *gomock.Controller) *MockCharm {
mock := &MockCharm{ctrl: ctrl}
mock.recorder = &MockCharmMockRecorder{mock}
return mock
} | go | func NewMockCharm(ctrl *gomock.Controller) *MockCharm {
mock := &MockCharm{ctrl: ctrl}
mock.recorder = &MockCharmMockRecorder{mock}
return mock
} | [
"func",
"NewMockCharm",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockCharm",
"{",
"mock",
":=",
"&",
"MockCharm",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockCharmMockRecorder",
"{",
"mock",
"}",
"\n",
... | // NewMockCharm creates a new mock instance | [
"NewMockCharm",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/facades/agent/provisioner/mocks/containerizer_mock.go#L271-L275 |
3,876 | juju/juju | cmd/jujud/agent/agent.go | AddFlags | func (c *agentConf) AddFlags(f *gnuflag.FlagSet) {
// TODO(dimitern) 2014-02-19 bug 1282025
// We need to pass a config location here instead and
// use it to locate the conf and the infer the data-dir
// from there instead of passing it like that.
f.StringVar(&c.dataDir, "data-dir", util.DataDir, "directory for juju data")
} | go | func (c *agentConf) AddFlags(f *gnuflag.FlagSet) {
// TODO(dimitern) 2014-02-19 bug 1282025
// We need to pass a config location here instead and
// use it to locate the conf and the infer the data-dir
// from there instead of passing it like that.
f.StringVar(&c.dataDir, "data-dir", util.DataDir, "directory for juju data")
} | [
"func",
"(",
"c",
"*",
"agentConf",
")",
"AddFlags",
"(",
"f",
"*",
"gnuflag",
".",
"FlagSet",
")",
"{",
"// TODO(dimitern) 2014-02-19 bug 1282025",
"// We need to pass a config location here instead and",
"// use it to locate the conf and the infer the data-dir",
"// from there ... | // AddFlags injects common agent flags into f. | [
"AddFlags",
"injects",
"common",
"agent",
"flags",
"into",
"f",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/agent.go#L66-L72 |
3,877 | juju/juju | cmd/jujud/agent/agent.go | CheckArgs | func (c *agentConf) CheckArgs(args []string) error {
if c.dataDir == "" {
return util.RequiredError("data-dir")
}
return cmd.CheckEmpty(args)
} | go | func (c *agentConf) CheckArgs(args []string) error {
if c.dataDir == "" {
return util.RequiredError("data-dir")
}
return cmd.CheckEmpty(args)
} | [
"func",
"(",
"c",
"*",
"agentConf",
")",
"CheckArgs",
"(",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"c",
".",
"dataDir",
"==",
"\"",
"\"",
"{",
"return",
"util",
".",
"RequiredError",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"... | // CheckArgs reports whether the given args are valid for this agent. | [
"CheckArgs",
"reports",
"whether",
"the",
"given",
"args",
"are",
"valid",
"for",
"this",
"agent",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/agent.go#L75-L80 |
3,878 | juju/juju | cmd/jujud/agent/agent.go | ReadConfig | func (c *agentConf) ReadConfig(tag string) error {
t, err := names.ParseTag(tag)
if err != nil {
return errors.Trace(err)
}
c.mu.Lock()
defer c.mu.Unlock()
conf, err := agent.ReadConfig(agent.ConfigPath(c.dataDir, t))
if err != nil {
return errors.Trace(err)
}
c._config = conf
return nil
} | go | func (c *agentConf) ReadConfig(tag string) error {
t, err := names.ParseTag(tag)
if err != nil {
return errors.Trace(err)
}
c.mu.Lock()
defer c.mu.Unlock()
conf, err := agent.ReadConfig(agent.ConfigPath(c.dataDir, t))
if err != nil {
return errors.Trace(err)
}
c._config = conf
return nil
} | [
"func",
"(",
"c",
"*",
"agentConf",
")",
"ReadConfig",
"(",
"tag",
"string",
")",
"error",
"{",
"t",
",",
"err",
":=",
"names",
".",
"ParseTag",
"(",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
"... | // ReadConfig reads the agent's config from its config file. | [
"ReadConfig",
"reads",
"the",
"agent",
"s",
"config",
"from",
"its",
"config",
"file",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/agent.go#L88-L101 |
3,879 | juju/juju | cmd/jujud/agent/agent.go | ChangeConfig | func (c *agentConf) ChangeConfig(change agent.ConfigMutator) error {
c.mu.Lock()
defer c.mu.Unlock()
if err := change(c._config); err != nil {
return errors.Trace(err)
}
if err := c._config.Write(); err != nil {
return errors.Annotate(err, "cannot write agent configuration")
}
return nil
} | go | func (c *agentConf) ChangeConfig(change agent.ConfigMutator) error {
c.mu.Lock()
defer c.mu.Unlock()
if err := change(c._config); err != nil {
return errors.Trace(err)
}
if err := c._config.Write(); err != nil {
return errors.Annotate(err, "cannot write agent configuration")
}
return nil
} | [
"func",
"(",
"c",
"*",
"agentConf",
")",
"ChangeConfig",
"(",
"change",
"agent",
".",
"ConfigMutator",
")",
"error",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"err",
":=",
"cha... | // ChangeConfig modifies this configuration using the given mutator. | [
"ChangeConfig",
"modifies",
"this",
"configuration",
"using",
"the",
"given",
"mutator",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/agent.go#L104-L114 |
3,880 | juju/juju | cmd/jujud/agent/agent.go | CurrentConfig | func (c *agentConf) CurrentConfig() agent.Config {
c.mu.Lock()
defer c.mu.Unlock()
return c._config.Clone()
} | go | func (c *agentConf) CurrentConfig() agent.Config {
c.mu.Lock()
defer c.mu.Unlock()
return c._config.Clone()
} | [
"func",
"(",
"c",
"*",
"agentConf",
")",
"CurrentConfig",
"(",
")",
"agent",
".",
"Config",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"c",
".",
"_config",
".",
"Clone",
"... | // CurrentConfig returns the agent config for this agent. | [
"CurrentConfig",
"returns",
"the",
"agent",
"config",
"for",
"this",
"agent",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/agent.go#L117-L121 |
3,881 | juju/juju | cmd/jujud/agent/agent.go | GetJujuVersion | func GetJujuVersion(machineAgent string, dataDir string) (version.Number, error) {
agentConf := NewAgentConf(dataDir)
if err := agentConf.ReadConfig(machineAgent); err != nil {
err = errors.Annotate(err, "failed to read agent config file.")
return version.Number{}, err
}
config := agentConf.CurrentConfig()
if config == nil {
return version.Number{}, errors.Errorf("%s agent conf is not found", machineAgent)
}
return config.UpgradedToVersion(), nil
} | go | func GetJujuVersion(machineAgent string, dataDir string) (version.Number, error) {
agentConf := NewAgentConf(dataDir)
if err := agentConf.ReadConfig(machineAgent); err != nil {
err = errors.Annotate(err, "failed to read agent config file.")
return version.Number{}, err
}
config := agentConf.CurrentConfig()
if config == nil {
return version.Number{}, errors.Errorf("%s agent conf is not found", machineAgent)
}
return config.UpgradedToVersion(), nil
} | [
"func",
"GetJujuVersion",
"(",
"machineAgent",
"string",
",",
"dataDir",
"string",
")",
"(",
"version",
".",
"Number",
",",
"error",
")",
"{",
"agentConf",
":=",
"NewAgentConf",
"(",
"dataDir",
")",
"\n",
"if",
"err",
":=",
"agentConf",
".",
"ReadConfig",
... | // GetJujuVersion gets the version of the agent from agent's config file | [
"GetJujuVersion",
"gets",
"the",
"version",
"of",
"the",
"agent",
"from",
"agent",
"s",
"config",
"file"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/agent.go#L149-L160 |
3,882 | juju/juju | state/mocks/txn_mock.go | NewMockRunner | func NewMockRunner(ctrl *gomock.Controller) *MockRunner {
mock := &MockRunner{ctrl: ctrl}
mock.recorder = &MockRunnerMockRecorder{mock}
return mock
} | go | func NewMockRunner(ctrl *gomock.Controller) *MockRunner {
mock := &MockRunner{ctrl: ctrl}
mock.recorder = &MockRunnerMockRecorder{mock}
return mock
} | [
"func",
"NewMockRunner",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRunner",
"{",
"mock",
":=",
"&",
"MockRunner",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRunnerMockRecorder",
"{",
"mock",
"}",
"\n"... | // NewMockRunner creates a new mock instance | [
"NewMockRunner",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/txn_mock.go#L25-L29 |
3,883 | juju/juju | state/mocks/txn_mock.go | MaybePruneTransactions | func (m *MockRunner) MaybePruneTransactions(arg0 txn.PruneOptions) error {
ret := m.ctrl.Call(m, "MaybePruneTransactions", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockRunner) MaybePruneTransactions(arg0 txn.PruneOptions) error {
ret := m.ctrl.Call(m, "MaybePruneTransactions", arg0)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRunner",
")",
"MaybePruneTransactions",
"(",
"arg0",
"txn",
".",
"PruneOptions",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
... | // MaybePruneTransactions mocks base method | [
"MaybePruneTransactions",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/txn_mock.go#L37-L41 |
3,884 | juju/juju | state/mocks/txn_mock.go | ResumeTransactions | func (m *MockRunner) ResumeTransactions() error {
ret := m.ctrl.Call(m, "ResumeTransactions")
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockRunner) ResumeTransactions() error {
ret := m.ctrl.Call(m, "ResumeTransactions")
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRunner",
")",
"ResumeTransactions",
"(",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\... | // ResumeTransactions mocks base method | [
"ResumeTransactions",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/txn_mock.go#L49-L53 |
3,885 | juju/juju | state/mocks/txn_mock.go | ResumeTransactions | func (mr *MockRunnerMockRecorder) ResumeTransactions() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeTransactions", reflect.TypeOf((*MockRunner)(nil).ResumeTransactions))
} | go | func (mr *MockRunnerMockRecorder) ResumeTransactions() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeTransactions", reflect.TypeOf((*MockRunner)(nil).ResumeTransactions))
} | [
"func",
"(",
"mr",
"*",
"MockRunnerMockRecorder",
")",
"ResumeTransactions",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".... | // ResumeTransactions indicates an expected call of ResumeTransactions | [
"ResumeTransactions",
"indicates",
"an",
"expected",
"call",
"of",
"ResumeTransactions"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/txn_mock.go#L56-L58 |
3,886 | juju/juju | state/mocks/txn_mock.go | Run | func (m *MockRunner) Run(arg0 txn.TransactionSource) error {
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockRunner) Run(arg0 txn.TransactionSource) error {
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRunner",
")",
"Run",
"(",
"arg0",
"txn",
".",
"TransactionSource",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",... | // Run mocks base method | [
"Run",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/txn_mock.go#L61-L65 |
3,887 | juju/juju | state/mocks/txn_mock.go | Run | func (mr *MockRunnerMockRecorder) Run(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockRunner)(nil).Run), arg0)
} | go | func (mr *MockRunnerMockRecorder) Run(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockRunner)(nil).Run), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockRunnerMockRecorder",
")",
"Run",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
... | // Run indicates an expected call of Run | [
"Run",
"indicates",
"an",
"expected",
"call",
"of",
"Run"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/mocks/txn_mock.go#L68-L70 |
3,888 | juju/juju | worker/instancemutater/mocks/environs_mock.go | NewMockEnviron | func NewMockEnviron(ctrl *gomock.Controller) *MockEnviron {
mock := &MockEnviron{ctrl: ctrl}
mock.recorder = &MockEnvironMockRecorder{mock}
return mock
} | go | func NewMockEnviron(ctrl *gomock.Controller) *MockEnviron {
mock := &MockEnviron{ctrl: ctrl}
mock.recorder = &MockEnvironMockRecorder{mock}
return mock
} | [
"func",
"NewMockEnviron",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockEnviron",
"{",
"mock",
":=",
"&",
"MockEnviron",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockEnvironMockRecorder",
"{",
"mock",
"}",
... | // NewMockEnviron creates a new mock instance | [
"NewMockEnviron",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/instancemutater/mocks/environs_mock.go#L34-L38 |
3,889 | juju/juju | worker/instancemutater/mocks/environs_mock.go | AllInstances | func (m *MockEnviron) AllInstances(arg0 context.ProviderCallContext) ([]instances.Instance, error) {
ret := m.ctrl.Call(m, "AllInstances", arg0)
ret0, _ := ret[0].([]instances.Instance)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockEnviron) AllInstances(arg0 context.ProviderCallContext) ([]instances.Instance, error) {
ret := m.ctrl.Call(m, "AllInstances", arg0)
ret0, _ := ret[0].([]instances.Instance)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockEnviron",
")",
"AllInstances",
"(",
"arg0",
"context",
".",
"ProviderCallContext",
")",
"(",
"[",
"]",
"instances",
".",
"Instance",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
... | // AllInstances mocks base method | [
"AllInstances",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/instancemutater/mocks/environs_mock.go#L58-L63 |
3,890 | juju/juju | worker/instancemutater/mocks/environs_mock.go | Bootstrap | func (m *MockEnviron) Bootstrap(arg0 environs.BootstrapContext, arg1 context.ProviderCallContext, arg2 environs.BootstrapParams) (*environs.BootstrapResult, error) {
ret := m.ctrl.Call(m, "Bootstrap", arg0, arg1, arg2)
ret0, _ := ret[0].(*environs.BootstrapResult)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockEnviron) Bootstrap(arg0 environs.BootstrapContext, arg1 context.ProviderCallContext, arg2 environs.BootstrapParams) (*environs.BootstrapResult, error) {
ret := m.ctrl.Call(m, "Bootstrap", arg0, arg1, arg2)
ret0, _ := ret[0].(*environs.BootstrapResult)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockEnviron",
")",
"Bootstrap",
"(",
"arg0",
"environs",
".",
"BootstrapContext",
",",
"arg1",
"context",
".",
"ProviderCallContext",
",",
"arg2",
"environs",
".",
"BootstrapParams",
")",
"(",
"*",
"environs",
".",
"BootstrapResult",
",... | // Bootstrap mocks base method | [
"Bootstrap",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/instancemutater/mocks/environs_mock.go#L71-L76 |
3,891 | juju/juju | worker/instancemutater/mocks/environs_mock.go | ControllerInstances | func (m *MockEnviron) ControllerInstances(arg0 context.ProviderCallContext, arg1 string) ([]instance.Id, error) {
ret := m.ctrl.Call(m, "ControllerInstances", arg0, arg1)
ret0, _ := ret[0].([]instance.Id)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockEnviron) ControllerInstances(arg0 context.ProviderCallContext, arg1 string) ([]instance.Id, error) {
ret := m.ctrl.Call(m, "ControllerInstances", arg0, arg1)
ret0, _ := ret[0].([]instance.Id)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockEnviron",
")",
"ControllerInstances",
"(",
"arg0",
"context",
".",
"ProviderCallContext",
",",
"arg1",
"string",
")",
"(",
"[",
"]",
"instance",
".",
"Id",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
... | // ControllerInstances mocks base method | [
"ControllerInstances",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/instancemutater/mocks/environs_mock.go#L109-L114 |
3,892 | juju/juju | worker/instancemutater/mocks/environs_mock.go | DestroyController | func (mr *MockEnvironMockRecorder) DestroyController(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyController", reflect.TypeOf((*MockEnviron)(nil).DestroyController), arg0, arg1)
} | go | func (mr *MockEnvironMockRecorder) DestroyController(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyController", reflect.TypeOf((*MockEnviron)(nil).DestroyController), arg0, arg1)
} | [
"func",
"(",
"mr",
"*",
"MockEnvironMockRecorder",
")",
"DestroyController",
"(",
"arg0",
",",
"arg1",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
... | // DestroyController indicates an expected call of DestroyController | [
"DestroyController",
"indicates",
"an",
"expected",
"call",
"of",
"DestroyController"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/instancemutater/mocks/environs_mock.go#L153-L155 |
3,893 | juju/juju | worker/instancemutater/mocks/environs_mock.go | Provider | func (mr *MockEnvironMockRecorder) Provider() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provider", reflect.TypeOf((*MockEnviron)(nil).Provider))
} | go | func (mr *MockEnvironMockRecorder) Provider() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provider", reflect.TypeOf((*MockEnviron)(nil).Provider))
} | [
"func",
"(",
"mr",
"*",
"MockEnvironMockRecorder",
")",
"Provider",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"Typ... | // Provider indicates an expected call of Provider | [
"Provider",
"indicates",
"an",
"expected",
"call",
"of",
"Provider"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/instancemutater/mocks/environs_mock.go#L227-L229 |
3,894 | juju/juju | caas/kubernetes/provider/k8s.go | NewK8sBroker | func NewK8sBroker(
controllerUUID string,
k8sRestConfig *rest.Config,
cfg *config.Config,
newClient NewK8sClientFunc,
newWatcher NewK8sWatcherFunc,
clock jujuclock.Clock,
) (*kubernetesClient, error) {
k8sClient, apiextensionsClient, err := newClient(k8sRestConfig)
if err != nil {
return nil, errors.Trace(err)
}
newCfg, err := providerInstance.newConfig(cfg)
if err != nil {
return nil, errors.Trace(err)
}
modelUUID := newCfg.UUID()
if modelUUID == "" {
return nil, errors.NotValidf("modelUUID is required")
}
client := &kubernetesClient{
clock: clock,
clientUnlocked: k8sClient,
apiextensionsClientUnlocked: apiextensionsClient,
envCfgUnlocked: newCfg.Config,
namespace: newCfg.Name(),
modelUUID: modelUUID,
newWatcher: newWatcher,
newClient: newClient,
annotations: k8sannotations.New(nil).
Add(annotationModelUUIDKey, modelUUID),
}
if controllerUUID != "" {
// controllerUUID could be empty in add-k8s without -c because there might be no controller yet.
client.annotations.Add(annotationControllerUUIDKey, controllerUUID)
}
return client, nil
} | go | func NewK8sBroker(
controllerUUID string,
k8sRestConfig *rest.Config,
cfg *config.Config,
newClient NewK8sClientFunc,
newWatcher NewK8sWatcherFunc,
clock jujuclock.Clock,
) (*kubernetesClient, error) {
k8sClient, apiextensionsClient, err := newClient(k8sRestConfig)
if err != nil {
return nil, errors.Trace(err)
}
newCfg, err := providerInstance.newConfig(cfg)
if err != nil {
return nil, errors.Trace(err)
}
modelUUID := newCfg.UUID()
if modelUUID == "" {
return nil, errors.NotValidf("modelUUID is required")
}
client := &kubernetesClient{
clock: clock,
clientUnlocked: k8sClient,
apiextensionsClientUnlocked: apiextensionsClient,
envCfgUnlocked: newCfg.Config,
namespace: newCfg.Name(),
modelUUID: modelUUID,
newWatcher: newWatcher,
newClient: newClient,
annotations: k8sannotations.New(nil).
Add(annotationModelUUIDKey, modelUUID),
}
if controllerUUID != "" {
// controllerUUID could be empty in add-k8s without -c because there might be no controller yet.
client.annotations.Add(annotationControllerUUIDKey, controllerUUID)
}
return client, nil
} | [
"func",
"NewK8sBroker",
"(",
"controllerUUID",
"string",
",",
"k8sRestConfig",
"*",
"rest",
".",
"Config",
",",
"cfg",
"*",
"config",
".",
"Config",
",",
"newClient",
"NewK8sClientFunc",
",",
"newWatcher",
"NewK8sWatcherFunc",
",",
"clock",
"jujuclock",
".",
"Cl... | // NewK8sBroker returns a kubernetes client for the specified k8s cluster. | [
"NewK8sBroker",
"returns",
"a",
"kubernetes",
"client",
"for",
"the",
"specified",
"k8s",
"cluster",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/k8s.go#L123-L163 |
3,895 | juju/juju | caas/kubernetes/provider/k8s.go | addAnnotations | func (k *kubernetesClient) addAnnotations(key, value string) k8sannotations.Annotation {
return k.annotations.Add(key, value)
} | go | func (k *kubernetesClient) addAnnotations(key, value string) k8sannotations.Annotation {
return k.annotations.Add(key, value)
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"addAnnotations",
"(",
"key",
",",
"value",
"string",
")",
"k8sannotations",
".",
"Annotation",
"{",
"return",
"k",
".",
"annotations",
".",
"Add",
"(",
"key",
",",
"value",
")",
"\n",
"}"
] | // addAnnotations set an annotation to current namespace's annotations. | [
"addAnnotations",
"set",
"an",
"annotation",
"to",
"current",
"namespace",
"s",
"annotations",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/k8s.go#L171-L173 |
3,896 | juju/juju | caas/kubernetes/provider/k8s.go | Config | func (k *kubernetesClient) Config() *config.Config {
k.lock.Lock()
defer k.lock.Unlock()
cfg := k.envCfgUnlocked
return cfg
} | go | func (k *kubernetesClient) Config() *config.Config {
k.lock.Lock()
defer k.lock.Unlock()
cfg := k.envCfgUnlocked
return cfg
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"Config",
"(",
")",
"*",
"config",
".",
"Config",
"{",
"k",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"k",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"cfg",
":=",
"k",
".",
"envCfgUnlocked... | // Config returns environ config. | [
"Config",
"returns",
"environ",
"config",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/k8s.go#L190-L195 |
3,897 | juju/juju | caas/kubernetes/provider/k8s.go | PrepareForBootstrap | func (k *kubernetesClient) PrepareForBootstrap(ctx environs.BootstrapContext, controllerName string) error {
alreadyExistErr := errors.NewAlreadyExists(nil,
fmt.Sprintf(`a controller called %q already exists on this k8s cluster.
Please bootstrap again and choose a different controller name.`, controllerName),
)
k.namespace = DecideControllerNamespace(controllerName)
// ensure no existing namespace has the same name.
_, err := k.getNamespaceByName(k.namespace)
if err == nil {
return alreadyExistErr
}
if !errors.IsNotFound(err) {
return errors.Trace(err)
}
// Good, no existing namespace has the same name.
// Now, try to find if there is any existing controller running in this cluster.
// Note: we have to do this check before we are confident to support multi controllers running in same k8s cluster.
_, err = k.listNamespacesByAnnotations(k.annotations)
if err == nil {
return alreadyExistErr
}
if !errors.IsNotFound(err) {
return errors.Trace(err)
}
// All good, no existing controller found on the cluster.
// The namespace will be set to controller-name in newcontrollerStack.
// do validation on storage class.
_, err = k.validateOperatorStorage()
return errors.Trace(err)
} | go | func (k *kubernetesClient) PrepareForBootstrap(ctx environs.BootstrapContext, controllerName string) error {
alreadyExistErr := errors.NewAlreadyExists(nil,
fmt.Sprintf(`a controller called %q already exists on this k8s cluster.
Please bootstrap again and choose a different controller name.`, controllerName),
)
k.namespace = DecideControllerNamespace(controllerName)
// ensure no existing namespace has the same name.
_, err := k.getNamespaceByName(k.namespace)
if err == nil {
return alreadyExistErr
}
if !errors.IsNotFound(err) {
return errors.Trace(err)
}
// Good, no existing namespace has the same name.
// Now, try to find if there is any existing controller running in this cluster.
// Note: we have to do this check before we are confident to support multi controllers running in same k8s cluster.
_, err = k.listNamespacesByAnnotations(k.annotations)
if err == nil {
return alreadyExistErr
}
if !errors.IsNotFound(err) {
return errors.Trace(err)
}
// All good, no existing controller found on the cluster.
// The namespace will be set to controller-name in newcontrollerStack.
// do validation on storage class.
_, err = k.validateOperatorStorage()
return errors.Trace(err)
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"PrepareForBootstrap",
"(",
"ctx",
"environs",
".",
"BootstrapContext",
",",
"controllerName",
"string",
")",
"error",
"{",
"alreadyExistErr",
":=",
"errors",
".",
"NewAlreadyExists",
"(",
"nil",
",",
"fmt",
".",
... | // PrepareForBootstrap prepares for bootstraping a controller. | [
"PrepareForBootstrap",
"prepares",
"for",
"bootstraping",
"a",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/k8s.go#L236-L269 |
3,898 | juju/juju | caas/kubernetes/provider/k8s.go | Create | func (k *kubernetesClient) Create(context.ProviderCallContext, environs.CreateParams) error {
// must raise errors.AlreadyExistsf if it's already exist.
return k.createNamespace(k.namespace)
} | go | func (k *kubernetesClient) Create(context.ProviderCallContext, environs.CreateParams) error {
// must raise errors.AlreadyExistsf if it's already exist.
return k.createNamespace(k.namespace)
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"Create",
"(",
"context",
".",
"ProviderCallContext",
",",
"environs",
".",
"CreateParams",
")",
"error",
"{",
"// must raise errors.AlreadyExistsf if it's already exist.",
"return",
"k",
".",
"createNamespace",
"(",
"k"... | // Create implements environs.BootstrapEnviron. | [
"Create",
"implements",
"environs",
".",
"BootstrapEnviron",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/k8s.go#L272-L275 |
3,899 | juju/juju | caas/kubernetes/provider/k8s.go | Bootstrap | func (k *kubernetesClient) Bootstrap(
ctx environs.BootstrapContext,
callCtx context.ProviderCallContext,
args environs.BootstrapParams,
) (*environs.BootstrapResult, error) {
if args.BootstrapSeries != "" {
return nil, errors.NotSupportedf("set series for bootstrapping to kubernetes")
}
storageClass, err := k.validateOperatorStorage()
if err != nil {
return nil, errors.Trace(err)
}
finalizer := func(ctx environs.BootstrapContext, pcfg *podcfg.ControllerPodConfig, opts environs.BootstrapDialOpts) (err error) {
if err = podcfg.FinishControllerPodConfig(pcfg, k.Config()); err != nil {
return errors.Trace(err)
}
if err = pcfg.VerifyConfig(); err != nil {
return errors.Trace(err)
}
logger.Debugf("controller pod config: \n%+v", pcfg)
// validate hosted model name if we need to create it.
if hostedModelName, has := pcfg.GetHostedModel(); has {
_, err := k.getNamespaceByName(hostedModelName)
if err == nil {
return errors.NewAlreadyExists(nil,
fmt.Sprintf(`
namespace %q already exists in the cluster,
please choose a different hosted model name then try again.`, hostedModelName),
)
}
if !errors.IsNotFound(err) {
return errors.Trace(err)
}
// hosted model is all good.
}
// we use controller name to name controller namespace in bootstrap time.
setControllerNamespace := func(controllerName string, broker *kubernetesClient) error {
nsName := DecideControllerNamespace(controllerName)
_, err := broker.GetNamespace(nsName)
if errors.IsNotFound(err) {
// all good.
broker.SetNamespace(nsName)
// ensure controller specific annotations.
_ = broker.addAnnotations(annotationControllerIsControllerKey, "true")
return nil
}
if err == nil {
// this should never happen because we avoid it in broker.PrepareForBootstrap before reaching here.
return errors.NotValidf("existing namespace %q found", broker.namespace)
}
return errors.Trace(err)
}
if err := setControllerNamespace(pcfg.ControllerName, k); err != nil {
return errors.Trace(err)
}
// create configmap, secret, volume, statefulset, etc resources for controller stack.
controllerStack, err := newcontrollerStack(ctx, JujuControllerStackName, storageClass, k, pcfg)
if err != nil {
return errors.Trace(err)
}
return errors.Annotate(
controllerStack.Deploy(),
"creating controller stack for controller",
)
}
return &environs.BootstrapResult{
// TODO(bootstrap): review this default arch and series(required for determining DataDir etc.) later.
Arch: arch.AMD64,
Series: jujuversion.SupportedLTS(),
CaasBootstrapFinalizer: finalizer,
}, nil
} | go | func (k *kubernetesClient) Bootstrap(
ctx environs.BootstrapContext,
callCtx context.ProviderCallContext,
args environs.BootstrapParams,
) (*environs.BootstrapResult, error) {
if args.BootstrapSeries != "" {
return nil, errors.NotSupportedf("set series for bootstrapping to kubernetes")
}
storageClass, err := k.validateOperatorStorage()
if err != nil {
return nil, errors.Trace(err)
}
finalizer := func(ctx environs.BootstrapContext, pcfg *podcfg.ControllerPodConfig, opts environs.BootstrapDialOpts) (err error) {
if err = podcfg.FinishControllerPodConfig(pcfg, k.Config()); err != nil {
return errors.Trace(err)
}
if err = pcfg.VerifyConfig(); err != nil {
return errors.Trace(err)
}
logger.Debugf("controller pod config: \n%+v", pcfg)
// validate hosted model name if we need to create it.
if hostedModelName, has := pcfg.GetHostedModel(); has {
_, err := k.getNamespaceByName(hostedModelName)
if err == nil {
return errors.NewAlreadyExists(nil,
fmt.Sprintf(`
namespace %q already exists in the cluster,
please choose a different hosted model name then try again.`, hostedModelName),
)
}
if !errors.IsNotFound(err) {
return errors.Trace(err)
}
// hosted model is all good.
}
// we use controller name to name controller namespace in bootstrap time.
setControllerNamespace := func(controllerName string, broker *kubernetesClient) error {
nsName := DecideControllerNamespace(controllerName)
_, err := broker.GetNamespace(nsName)
if errors.IsNotFound(err) {
// all good.
broker.SetNamespace(nsName)
// ensure controller specific annotations.
_ = broker.addAnnotations(annotationControllerIsControllerKey, "true")
return nil
}
if err == nil {
// this should never happen because we avoid it in broker.PrepareForBootstrap before reaching here.
return errors.NotValidf("existing namespace %q found", broker.namespace)
}
return errors.Trace(err)
}
if err := setControllerNamespace(pcfg.ControllerName, k); err != nil {
return errors.Trace(err)
}
// create configmap, secret, volume, statefulset, etc resources for controller stack.
controllerStack, err := newcontrollerStack(ctx, JujuControllerStackName, storageClass, k, pcfg)
if err != nil {
return errors.Trace(err)
}
return errors.Annotate(
controllerStack.Deploy(),
"creating controller stack for controller",
)
}
return &environs.BootstrapResult{
// TODO(bootstrap): review this default arch and series(required for determining DataDir etc.) later.
Arch: arch.AMD64,
Series: jujuversion.SupportedLTS(),
CaasBootstrapFinalizer: finalizer,
}, nil
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"Bootstrap",
"(",
"ctx",
"environs",
".",
"BootstrapContext",
",",
"callCtx",
"context",
".",
"ProviderCallContext",
",",
"args",
"environs",
".",
"BootstrapParams",
",",
")",
"(",
"*",
"environs",
".",
"Bootstra... | // Bootstrap deploys controller with mongoDB together into k8s cluster. | [
"Bootstrap",
"deploys",
"controller",
"with",
"mongoDB",
"together",
"into",
"k8s",
"cluster",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/k8s.go#L278-L360 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.