func (stringSetSuite) TestIntersection(c *C) {
s1 := set.NewStrings("foo", "bar")
s2 := set.NewStrings("foo", "baz", "bang")
int1 := s1.Intersection(s2)
int2 := s2.Intersection(s1)
AssertValues(c, int1, "foo")
AssertValues(c, int2, "foo")
}
func (stringSetSuite) TestDifference(c *C) {
s1 := set.NewStrings("foo", "bar")
s2 := set.NewStrings("foo", "baz", "bang")
diff1 := s1.Difference(s2)
diff2 := s2.Difference(s1)
AssertValues(c, diff1, "bar")
AssertValues(c, diff2, "baz", "bang")
}
func (stringSetSuite) TestSize(c *C) {
// Empty sets are empty.
s := set.NewStrings()
c.Assert(s.Size(), Equals, 0)
// Size returns number of unique values.
s = set.NewStrings("foo", "foo", "bar")
c.Assert(s.Size(), Equals, 2)
}
func (stringSetSuite) TestUnion(c *C) {
s1 := set.NewStrings("foo", "bar")
s2 := set.NewStrings("foo", "baz", "bang")
union1 := s1.Union(s2)
union2 := s2.Union(s1)
AssertValues(c, union1, "foo", "bar", "baz", "bang")
AssertValues(c, union2, "foo", "bar", "baz", "bang")
}
func (stringSetSuite) TestIsEmpty(c *C) {
// Empty sets are empty.
s := set.NewStrings()
c.Assert(s.IsEmpty(), Equals, true)
// Non-empty sets are not empty.
s = set.NewStrings("foo")
c.Assert(s.IsEmpty(), Equals, false)
// Newly empty sets work too.
s.Remove("foo")
c.Assert(s.IsEmpty(), Equals, true)
}
// NewDeployerAPI creates a new client-side DeployerAPI facade.
func NewDeployerAPI(
st *state.State,
resources *common.Resources,
authorizer common.Authorizer,
) (*DeployerAPI, error) {
if !authorizer.AuthMachineAgent() {
return nil, common.ErrPerm
}
getAuthFunc := func() (common.AuthFunc, error) {
// Get all units of the machine and cache them.
knownUnits := set.NewStrings()
thisMachineTag := authorizer.GetAuthTag()
if units, err := getAllUnits(st, thisMachineTag); err != nil {
return nil, err
} else {
for _, unit := range units {
knownUnits.Add(unit)
}
}
// Then we just check if the unit is already known.
return func(tag string) bool {
unitName := state.UnitNameFromTag(tag)
return knownUnits.Contains(unitName)
}, nil
}
return &DeployerAPI{
Remover: common.NewRemover(st, getAuthFunc),
PasswordChanger: common.NewPasswordChanger(st, getAuthFunc),
LifeGetter: common.NewLifeGetter(st, getAuthFunc),
st: st,
resources: resources,
authorizer: authorizer,
}, nil
}
func (*statusContext) processRelations(service *state.Service) (related map[string][]string, subord []string, err error) {
// TODO(mue) This way the same relation is read twice (for each service).
// Maybe add Relations() to state, read them only once and pass them to each
// call of this function.
relations, err := service.Relations()
if err != nil {
return nil, nil, err
}
var subordSet set.Strings
related = make(map[string][]string)
for _, relation := range relations {
ep, err := relation.Endpoint(service.Name())
if err != nil {
return nil, nil, err
}
relationName := ep.Relation.Name
eps, err := relation.RelatedEndpoints(service.Name())
if err != nil {
return nil, nil, err
}
for _, ep := range eps {
if ep.Scope == charm.ScopeContainer && !service.IsPrincipal() {
subordSet.Add(ep.ServiceName)
}
related[relationName] = append(related[relationName], ep.ServiceName)
}
}
for relationName, serviceNames := range related {
sn := set.NewStrings(serviceNames...)
related[relationName] = sn.SortedValues()
}
return related, subordSet.SortedValues(), nil
}
func (stringSetSuite) TestAdd(c *C) {
s := set.NewStrings()
s.Add("foo")
s.Add("foo")
s.Add("bar")
AssertValues(c, s, "foo", "bar")
}
// checkStopInstances checks that an instance has been stopped.
func (s *CommonProvisionerSuite) checkStopInstances(c *C, instances ...instance.Instance) {
s.State.StartSync()
instanceIds := set.NewStrings()
for _, instance := range instances {
instanceIds.Add(string(instance.Id()))
}
// Continue checking for stop instance calls until all the instances we
// are waiting on to finish, actually finish, or we time out.
for !instanceIds.IsEmpty() {
select {
case o := <-s.op:
switch o := o.(type) {
case dummy.OpStopInstances:
for _, stoppedInstance := range o.Instances {
instanceIds.Remove(string(stoppedInstance.Id()))
}
default:
c.Fatalf("unexpected operation %#v", o)
return
}
case <-time.After(2 * time.Second):
c.Fatalf("provisioner did not stop an instance")
return
}
}
}
func (s *DeployLocalSuite) assertMachines(c *C, service *state.Service, expectCons constraints.Value, expectIds ...string) {
units, err := service.AllUnits()
c.Assert(err, IsNil)
c.Assert(units, HasLen, len(expectIds))
unseenIds := set.NewStrings(expectIds...)
for _, unit := range units {
id, err := unit.AssignedMachineId()
c.Assert(err, IsNil)
unseenIds.Remove(id)
machine, err := s.State.Machine(id)
c.Assert(err, IsNil)
cons, err := machine.Constraints()
c.Assert(err, IsNil)
c.Assert(cons, DeepEquals, expectCons)
}
c.Assert(unseenIds, DeepEquals, set.NewStrings())
}
func (stringSetSuite) TestUninitialized(c *C) {
var uninitialized set.Strings
c.Assert(uninitialized.Size(), Equals, 0)
c.Assert(uninitialized.IsEmpty(), Equals, true)
// You can get values and sorted values from an unitialized set.
AssertValues(c, uninitialized)
// All contains checks are false
c.Assert(uninitialized.Contains("foo"), Equals, false)
// Remove works on an uninitialized Strings
uninitialized.Remove("foo")
var other set.Strings
// Union returns a new set that is empty but initialized.
c.Assert(uninitialized.Union(other), DeepEquals, set.NewStrings())
c.Assert(uninitialized.Intersection(other), DeepEquals, set.NewStrings())
c.Assert(uninitialized.Difference(other), DeepEquals, set.NewStrings())
other = set.NewStrings("foo", "bar")
c.Assert(uninitialized.Union(other), DeepEquals, other)
c.Assert(uninitialized.Intersection(other), DeepEquals, set.NewStrings())
c.Assert(uninitialized.Difference(other), DeepEquals, set.NewStrings())
c.Assert(other.Union(uninitialized), DeepEquals, other)
c.Assert(other.Intersection(uninitialized), DeepEquals, set.NewStrings())
c.Assert(other.Difference(uninitialized), DeepEquals, other)
// Once something is added, the set becomes initialized.
uninitialized.Add("foo")
AssertValues(c, uninitialized, "foo")
}
// getUploadSeries returns the supplied series with duplicates removed if
// non-empty; otherwise it returns a default list of series we should
// probably upload, based on cfg.
func getUploadSeries(cfg *config.Config, series []string) []string {
unique := set.NewStrings(series...)
if unique.IsEmpty() {
unique.Add(version.Current.Series)
unique.Add(config.DefaultSeries)
unique.Add(cfg.DefaultSeries())
}
return unique.Values()
}
// FindSession attempts to find a debug hooks session for the unit specified
// in the context, and returns a new ServerSession structure for it.
func (c *HooksContext) FindSession() (*ServerSession, error) {
cmd := exec.Command("tmux", "has-session", "-t", c.tmuxSessionName())
out, err := cmd.CombinedOutput()
if err != nil {
if len(out) != 0 {
return nil, errors.New(string(out))
} else {
return nil, err
}
}
// Parse the debug-hooks file for an optional hook name.
data, err := ioutil.ReadFile(c.ClientFileLock())
if err != nil {
return nil, err
}
var args hookArgs
err = goyaml.Unmarshal(data, &args)
if err != nil {
return nil, err
}
hooks := set.NewStrings(args.Hooks...)
session := &ServerSession{c, hooks}
return session, nil
}
func (stringSetSuite) TestRemove(c *C) {
s := set.NewStrings("foo", "bar")
s.Remove("foo")
AssertValues(c, s, "bar")
}
func (stringSetSuite) TestEmpty(c *C) {
s := set.NewStrings()
AssertValues(c, s)
}
"launchpad.net/juju-core/testing"
"launchpad.net/juju-core/utils/set"
"launchpad.net/juju-core/worker/uniter/jujuc"
)
type PortsSuite struct {
ContextSuite
}
var _ = Suite(&PortsSuite{})
var portsTests = []struct {
cmd []string
expect set.Strings
}{
{[]string{"open-port", "80"}, set.NewStrings("80/tcp")},
{[]string{"open-port", "99/tcp"}, set.NewStrings("80/tcp", "99/tcp")},
{[]string{"close-port", "80/TCP"}, set.NewStrings("99/tcp")},
{[]string{"open-port", "123/udp"}, set.NewStrings("99/tcp", "123/udp")},
{[]string{"close-port", "9999/UDP"}, set.NewStrings("99/tcp", "123/udp")},
}
func (s *PortsSuite) TestOpenClose(c *C) {
hctx := s.GetHookContext(c, -1, "")
for _, t := range portsTests {
com, err := jujuc.NewCommand(hctx, t.cmd[0])
c.Assert(err, IsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, t.cmd[1:])
c.Assert(code, Equals, 0)
c.Assert(bufferString(ctx.Stdout), Equals, "")
func (stringSetSuite) TestInitialValues(c *C) {
values := []string{"foo", "bar", "baz"}
s := set.NewStrings(values...)
AssertValues(c, s, values...)
}
func (stringSetSuite) TestContains(c *C) {
s := set.NewStrings("foo", "bar")
c.Assert(s.Contains("foo"), Equals, true)
c.Assert(s.Contains("bar"), Equals, true)
c.Assert(s.Contains("baz"), Equals, false)
}
func (stringSetSuite) TestRemoveNonExistent(c *C) {
s := set.NewStrings()
s.Remove("foo")
AssertValues(c, s)
}
