def test_all_attrs(self):
machine = ProviderMachine(
"i-abc", "xe.example.com", "foo.local", "borken")
self.assertEqual(machine.instance_id, "i-abc")
self.assertEqual(machine.dns_name, "xe.example.com")
self.assertEqual(machine.private_dns_name, "foo.local")
self.assertEqual(machine.state, "borken")
def test_none_have_dns_at_first(self):
"""Verify retry of ZK machine that at first doesn't have a DNS name."""
log = self.capture_logging(level=logging.DEBUG)
mocked_machine = self.mocker.proxy(
ProviderMachine("i-have-no-dns-at-first"))
mocked_machine.dns_name
self.mocker.result(None)
mocked_machine.dns_name
self.mocker.count(0, None)
self.mocker.result("foo.example.com") # name assumed by mock_connect
# Provide for a valid mocked client once connected
client = self.mocker.mock(type=SSHClient)
self.mock_connect(True, succeed(client))
client.exists_and_watch("/initialized")
self.mocker.result((succeed(True), None))
self.mocker.replay()
provider = DummyProvider(mocked_machine)
client = yield provider.connect(share=True)
self.assertIn(
"Retrying connection: No machines have assigned addresses",
log.getvalue())
def get_zookeeper_machines(self):
"""
Return a pair of possible zookeepers, the first of which is invalid
"""
machines = [ProviderMachine("i-havenodns")]
machines.extend(self._zookeepers)
return succeed(machines)
def test_wait_for_initialize(self):
"""
A connection to a zookeeper that is running, but whose juju state
is not ready, should wait until that state is ready.
"""
client = ZookeeperClient()
self.client = client # for poke_zk
self.mock_connect(False, succeed(client))
self.mocker.replay()
zookeeper.set_debug_level(0)
yield client.connect(get_test_zookeeper_address())
provider = DummyProvider(ProviderMachine("i-amok", "foo.example.com"))
d = provider.connect()
client_result = []
d.addCallback(client_result.append)
# Give it a chance to do it incorrectly.
yield self.poke_zk()
try:
self.assertEquals(client_result, [])
yield client.create("/initialized")
yield d
self.assertTrue(client_result, client_result)
self.assertIdentical(client_result[0], client)
finally:
deleteTree("/", client.handle)
client.close()
def test_other_error(self):
"""Other errors should propagate"""
log = self.capture_logging()
self.mock_connect(False, fail(TypeError("THUD!")))
self.mocker.replay()
provider = DummyProvider(ProviderMachine("i-exist", "foo.example.com"))
ex = yield self.assertFailure(provider.connect(), TypeError)
self.assertEqual(str(ex), "THUD!")
self.assertIn("Cannot connect to environment: THUD!", log.getvalue())
def test_fast_connection(self):
"""Verify connection when requirements are available at time of conn.
This includes /initialized is already set. In addition, also
verifies that if multiple ZKs are available, one is selected
via random.choice.
"""
log = self.capture_logging(level=logging.DEBUG)
client = ZookeeperClient()
self.mock_connect(False, succeed(client))
def get_choice(lst):
for item in lst:
if item.dns_name == "foo.example.com":
return item
raise AssertionError("expected choice not seen")
self.patch(random, "choice", get_choice)
self.mocker.replay()
provider = DummyProvider(
ProviderMachine("i-am-picked", "foo.example.com"),
ProviderMachine("i-was-not", "bar.example.com"))
zookeeper.set_debug_level(0)
yield client.connect(get_test_zookeeper_address())
try:
yield client.create("/initialized")
yield provider.connect()
self.assertEqual(
"Connecting to environment...\n"
"Connecting to environment using foo.example.com...\n"
"Environment is initialized.\n"
"Connected to environment.\n", log.getvalue())
finally:
deleteTree("/", client.handle)
client.close()
def test_get_provider_opened_ports_unknown_instance(self):
"""Verify open port op will use the correct EC2 API."""
self.ec2.describe_security_groups("juju-moon-machine-1")
self.mocker.result(fail(self.get_ec2_error("i-foobar")))
self.mocker.replay()
provider = self.get_provider()
machine = ProviderMachine("i-foobar", "x1.example.com")
ex = yield self.assertFailure(
get_provider_opened_ports(provider, machine, "machine-1"),
ProviderInteractionError)
self.assertEqual(
str(ex),
"Unexpected EC2Error getting open ports on machine i-foobar: "
"The instance ID 'i-foobar' does not exist")
def test_close_provider_port(self):
"""Verify close port op will use the correct EC2 API."""
log = self.capture_logging("juju.ec2", level=logging.DEBUG)
machine = ProviderMachine("i-foobar", "x1.example.com")
self.ec2.revoke_security_group("juju-moon-machine-1",
ip_protocol="tcp",
from_port="80",
to_port="80",
cidr_ip="0.0.0.0/0")
self.mocker.result(succeed(True))
self.mocker.replay()
provider = self.get_provider()
yield close_provider_port(provider, machine, "machine-1", 80, "tcp")
self.assertIn("Closed 80/tcp on provider machine 'i-foobar'",
log.getvalue())
def test_share_kwarg(self):
"""The `share` kwarg should be passed through to `SSHClient.connect`"""
client = self.mocker.mock(type=SSHClient)
self.mock_connect(True, succeed(client))
client.exists_and_watch("/initialized")
self.mocker.result((succeed(True), None))
self.mocker.replay()
provider = DummyProvider(ProviderMachine("i-amok", "foo.example.com"))
d = provider.connect(share=True)
def verify(result):
self.assertIdentical(result, client)
d.addCallback(verify)
return d
def test_shutdown_machine_invalid_machine(self):
"""
Attempting to shutdown a machine that from a different provider
type will raise a `ProviderError`.
"""
self.mocker.replay()
machine = ProviderMachine("i-foobar")
provider = self.get_provider()
d = provider.shutdown_machine(machine)
self.assertFailure(d, ProviderError)
def check_error(error):
self.assertEquals(
str(error), "Can only shut down EC2ProviderMachines; got a "
"<class 'juju.machine.ProviderMachine'>")
d.addCallback(check_error)
return d
def test_close_provider_port_unknown_instance(self):
"""Verify open port op will use the correct EC2 API."""
machine = ProviderMachine("i-foobar", "x1.example.com")
self.ec2.revoke_security_group("juju-moon-machine-1",
ip_protocol="tcp",
from_port="80",
to_port="80",
cidr_ip="0.0.0.0/0")
self.mocker.result(fail(self.get_ec2_error("i-foobar")))
self.mocker.replay()
provider = self.get_provider()
ex = yield self.assertFailure(
close_provider_port(provider, machine, "machine-1", 80, "tcp"),
ProviderInteractionError)
self.assertEqual(
str(ex), "Unexpected EC2Error closing 80/tcp on machine i-foobar: "
"The instance ID 'i-foobar' does not exist")
def test_get_provider_opened_ports(self):
"""Verify correct parse of IP perms from describe_security_group."""
self.ec2.describe_security_groups("juju-moon-machine-1")
self.mocker.result(
succeed([
SecurityGroup(
"juju-%s-machine-1" % self.env_name,
"a security group name",
ips=[
IPPermission("udp", "53", "53", "0.0.0.0/0"),
IPPermission("tcp", "80", "80", "0.0.0.0/0"),
# The range 8080-8082 will be ignored
IPPermission("tcp", "8080", "8082", "0.0.0.0/0"),
# Ignore permissions that are not 0.0.0.0/0
IPPermission("tcp", "443", "443", "10.1.2.3")
])
]))
self.mocker.replay()
provider = self.get_provider()
machine = ProviderMachine("i-foobar", "x1.example.com")
opened_ports = yield get_provider_opened_ports(provider, machine,
"machine-1")
self.assertEqual(opened_ports, set([(53, "udp"), (80, "tcp")]))
def test_no_connection(self):
"""Verify retry of `NoConnection` errors."""
log = self.capture_logging(level=logging.DEBUG)
# First connection attempts fails
mock_client = self.mocker.patch(SSHClient)
mock_client.connect("foo.example.com:2181", timeout=30, share=False)
self.mocker.result(fail(NoConnection("KABOOM!")))
# Subsequent connection attempt then succeeds with a valid
# (mocked) client that can be waited on.
mock_client.connect("foo.example.com:2181", timeout=30, share=False)
self.mocker.result(succeed(mock_client))
mock_client.exists_and_watch("/initialized")
self.mocker.result((succeed(True), None))
self.mocker.replay()
provider = DummyProvider(ProviderMachine("i-exist", "foo.example.com"))
yield provider.connect()
self.assertIn(
"Retrying connection: Cannot connect to environment "
"using foo.example.com (perhaps still initializing): KABOOM!",
log.getvalue())
def run(self, machine_data):
return succeed([ProviderMachine(machine_data["machine-id"])])
def test_shutdown_rejects_invalid_machine(self):
machine = ProviderMachine("a-value")
d = self.provider.shutdown_machine(machine)
self.assertFailure(d, ProviderError)
return d
def test_minimal(self):
machine = ProviderMachine("i-abc")
self.assertEqual(machine.instance_id, "i-abc")
self.assertEqual(machine.dns_name, None)
self.assertEqual(machine.private_dns_name, None)
self.assertEqual(machine.state, "unknown")
