def test_should_load_and_use_only_loaded_vcls(self):
start_processing_time = timezone.now()
vcl = Vcl('Test-content', name='test')
loader_mock = Mock()
loader_mock.use_vcl = Mock(return_value=VclStatus.OK)
loader_mock.discard_unused_vcls = Mock()
rendered_list = [(vcl, servers[0])]
loaded_list = [(vcl, loader_mock, servers[0])]
with patch.object(ParallelRenderer,
'render_vcl_for_servers',
return_value=rendered_list):
with patch.object(ParallelLoader,
'load_vcl_list',
return_value=loaded_list):
with patch.object(ParallelLoader,
'use_vcl_list',
return_value=True) as use_vcl_mock:
varnish_cluster = VarnishCluster()
assert_true(
varnish_cluster.load_vcl(start_processing_time, []))
"""
Here we check if only previously loaded vcl-s are used
"""
assert_list_equal(
[call(start_processing_time, loaded_list)],
use_vcl_mock.call_args_list)
def test_should_discard_unused_vcls_on_error_while_loading_vcl(self):
vcl = Vcl('Test-content', name='test')
rendered_list = [(vcl, servers[0])]
with patch.object(ParallelRenderer, 'render_vcl_for_servers', return_value=rendered_list):
with patch.object(ParallelLoader, 'load_vcl_list', side_effect=VclLoadException):
with patch.object(ParallelLoader, 'discard_loaded_unused_vcl', return_value=(True, servers[0])) as \
discard_vcl_mock:
varnish_cluster = VarnishCluster()
with self.assertRaises(VclLoadException):
varnish_cluster.load_vcl(timezone.now(), [])
assert_list_equal([call([(vcl, servers[0])])], discard_vcl_mock.call_args_list)
def test_should_not_use_vcls_on_error_while_loading_vcl(self):
vcl = Vcl('Test-content', name='test')
rendered_list = [(vcl, servers[0])]
with patch.object(ParallelRenderer, 'render_vcl_for_servers', return_value=rendered_list):
with patch.object(ParallelLoader, 'load_vcl_list', side_effect=VclLoadException):
with patch.object(ParallelLoader, 'use_vcl_list', return_value=False) as use_vcl_mock:
varnish_cluster = VarnishCluster()
with self.assertRaises(VclLoadException):
varnish_cluster.load_vcl(timezone.now(), [])
"""
Here we check if 'use' command is NOT sent to servers
"""
assert_list_equal([], use_vcl_mock.call_args_list)
def test_should_load_and_use_only_loaded_vcls(self):
start_processing_time = timezone.now()
vcl = Vcl('Test-content', name='test')
loader_mock = Mock()
loader_mock.use_vcl = Mock(return_value=VclStatus.OK)
loader_mock.discard_unused_vcls = Mock()
rendered_list = [(vcl, servers[0])]
loaded_list = [(vcl, loader_mock, servers[0])]
with patch.object(ParallelRenderer, 'render_vcl_for_servers', return_value=rendered_list):
with patch.object(ParallelLoader, 'load_vcl_list', return_value=loaded_list):
with patch.object(ParallelLoader, 'use_vcl_list', return_value=True) as use_vcl_mock:
varnish_cluster = VarnishCluster()
assert_true(varnish_cluster.load_vcl(start_processing_time, []))
"""
Here we check if only previously loaded vcl-s are used
"""
assert_list_equal([call(start_processing_time, loaded_list)], use_vcl_mock.call_args_list)
def test_should_not_use_vcls_on_error_while_loading_vcl(self):
vcl = Vcl('Test-content', name='test')
rendered_list = [(vcl, servers[0])]
with patch.object(ParallelRenderer,
'render_vcl_for_servers',
return_value=rendered_list):
with patch.object(ParallelLoader,
'load_vcl_list',
side_effect=VclLoadException):
with patch.object(ParallelLoader,
'use_vcl_list',
return_value=False) as use_vcl_mock:
varnish_cluster = VarnishCluster()
with self.assertRaises(VclLoadException):
varnish_cluster.load_vcl(timezone.now(), [])
"""
Here we check if 'use' command is NOT sent to servers
"""
assert_list_equal([], use_vcl_mock.call_args_list)
def process_response(self, request, response):
# clusters - a list with varnish clusters to refresh
clusters = VclRefreshState.get_refresh(request.id)
if 'error_message' in request.session:
del request.session['error_message']
if len(clusters) > 0:
start = time.time()
try:
VarnishCluster().load_vcl(datetime.datetime.now().isoformat(), clusters)
except Exception as e:
logging.info("Error while reloading cluster: %s (%s)" % (e, type(response)))
if 'tastypie' in str(type(response)):
return HttpApplicationError("%s: %s" % (e.__class__.__name__, str(e)[:400]))
request.session['error_message'] = "%s: %s" % (e.__class__.__name__, str(e)[:400])
logging.info("cluster reload time: %f" % (time.time() - start))
return response
def handle(self, *args, **options):
call_command('syncdb', interactive=False)
call_command('flush', interactive=False)
user = User.objects.db_manager(database).create_superuser('admin', '*****@*****.**', 'admin')
ApiKey.objects.create(user=user, key="vagrant_api_key")
dc1 = Dc.objects.create(symbol='dc1', name='First datacenter')
template3 = VclTemplate.objects.create(name='vagrant_template_3', content='<VCL/>', version='3.0')
template4 = VclTemplate.objects.create(name='vagrant_template_4', content='<VCL/>', version='4.0')
probe = Probe.objects.create(name='default_probe', url='/ts.1')
first_director = Director.objects.create(
name='first_service', route_expression='/first', mode='random', probe=probe
)
second_director = Director.objects.create(
name='second_service', router='req.http.host', route_expression='second.*', mode='round-robin', probe=probe
)
Backend.objects.create(dc=dc1, director=first_director, address='192.168.199.10', port=80, weight=1)
Backend.objects.create(dc=dc1, director=first_director, address='192.168.199.11', port=80, weight=1)
Backend.objects.create(dc=dc1, director=first_director, address='192.168.199.12', port=80, weight=2)
Backend.objects.create(dc=dc1, director=second_director, address='192.168.199.13', port=80, weight=3)
Backend.objects.create(dc=dc1, director=second_director, address='192.168.199.14', port=80, weight=4)
Backend.objects.create(dc=dc1, director=second_director, address='192.168.199.15', port=80, weight=5)
cluster1_siteA_test = LogicalCluster.objects.create(name='cluster1_siteA_test')
cluster2_siteB_test = LogicalCluster.objects.create(name='cluster2_siteB_test')
# Created in database, but not assigned:
LogicalCluster.objects.create(name='cluster3_siteA_dev')
LogicalCluster.objects.create(name='cluster4_siteC_prod')
# Link directors with newly created clusters.
# Numbers in brackets represent cluster ids in the database.
first_director.cluster.add(1)
second_director.cluster.add(2)
VarnishServer.objects.create(
ip='192.168.199.2',
port=6082,
hostname='varnish-3',
dc=dc1,
template=template3,
cluster_weight=1,
secret='edcf6c52-6f93-4d0d-82b9-cd74239146b0',
enabled=True,
cluster=cluster1_siteA_test
)
VarnishServer.objects.create(
ip='192.168.199.3',
port=6082,
hostname='varnish-4',
dc=dc1,
template=template4,
cluster_weight=1,
secret='edcf6c52-6f93-4d0d-82b9-cd74239146b0',
enabled=True,
cluster=cluster2_siteB_test
)
VarnishServer.objects.create(
ip='192.168.199.4',
port=6082,
hostname='varnish-4.1',
dc=dc1,
template=template4,
cluster_weight=1,
secret='edcf6c52-6f93-4d0d-82b9-cd74239146b0',
enabled=True,
cluster=cluster2_siteB_test
)
VarnishCluster().load_vcl(datetime.datetime.now().isoformat(), [cluster1_siteA_test, cluster2_siteB_test])
def vcl(request, varnish_server_pk):
return HttpResponse(VarnishCluster().get_vcl_content(
int(varnish_server_pk)),
content_type="text/plain")
