func (s *GlobalModeSuite) TestStartWithUnexposedService(c *gc.C) {
m, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, jc.ErrorIsNil)
s.startInstance(c, m)
svc := s.AddTestingService(c, "wordpress", s.charm)
u, err := svc.AddUnit()
c.Assert(err, jc.ErrorIsNil)
err = u.AssignToMachine(m)
c.Assert(err, jc.ErrorIsNil)
err = u.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
// Starting the firewaller, no open ports.
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
s.assertEnvironPorts(c, nil)
// Expose service.
err = svc.SetExposed()
c.Assert(err, jc.ErrorIsNil)
s.assertEnvironPorts(c, []network.PortRange{{80, 80, "tcp"}})
}
func (s *GlobalModeSuite) TestRestartUnexposedService(c *gc.C) {
// Start firewaller and open ports.
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
svc := s.AddTestingService(c, "wordpress", s.charm)
err = svc.SetExposed()
c.Assert(err, jc.ErrorIsNil)
u, m := s.addUnit(c, svc)
s.startInstance(c, m)
err = u.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
err = u.OpenPort("tcp", 8080)
c.Assert(err, jc.ErrorIsNil)
s.assertEnvironPorts(c, []network.PortRange{{80, 80, "tcp"}, {8080, 8080, "tcp"}})
// Stop firewaller and clear exposed flag on service.
err = worker.Stop(fw)
c.Assert(err, jc.ErrorIsNil)
err = svc.ClearExposed()
c.Assert(err, jc.ErrorIsNil)
// Start firewaller and check port.
fw, err = firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
s.assertEnvironPorts(c, nil)
}
func (s *InstanceModeSuite) TestRemoveMachine(c *gc.C) {
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
svc := s.AddTestingService(c, "wordpress", s.charm)
err = svc.SetExposed()
c.Assert(err, jc.ErrorIsNil)
u, m := s.addUnit(c, svc)
inst := s.startInstance(c, m)
err = u.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst, m.Id(), []network.PortRange{{80, 80, "tcp"}})
// Remove unit.
err = u.EnsureDead()
c.Assert(err, jc.ErrorIsNil)
err = u.Remove()
c.Assert(err, jc.ErrorIsNil)
// Remove machine. Nothing bad should happen, but can't
// assert port state since the machine must have been
// destroyed and we lost its reference.
err = m.Refresh()
c.Assert(err, jc.ErrorIsNil)
err = m.EnsureDead()
c.Assert(err, jc.ErrorIsNil)
err = m.Remove()
c.Assert(err, jc.ErrorIsNil)
}
func (s *InstanceModeSuite) TestRemoveUnit(c *gc.C) {
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
svc := s.AddTestingService(c, "wordpress", s.charm)
err = svc.SetExposed()
c.Assert(err, jc.ErrorIsNil)
u1, m1 := s.addUnit(c, svc)
inst1 := s.startInstance(c, m1)
err = u1.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
u2, m2 := s.addUnit(c, svc)
inst2 := s.startInstance(c, m2)
err = u2.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst1, m1.Id(), []network.PortRange{{80, 80, "tcp"}})
s.assertPorts(c, inst2, m2.Id(), []network.PortRange{{80, 80, "tcp"}})
// Remove unit.
err = u1.EnsureDead()
c.Assert(err, jc.ErrorIsNil)
err = u1.Remove()
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst1, m1.Id(), nil)
s.assertPorts(c, inst2, m2.Id(), []network.PortRange{{80, 80, "tcp"}})
}
func (s *InstanceModeSuite) TestDeadMachine(c *gc.C) {
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
svc := s.AddTestingService(c, "wordpress", s.charm)
err = svc.SetExposed()
c.Assert(err, jc.ErrorIsNil)
u, m := s.addUnit(c, svc)
inst := s.startInstance(c, m)
err = u.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst, m.Id(), []network.PortRange{{80, 80, "tcp"}})
// Remove unit and service, also tested without. Has no effect.
err = u.EnsureDead()
c.Assert(err, jc.ErrorIsNil)
err = u.Remove()
c.Assert(err, jc.ErrorIsNil)
err = svc.Destroy()
c.Assert(err, jc.ErrorIsNil)
// Kill machine.
err = m.Refresh()
c.Assert(err, jc.ErrorIsNil)
err = m.EnsureDead()
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst, m.Id(), nil)
}
func (s *InstanceModeSuite) TestSetClearExposedService(c *gc.C) {
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
svc := s.AddTestingService(c, "wordpress", s.charm)
u, m := s.addUnit(c, svc)
inst := s.startInstance(c, m)
err = u.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
err = u.OpenPort("tcp", 8080)
c.Assert(err, jc.ErrorIsNil)
// Not exposed service, so no open port.
s.assertPorts(c, inst, m.Id(), nil)
// SeExposed opens the ports.
err = svc.SetExposed()
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst, m.Id(), []network.PortRange{{80, 80, "tcp"}, {8080, 8080, "tcp"}})
// ClearExposed closes the ports again.
err = svc.ClearExposed()
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst, m.Id(), nil)
}
func (s *InstanceModeSuite) TestStartWithState(c *gc.C) {
svc := s.AddTestingService(c, "wordpress", s.charm)
err := svc.SetExposed()
c.Assert(err, jc.ErrorIsNil)
u, m := s.addUnit(c, svc)
inst := s.startInstance(c, m)
err = u.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
err = u.OpenPort("tcp", 8080)
c.Assert(err, jc.ErrorIsNil)
// Nothing open without firewaller.
s.assertPorts(c, inst, m.Id(), nil)
// Starting the firewaller opens the ports.
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
s.assertPorts(c, inst, m.Id(), []network.PortRange{{80, 80, "tcp"}, {8080, 8080, "tcp"}})
err = svc.SetExposed()
c.Assert(err, jc.ErrorIsNil)
}
func (s *GlobalModeSuite) TestRestartPortCount(c *gc.C) {
// Start firewaller and open ports.
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
svc1 := s.AddTestingService(c, "wordpress", s.charm)
err = svc1.SetExposed()
c.Assert(err, jc.ErrorIsNil)
u1, m1 := s.addUnit(c, svc1)
s.startInstance(c, m1)
err = u1.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
err = u1.OpenPort("tcp", 8080)
c.Assert(err, jc.ErrorIsNil)
s.assertEnvironPorts(c, []network.PortRange{{80, 80, "tcp"}, {8080, 8080, "tcp"}})
// Stop firewaller and add another service using the port.
err = worker.Stop(fw)
c.Assert(err, jc.ErrorIsNil)
svc2 := s.AddTestingService(c, "moinmoin", s.charm)
err = svc2.SetExposed()
c.Assert(err, jc.ErrorIsNil)
u2, m2 := s.addUnit(c, svc2)
s.startInstance(c, m2)
err = u2.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
// Start firewaller and check port.
fw, err = firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
s.assertEnvironPorts(c, []network.PortRange{{80, 80, "tcp"}, {8080, 8080, "tcp"}})
// Closing a port opened by a different unit won't touch the environment.
err = u1.ClosePort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
s.assertEnvironPorts(c, []network.PortRange{{80, 80, "tcp"}, {8080, 8080, "tcp"}})
// Closing a port used just once changes the environment.
err = u1.ClosePort("tcp", 8080)
c.Assert(err, jc.ErrorIsNil)
s.assertEnvironPorts(c, []network.PortRange{{80, 80, "tcp"}})
// Closing the last port also modifies the environment.
err = u2.ClosePort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
s.assertEnvironPorts(c, nil)
}
func (s *InstanceModeSuite) TestNotExposedService(c *gc.C) {
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
svc := s.AddTestingService(c, "wordpress", s.charm)
u, m := s.addUnit(c, svc)
inst := s.startInstance(c, m)
err = u.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
err = u.OpenPort("tcp", 8080)
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst, m.Id(), nil)
err = u.ClosePort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst, m.Id(), nil)
}
func (s *InstanceModeSuite) TestMultipleExposedServices(c *gc.C) {
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
svc1 := s.AddTestingService(c, "wordpress", s.charm)
err = svc1.SetExposed()
c.Assert(err, jc.ErrorIsNil)
u1, m1 := s.addUnit(c, svc1)
inst1 := s.startInstance(c, m1)
err = u1.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
err = u1.OpenPort("tcp", 8080)
c.Assert(err, jc.ErrorIsNil)
svc2 := s.AddTestingService(c, "mysql", s.charm)
c.Assert(err, jc.ErrorIsNil)
err = svc2.SetExposed()
c.Assert(err, jc.ErrorIsNil)
u2, m2 := s.addUnit(c, svc2)
inst2 := s.startInstance(c, m2)
err = u2.OpenPort("tcp", 3306)
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst1, m1.Id(), []network.PortRange{{80, 80, "tcp"}, {8080, 8080, "tcp"}})
s.assertPorts(c, inst2, m2.Id(), []network.PortRange{{3306, 3306, "tcp"}})
err = u1.ClosePort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
err = u2.ClosePort("tcp", 3306)
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst1, m1.Id(), []network.PortRange{{8080, 8080, "tcp"}})
s.assertPorts(c, inst2, m2.Id(), nil)
}
func (s *InstanceModeSuite) TestMachineWithoutInstanceId(c *gc.C) {
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertKillAndWait(c, fw)
svc := s.AddTestingService(c, "wordpress", s.charm)
err = svc.SetExposed()
c.Assert(err, jc.ErrorIsNil)
// add a unit but don't start its instance yet.
u1, m1 := s.addUnit(c, svc)
// add another unit and start its instance, so that
// we're sure the firewaller has seen the first instance.
u2, m2 := s.addUnit(c, svc)
inst2 := s.startInstance(c, m2)
err = u2.OpenPort("tcp", 80)
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst2, m2.Id(), []network.PortRange{{80, 80, "tcp"}})
inst1 := s.startInstance(c, m1)
err = u1.OpenPort("tcp", 8080)
c.Assert(err, jc.ErrorIsNil)
s.assertPorts(c, inst1, m1.Id(), []network.PortRange{{8080, 8080, "tcp"}})
}
func (s *GlobalModeSuite) TestStartStop(c *gc.C) {
fw, err := firewaller.NewFirewaller(s.firewaller)
c.Assert(err, jc.ErrorIsNil)
statetesting.AssertKillAndWait(c, fw)
}
