def test_memcache_ctx(self):
class MockCharmInstance(object):
api_ports = {}
name = 'hello'
def __init__(self, release):
self.release = release
mch_result = False
class MCHR(object):
class_thing = None
def __init__(self, thing):
self.thing = thing
self.__class__.class_thing = self
def __gt__(self, other):
return mch_result
mpo = mock.patch.object
with mpo(adapters.ch_host, 'lsb_release') as lsb_r, \
mpo(adapters.ch_host, 'CompareHostReleases', new=MCHR), \
mpo(adapters.ch_ip, 'is_ipv6_disabled') as is_ipv6_disabled:
# first no memcache
mci = MockCharmInstance('liberty')
c = adapters.APIConfigurationAdapter(charm_instance=mci)
self.assertEqual(c.memcache['use_memcache'], False)
# next switch on memcache
mci = MockCharmInstance('mitaka')
# start with ipv6 disabled and ubuntu release is trusty
lsb_r.return_value = {'DISTRIB_CODENAME': 'trusty'}
is_ipv6_disabled.return_value = True
c = adapters.APIConfigurationAdapter(charm_instance=mci)
self.assertEqual(c.memcache['use_memcache'], True)
self.assertEqual(MCHR.class_thing.thing, 'trusty')
self.assertEqual(c.memcache['memcache_server'], 'localhost')
self.assertEqual(c.memcache['memcache_server_formatted'],
'127.0.0.1')
self.assertEqual(c.memcache['memcache_port'], '11211')
self.assertEqual(c.memcache['memcache_url'], '127.0.0.1:11211')
# make us later than trusty
mch_result = True
self.assertEqual(c.memcache['memcache_server'], '127.0.0.1')
# now do ipv6 not disabled.
mch_result = False
is_ipv6_disabled.return_value = False
c = adapters.APIConfigurationAdapter(charm_instance=mci)
self.assertEqual(c.memcache['use_memcache'], True)
self.assertEqual(MCHR.class_thing.thing, 'trusty')
self.assertEqual(c.memcache['memcache_server'], 'ip6-localhost')
self.assertEqual(c.memcache['memcache_server_formatted'], '[::1]')
self.assertEqual(c.memcache['memcache_port'], '11211')
self.assertEqual(c.memcache['memcache_url'], 'inet6:[::1]:11211')
# make us later than trusty
mch_result = True
self.assertEqual(c.memcache['memcache_server'], '::1')
def test_memcache_server(self):
with mock.patch.object(adapters.ch_host,
'lsb_release',
return_value={'DISTRIB_RELEASE': '14.04'}):
c = adapters.APIConfigurationAdapter()
self.assertEqual(c.memcache_server, 'ip6-localhost')
with mock.patch.object(adapters.ch_host,
'lsb_release',
return_value={'DISTRIB_RELEASE': '16.04'}):
c = adapters.APIConfigurationAdapter()
self.assertEqual(c.memcache_server, '::1')
def test_determine_service_port(self):
with mock.patch.object(adapters.APIConfigurationAdapter,
'apache_enabled',
new=True):
c = adapters.APIConfigurationAdapter()
self.assertEqual(c.determine_service_port(80), 60)
with mock.patch.object(adapters.APIConfigurationAdapter,
'apache_enabled',
new=False):
c = adapters.APIConfigurationAdapter()
self.assertEqual(c.determine_service_port(80), 70)
def test_apache_enabled(self):
with mock.patch.object(adapters.charms.reactive.bus,
'get_state',
return_value=True):
c = adapters.APIConfigurationAdapter()
self.assertTrue(c.apache_enabled)
with mock.patch.object(adapters.charms.reactive.bus,
'get_state',
return_value=False):
c = adapters.APIConfigurationAdapter()
self.assertFalse(c.apache_enabled)
def test_ipv6_enabled(self):
with mock.patch.object(adapters.ch_ip,
'is_ipv6_disabled') as is_ipv6_disabled:
# IPv6 disabled
is_ipv6_disabled.return_value = True
a = adapters.APIConfigurationAdapter()
self.assertEqual(a.ipv6_enabled, False)
# IPv6 enabled
is_ipv6_disabled.return_value = False
b = adapters.APIConfigurationAdapter()
self.assertEqual(b.ipv6_enabled, True)
def test_use_memcache(self):
test_config = {'openstack-origin': 'distro'}
with mock.patch.object(adapters.hookenv,
'config',
new=lambda: test_config):
with mock.patch.object(adapters.ch_utils,
'get_os_codename_install_source',
return_value='liberty'):
c = adapters.APIConfigurationAdapter()
self.assertFalse(c.use_memcache)
with mock.patch.object(adapters.ch_utils,
'get_os_codename_install_source',
return_value='newton'):
c = adapters.APIConfigurationAdapter()
self.assertTrue(c.use_memcache)
def test_external_endpoints(self):
test_config = {
'prefer-ipv6': False,
'vip': None,
}
with mock.patch.object(adapters.hookenv, 'config',
new=lambda: test_config), \
mock.patch.object(adapters.ch_utils, 'get_host_ip',
return_value='10.0.0.10'), \
mock.patch.object(adapters.APIConfigurationAdapter,
'get_network_addresses'), \
mock.patch.object(adapters.hookenv, 'local_unit',
return_value='my-unit/0'):
c = adapters.APIConfigurationAdapter(port_map=self.api_ports)
self.assertEqual(
c.external_endpoints, {
'svc1': {
'proto': 'https',
'ip': '10.0.0.10',
'port': 9001,
'url': 'https://10.0.0.10:9001'
},
'svc2': {
'proto': 'https',
'ip': '10.0.0.10',
'port': 9002,
'url': 'https://10.0.0.10:9002'
}
})
def test_memcache_url(self):
with mock.patch.object(adapters.APIConfigurationAdapter,
'memcache',
new_callable=mock.PropertyMock) as memcache:
memcache.return_value = {}
c = adapters.APIConfigurationAdapter()
self.assertEqual(c.memcache_url, '')
memcache.return_value = {'memcache_url': 'hello'}
self.assertEqual(c.memcache_url, 'hello')
def test_workers(self):
class FakeWorkerConfigContext(object):
def __call__(self):
return {"workers": 8}
with mock.patch.object(adapters.ch_context,
'WorkerConfigContext',
new=FakeWorkerConfigContext):
c = adapters.APIConfigurationAdapter()
self.assertEqual(c.workers, 8)
def test_use_memcache(self):
with mock.patch.object(adapters.APIConfigurationAdapter,
'memcache',
new_callable=mock.PropertyMock) as memcache:
memcache.return_value = {}
c = adapters.APIConfigurationAdapter()
self.assertEqual(c.use_memcache, False)
memcache.return_value = {'use_memcache': False}
self.assertEqual(c.use_memcache, False)
memcache.return_value = {'use_memcache': True}
self.assertEqual(c.use_memcache, True)
def test_class_init_using_charm_instance(self):
class TestCharm(object):
api_ports = TestAPIConfigurationAdapter.api_ports
name = 'test-charm'
with mock.patch.object(adapters.hookenv, 'config', new=lambda: {}), \
mock.patch.object(adapters.APIConfigurationAdapter,
'get_network_addresses'):
c = adapters.APIConfigurationAdapter(charm_instance=TestCharm())
self.assertEqual(c.port_map, TestCharm.api_ports)
self.assertEqual(c.service_name, 'test-charm')
def test_class(self):
test_config = {
'prefer-ipv6': False,
'vip': '',
}
with mock.patch.object(adapters.hookenv, 'config',
new=lambda: test_config), \
mock.patch.object(adapters.APIConfigurationAdapter,
'get_network_addresses'), \
mock.patch.object(adapters.hookenv, 'local_unit',
return_value='my-unit/0'):
c = adapters.APIConfigurationAdapter()
self.assertEqual(c.local_unit_name, 'my-unit-0')
self.assertEqual(c.haproxy_stat_port, '8888')
self.assertEqual(c.service_ports, {})
self.assertEqual(c.service_listen_info, {})
self.assertEqual(c.external_endpoints, {})
def test_ipv6_mode(self):
test_config = {
'prefer-ipv6': True,
'vip': '',
}
with mock.patch.object(adapters.hookenv, 'config',
new=lambda: test_config), \
mock.patch.object(
adapters.ch_ip,
'get_ipv6_addr',
return_value=['fe80::f2de:f1ff:fedd:8dc7']), \
mock.patch.object(adapters.APIConfigurationAdapter,
'get_network_addresses'):
c = adapters.APIConfigurationAdapter()
self.assertTrue(c.ipv6_mode)
self.assertEqual(c.local_address, 'fe80::f2de:f1ff:fedd:8dc7')
self.assertEqual(c.local_host, 'ip6-localhost')
self.assertEqual(c.haproxy_host, '::')
def test_ipv4_mode(self):
test_config = {
'prefer-ipv6': False,
'vip': '',
}
with mock.patch.object(adapters.ch_utils, 'get_host_ip',
return_value='10.0.0.10'), \
mock.patch.object(adapters.hookenv, 'config',
new=lambda: test_config), \
mock.patch.object(adapters.hookenv, 'unit_get',
return_value='10.0.0.20'), \
mock.patch.object(adapters.APIConfigurationAdapter,
'get_network_addresses'):
c = adapters.APIConfigurationAdapter(service_name='svc1')
self.assertFalse(c.ipv6_mode)
self.assertEqual(c.local_address, '10.0.0.10')
self.assertEqual(c.local_host, '127.0.0.1')
self.assertEqual(c.haproxy_host, '0.0.0.0')
self.assertEqual(c.service_name, 'svc1')
def test_external_endpoints(self):
with mock.patch.object(adapters.os_ip,
'resolve_address',
return_value="10.0.0.10"):
c = adapters.APIConfigurationAdapter(port_map=self.api_ports)
self.assertEqual(
c.external_endpoints, {
'svc1': {
'proto': 'https',
'ip': '10.0.0.10',
'port': 9001,
'url': 'https://10.0.0.10:9001'
},
'svc2': {
'proto': 'https',
'ip': '10.0.0.10',
'port': 9002,
'url': 'https://10.0.0.10:9002'
}
})
def test_get_network_addresses(self):
test_config = {
'prefer-ipv6': False,
'os-admin-network': 'admin_net',
'os-public-network': 'public_net',
'os-internal-network': 'internal_net',
}
test_networks = {
'admin_net': 'admin_addr',
'public_net': 'public_addr',
'internal_net': 'internal_addr',
}
resolved_addresses = {
'admin': 'admin_addr',
'public': 'public_addr',
'int': 'int_vip',
}
def _is_address_in_network(cidr, vip):
return cidr == vip.replace('vip_', '')
def _resolve_address(endpoint_type=None):
return resolved_addresses[endpoint_type]
with mock.patch.object(adapters.hookenv, 'config',
return_value=test_config), \
mock.patch.object(adapters.hookenv, 'unit_get',
return_value='thisunit'), \
mock.patch.object(adapters.ch_ip, 'get_address_in_network',
new=lambda x, y: test_networks[x]), \
mock.patch.object(adapters.ch_ip, 'get_relation_ip',
new=lambda x, y: test_networks[x]), \
mock.patch.object(adapters.os_ip, 'resolve_address',
new=_resolve_address):
c = adapters.APIConfigurationAdapter()
self.assertEqual(c.get_network_addresses(),
[('admin_addr', 'admin_addr'),
('internal_addr', 'int_vip'),
('public_addr', 'public_addr')])
def test_endpoints_and_ext_ports(self):
_net_addrs = [('admin_addr', 'vip_admin_net'),
('internal_addr', 'vip_internal_net')]
with mock.patch.object(adapters.APIConfigurationAdapter,
'get_network_addresses',
return_value=_net_addrs), \
mock.patch.object(adapters.ch_cluster, 'determine_apache_port',
new=lambda x, singlenode_mode: x - 10), \
mock.patch.object(adapters.ch_cluster, 'determine_api_port',
new=lambda x, singlenode_mode: x - 20):
c = adapters.APIConfigurationAdapter(port_map=self.api_ports)
expect = [
('admin_addr', 'vip_admin_net', 8991, 8981),
('admin_addr', 'vip_admin_net', 8992, 8982),
('admin_addr', 'vip_admin_net', 8993, 8983),
('internal_addr', 'vip_internal_net', 8991, 8981),
('internal_addr', 'vip_internal_net', 8992, 8982),
('internal_addr', 'vip_internal_net', 8993, 8983),
]
self.assertEqual(c.endpoints, expect)
self.assertEqual(c.ext_ports, [8991, 8992, 8993])
def test_memcache_host(self):
self.assertEqual(adapters.APIConfigurationAdapter().memcache_host,
'[::1]')
def test_wsgi_worker_context(self):
class ChInstance1(object):
name = 'test-name'
wsgi_script = 'test-script'
api_ports = {}
class ChInstance2(object):
name = 'test-name'
wsgi_script = 'test-script'
wsgi_admin_script = 'test-admin-script'
wsgi_public_script = 'test-public-script'
wsgi_process_weight = 0.5
wsgi_admin_process_weight = 0.1
wsgi_public_process_weight = 0.4
api_ports = {}
class ChInstance3(object):
name = 'test-name'
wsgi_script = None
wsgi_admin_script = 'test-admin-script'
wsgi_public_script = 'test-public-script'
wsgi_process_weight = None
wsgi_admin_process_weight = 0.1
wsgi_public_process_weight = 0.4
api_ports = {}
class FakeWSGIWorkerConfigContext():
copy_kwargs = None
def __init__(self, **kwargs):
self.__class__.copy_kwargs = kwargs.copy()
def __call__(self):
return "T"
with mock.patch.object(adapters.ch_context,
'WSGIWorkerConfigContext',
new=FakeWSGIWorkerConfigContext):
# start with no charm instance to get default values
c = adapters.APIConfigurationAdapter()
self.assertEqual(c.wsgi_worker_context, "T")
self.assertEqual(FakeWSGIWorkerConfigContext.copy_kwargs, {})
# start with a minimal charm_instance
instance = ChInstance1()
c = adapters.APIConfigurationAdapter(charm_instance=instance)
self.assertEqual(c.wsgi_worker_context, "T")
self.assertEqual(FakeWSGIWorkerConfigContext.copy_kwargs, {
'name': 'test-name',
'script': 'test-script'
})
# And then, all the options set:
instance = ChInstance2()
c = adapters.APIConfigurationAdapter(charm_instance=instance)
self.assertEqual(c.wsgi_worker_context, "T")
self.assertEqual(
FakeWSGIWorkerConfigContext.copy_kwargs, {
'name': 'test-name',
'script': 'test-script',
'admin_script': 'test-admin-script',
'public_script': 'test-public-script',
'process_weight': 0.5,
'admin_process_weight': 0.1,
'public_process_weight': 0.4
})
# and finally, with some of the options set to None, to test
# filtering
instance = ChInstance3()
c = adapters.APIConfigurationAdapter(charm_instance=instance)
self.assertEqual(c.wsgi_worker_context, "T")
self.assertEqual(
FakeWSGIWorkerConfigContext.copy_kwargs, {
'name': 'test-name',
'admin_script': 'test-admin-script',
'public_script': 'test-public-script',
'admin_process_weight': 0.1,
'public_process_weight': 0.4
})
def test_external_ports(self):
c = adapters.APIConfigurationAdapter(port_map=self.api_ports)
self.assertEqual(c.external_ports, {9001, 9002, 9003})
def test_memcache_port(self):
self.assertEqual(adapters.APIConfigurationAdapter().memcache_port,
'11211')
def test_memcache_url(self):
self.assertEqual(adapters.APIConfigurationAdapter().memcache_url,
'inet6:[::1]:11211')
