func unitMatchSubnet(u *state.Unit, patterns []string) (bool, bool, error) {
pub, pubErr := u.PublicAddress()
if pubErr != nil && !network.IsNoAddress(pubErr) {
return true, false, errors.Trace(pubErr)
}
priv, privErr := u.PrivateAddress()
if privErr != nil && !network.IsNoAddress(privErr) {
return true, false, errors.Trace(privErr)
}
if pubErr != nil && privErr != nil {
return true, false, nil
}
return matchSubnet(patterns, pub.Value, priv.Value)
}
// PrivateAddress returns the private address for each given unit, if set.
func (u *UniterAPIV3) PrivateAddress(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var address network.Address
address, err = unit.PrivateAddress()
if err == nil {
result.Results[i].Result = address.Value
} else if network.IsNoAddress(err) {
err = common.NoAddressSetError(tag, "private")
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// runMachineUpdate connects via ssh to the machine and runs the update script.
func runMachineUpdate(machine *state.Machine, sshArg string) error {
addr, err := machine.PublicAddress()
if err != nil {
if network.IsNoAddress(err) {
return errors.Annotatef(err, "no appropriate public address found")
}
return errors.Trace(err)
}
return runViaSSH(addr.Value, sshArg)
}
func (s *NetworkSuite) TestNoAddressError(c *gc.C) {
err := network.NoAddressf("boom")
c.Assert(err, gc.ErrorMatches, "boom no address")
c.Assert(network.IsNoAddress(err), jc.IsTrue)
c.Assert(network.IsNoAddress(errors.New("address found")), jc.IsFalse)
}
func (u *UniterAPIV3) getOneNetworkConfig(canAccess common.AuthFunc, unitTagArg, bindingName string) ([]params.NetworkConfig, error) {
unitTag, err := names.ParseUnitTag(unitTagArg)
if err != nil {
return nil, errors.Trace(err)
}
if bindingName == "" {
return nil, errors.Errorf("binding name cannot be empty")
}
if !canAccess(unitTag) {
return nil, common.ErrPerm
}
unit, err := u.getUnit(unitTag)
if err != nil {
return nil, errors.Trace(err)
}
service, err := unit.Service()
if err != nil {
return nil, errors.Trace(err)
}
bindings, err := service.EndpointBindings()
if err != nil {
return nil, errors.Trace(err)
}
boundSpace, known := bindings[bindingName]
if !known {
return nil, errors.Errorf("binding name %q not defined by the unit's charm", bindingName)
}
machineID, err := unit.AssignedMachineId()
if err != nil {
return nil, errors.Trace(err)
}
machine, err := u.st.Machine(machineID)
if err != nil {
return nil, errors.Trace(err)
}
var results []params.NetworkConfig
if boundSpace == "" {
logger.Debugf(
"endpoint %q not explicitly bound to a space, using preferred private address for machine %q",
bindingName, machineID,
)
privateAddress, err := machine.PrivateAddress()
if err != nil && !network.IsNoAddress(err) {
return nil, errors.Annotatef(err, "getting machine %q preferred private address", machineID)
}
results = append(results, params.NetworkConfig{
Address: privateAddress.Value,
})
return results, nil
} else {
logger.Debugf("endpoint %q is explicitly bound to space %q", bindingName, boundSpace)
}
// TODO(dimitern): Use NetworkInterfaces() instead later, this is just for
// the PoC to enable minimal network-get implementation returning just the
// primary address.
//
// LKK Card: https://canonical.leankit.com/Boards/View/101652562/119258804
addresses, err := machine.AllAddresses()
if err != nil {
return nil, errors.Annotate(err, "cannot get devices addresses")
}
logger.Infof(
"geting network config for machine %q with addresses %+v, hosting unit %q of service %q, with bindings %+v",
machineID, addresses, unit.Name(), service.Name(), bindings,
)
for _, addr := range addresses {
subnet, err := addr.Subnet()
if err != nil {
return nil, errors.Annotatef(err, "cannot get subnet for address %q", addr)
}
if subnet == nil {
logger.Debugf("skipping %s: not linked to a known subnet", addr)
continue
}
if space := subnet.SpaceName(); space != boundSpace {
logger.Debugf("skipping %s: want bound to space %q, got space %q", addr, boundSpace, space)
continue
}
logger.Debugf("endpoint %q bound to space %q has address %q", bindingName, boundSpace, addr)
// TODO(dimitern): Fill in the rest later (see linked LKK card above).
results = append(results, params.NetworkConfig{
Address: addr.Value(),
})
}
return results, nil
}
