// PrivateAddress implements the server side of Client.PrivateAddress.
func (c *Client) PrivateAddress(p params.PrivateAddress) (results params.PrivateAddressResults, err error) {
switch {
case names.IsMachine(p.Target):
machine, err := c.api.state.Machine(p.Target)
if err != nil {
return results, err
}
addr := instance.SelectInternalAddress(machine.Addresses(), false)
if addr == "" {
return results, fmt.Errorf("machine %q has no internal address", machine)
}
return params.PrivateAddressResults{PrivateAddress: addr}, nil
case names.IsUnit(p.Target):
unit, err := c.api.state.Unit(p.Target)
if err != nil {
return results, err
}
addr, ok := unit.PrivateAddress()
if !ok {
return results, fmt.Errorf("unit %q has no internal address", unit)
}
return params.PrivateAddressResults{PrivateAddress: addr}, nil
}
return results, fmt.Errorf("unknown unit or machine %q", p.Target)
}
// Unit returns the service's unit with name.
func (s *Service) Unit(name string) (*Unit, error) {
if !names.IsUnit(name) {
return nil, fmt.Errorf("%q is not a valid unit name", name)
}
udoc := &unitDoc{}
sel := bson.D{{"_id", name}, {"service", s.doc.Name}}
if err := s.st.units.Find(sel).One(udoc); err != nil {
return nil, fmt.Errorf("cannot get unit %q from service %q: %v", name, s.doc.Name, err)
}
return newUnit(s.st, udoc), nil
}
func (c *ResolvedCommand) Init(args []string) error {
if len(args) > 0 {
c.UnitName = args[0]
if !names.IsUnit(c.UnitName) {
return fmt.Errorf("invalid unit name %q", c.UnitName)
}
args = args[1:]
} else {
return fmt.Errorf("no unit specified")
}
return cmd.CheckEmpty(args)
}
// Init initializes the command for running.
func (a *UnitAgent) Init(args []string) error {
if a.UnitName == "" {
return requiredError("unit-name")
}
if !names.IsUnit(a.UnitName) {
return fmt.Errorf(`--unit-name option expects "<service>/<n>" argument`)
}
if err := a.AgentConf.CheckArgs(args); err != nil {
return err
}
a.runner = worker.NewRunner(isFatal, moreImportant)
return nil
}
// Unit returns a unit by name.
func (st *State) Unit(name string) (*Unit, error) {
if !names.IsUnit(name) {
return nil, fmt.Errorf("%q is not a valid unit name", name)
}
doc := unitDoc{}
err := st.units.FindId(name).One(&doc)
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("unit %q", name)
}
if err != nil {
return nil, fmt.Errorf("cannot get unit %q: %v", name, err)
}
return newUnit(st, &doc), nil
}
// ReadSettings returns a map holding the settings of the unit with the
// supplied name within this relation. An error will be returned if the
// relation no longer exists, or if the unit's service is not part of the
// relation, or the settings are invalid; but mere non-existence of the
// unit is not grounds for an error, because the unit settings are
// guaranteed to persist for the lifetime of the relation, regardless
// of the lifetime of the unit.
func (ru *RelationUnit) ReadSettings(uname string) (m map[string]interface{}, err error) {
defer errors.Maskf(&err, "cannot read settings for unit %q in relation %q", uname, ru.relation)
if !names.IsUnit(uname) {
return nil, fmt.Errorf("%q is not a valid unit name", uname)
}
key, err := ru.key(uname)
if err != nil {
return nil, err
}
node, err := readSettings(ru.st, key)
if err != nil {
return nil, err
}
return node.Map(), nil
}
func (ctx *SimpleContext) deployedUnitsUpstartJobs() (map[string]string, error) {
fis, err := ioutil.ReadDir(ctx.initDir)
if err != nil {
return nil, err
}
installed := make(map[string]string)
for _, fi := range fis {
if groups := deployedRe.FindStringSubmatch(fi.Name()); len(groups) == 4 {
unitName := groups[2] + "/" + groups[3]
if !names.IsUnit(unitName) {
continue
}
installed[unitName] = groups[1]
}
}
return installed, nil
}