1222 lines
48 KiB
Python
1222 lines
48 KiB
Python
# Copyright (c) 2013 Christian Schwede <christian.schwede@enovance.com>
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
# implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import json
|
|
import mock
|
|
import os
|
|
import random
|
|
import re
|
|
import tempfile
|
|
import time
|
|
import unittest
|
|
import shutil
|
|
import string
|
|
import sys
|
|
import six
|
|
|
|
from eventlet.green import socket
|
|
from six import StringIO
|
|
from six.moves import urllib
|
|
|
|
from swift.cli import recon
|
|
from swift.common import utils
|
|
from swift.common.ring import builder
|
|
from swift.common.ring import utils as ring_utils
|
|
from swift.common.storage_policy import StoragePolicy, POLICIES
|
|
from test.unit import patch_policies
|
|
|
|
if six.PY3:
|
|
from eventlet.green.urllib import request as urllib2
|
|
GREEN_URLLIB_URLOPEN = 'eventlet.green.urllib.request.urlopen'
|
|
else:
|
|
from eventlet.green import urllib2
|
|
GREEN_URLLIB_URLOPEN = 'eventlet.green.urllib2.urlopen'
|
|
|
|
|
|
class TestHelpers(unittest.TestCase):
|
|
def test_seconds2timeunit(self):
|
|
self.assertEqual(recon.seconds2timeunit(10), (10, 'seconds'))
|
|
self.assertEqual(recon.seconds2timeunit(600), (10, 'minutes'))
|
|
self.assertEqual(recon.seconds2timeunit(36000), (10, 'hours'))
|
|
self.assertEqual(recon.seconds2timeunit(60 * 60 * 24 * 10),
|
|
(10, 'days'))
|
|
|
|
def test_size_suffix(self):
|
|
self.assertEqual(recon.size_suffix(5 * 10 ** 2), '500 bytes')
|
|
self.assertEqual(recon.size_suffix(5 * 10 ** 3), '5 kB')
|
|
self.assertEqual(recon.size_suffix(5 * 10 ** 6), '5 MB')
|
|
self.assertEqual(recon.size_suffix(5 * 10 ** 9), '5 GB')
|
|
self.assertEqual(recon.size_suffix(5 * 10 ** 12), '5 TB')
|
|
self.assertEqual(recon.size_suffix(5 * 10 ** 15), '5 PB')
|
|
self.assertEqual(recon.size_suffix(5 * 10 ** 18), '5 EB')
|
|
self.assertEqual(recon.size_suffix(5 * 10 ** 21), '5 ZB')
|
|
|
|
|
|
class TestScout(unittest.TestCase):
|
|
def setUp(self, *_args, **_kwargs):
|
|
self.scout_instance = recon.Scout("type", suppress_errors=True)
|
|
self.url = 'http://127.0.0.1:8080/recon/type'
|
|
self.server_type_url = 'http://127.0.0.1:8080/'
|
|
|
|
@mock.patch(GREEN_URLLIB_URLOPEN)
|
|
def test_scout_ok(self, mock_urlopen):
|
|
mock_urlopen.return_value.read = lambda: json.dumps([])
|
|
url, content, status, ts_start, ts_end = self.scout_instance.scout(
|
|
("127.0.0.1", "8080"))
|
|
self.assertEqual(url, self.url)
|
|
self.assertEqual(content, [])
|
|
self.assertEqual(status, 200)
|
|
|
|
@mock.patch(GREEN_URLLIB_URLOPEN)
|
|
def test_scout_url_error(self, mock_urlopen):
|
|
mock_urlopen.side_effect = urllib2.URLError("")
|
|
url, content, status, ts_start, ts_end = self.scout_instance.scout(
|
|
("127.0.0.1", "8080"))
|
|
self.assertIsInstance(content, urllib2.URLError)
|
|
self.assertEqual(url, self.url)
|
|
self.assertEqual(status, -1)
|
|
|
|
@mock.patch(GREEN_URLLIB_URLOPEN)
|
|
def test_scout_http_error(self, mock_urlopen):
|
|
mock_urlopen.side_effect = urllib2.HTTPError(
|
|
self.url, 404, "Internal error", None, None)
|
|
url, content, status, ts_start, ts_end = self.scout_instance.scout(
|
|
("127.0.0.1", "8080"))
|
|
self.assertEqual(url, self.url)
|
|
self.assertIsInstance(content, urllib2.HTTPError)
|
|
self.assertEqual(status, 404)
|
|
|
|
@mock.patch(GREEN_URLLIB_URLOPEN)
|
|
def test_scout_socket_timeout(self, mock_urlopen):
|
|
mock_urlopen.side_effect = socket.timeout("timeout")
|
|
url, content, status, ts_start, ts_end = self.scout_instance.scout(
|
|
("127.0.0.1", "8080"))
|
|
self.assertIsInstance(content, socket.timeout)
|
|
self.assertEqual(url, self.url)
|
|
self.assertEqual(status, -1)
|
|
|
|
@mock.patch(GREEN_URLLIB_URLOPEN)
|
|
def test_scout_server_type_ok(self, mock_urlopen):
|
|
def getheader(name):
|
|
d = {'Server': 'server-type'}
|
|
return d.get(name)
|
|
mock_urlopen.return_value.info.return_value.get = getheader
|
|
url, content, status = self.scout_instance.scout_server_type(
|
|
("127.0.0.1", "8080"))
|
|
self.assertEqual(url, self.server_type_url)
|
|
self.assertEqual(content, 'server-type')
|
|
self.assertEqual(status, 200)
|
|
|
|
@mock.patch(GREEN_URLLIB_URLOPEN)
|
|
def test_scout_server_type_url_error(self, mock_urlopen):
|
|
mock_urlopen.side_effect = urllib2.URLError("")
|
|
url, content, status = self.scout_instance.scout_server_type(
|
|
("127.0.0.1", "8080"))
|
|
self.assertIsInstance(content, urllib2.URLError)
|
|
self.assertEqual(url, self.server_type_url)
|
|
self.assertEqual(status, -1)
|
|
|
|
@mock.patch(GREEN_URLLIB_URLOPEN)
|
|
def test_scout_server_type_http_error(self, mock_urlopen):
|
|
mock_urlopen.side_effect = urllib2.HTTPError(
|
|
self.server_type_url, 404, "Internal error", None, None)
|
|
url, content, status = self.scout_instance.scout_server_type(
|
|
("127.0.0.1", "8080"))
|
|
self.assertEqual(url, self.server_type_url)
|
|
self.assertIsInstance(content, urllib2.HTTPError)
|
|
self.assertEqual(status, 404)
|
|
|
|
@mock.patch(GREEN_URLLIB_URLOPEN)
|
|
def test_scout_server_type_socket_timeout(self, mock_urlopen):
|
|
mock_urlopen.side_effect = socket.timeout("timeout")
|
|
url, content, status = self.scout_instance.scout_server_type(
|
|
("127.0.0.1", "8080"))
|
|
self.assertIsInstance(content, socket.timeout)
|
|
self.assertEqual(url, self.server_type_url)
|
|
self.assertEqual(status, -1)
|
|
|
|
|
|
@patch_policies
|
|
class TestRecon(unittest.TestCase):
|
|
def setUp(self, *_args, **_kwargs):
|
|
self.swift_conf_file = utils.SWIFT_CONF_FILE
|
|
self.recon_instance = recon.SwiftRecon()
|
|
self.swift_dir = tempfile.mkdtemp()
|
|
self.ring_name = POLICIES.legacy.ring_name
|
|
self.tmpfile_name = os.path.join(
|
|
self.swift_dir, self.ring_name + '.ring.gz')
|
|
self.ring_name2 = POLICIES[1].ring_name
|
|
self.tmpfile_name2 = os.path.join(
|
|
self.swift_dir, self.ring_name2 + '.ring.gz')
|
|
|
|
swift_conf = os.path.join(self.swift_dir, 'swift.conf')
|
|
self.policy_name = ''.join(random.sample(string.ascii_letters, 20))
|
|
swift_conf_data = '''
|
|
[swift-hash]
|
|
swift_hash_path_suffix = changeme
|
|
|
|
[storage-policy:0]
|
|
name = default
|
|
default = yes
|
|
|
|
[storage-policy:1]
|
|
name = unu
|
|
aliases = %s
|
|
''' % self.policy_name
|
|
with open(swift_conf, "wb") as sc:
|
|
sc.write(swift_conf_data.encode('utf8'))
|
|
|
|
def tearDown(self, *_args, **_kwargs):
|
|
utils.SWIFT_CONF_FILE = self.swift_conf_file
|
|
shutil.rmtree(self.swift_dir, ignore_errors=True)
|
|
|
|
def _make_object_rings(self):
|
|
ringbuilder = builder.RingBuilder(2, 3, 1)
|
|
devs = [
|
|
'r0z0-127.0.0.1:10000/sda1',
|
|
'r0z1-127.0.0.1:10001/sda1',
|
|
'r1z0-127.0.0.1:10002/sda1',
|
|
'r1z1-127.0.0.1:10003/sda1',
|
|
]
|
|
for raw_dev_str in devs:
|
|
dev = ring_utils.parse_add_value(raw_dev_str)
|
|
dev['weight'] = 1.0
|
|
ringbuilder.add_dev(dev)
|
|
ringbuilder.rebalance()
|
|
ringbuilder.get_ring().save(self.tmpfile_name)
|
|
|
|
ringbuilder = builder.RingBuilder(2, 2, 1)
|
|
devs = [
|
|
'r0z0-127.0.0.1:10000/sda1',
|
|
'r0z1-127.0.0.2:10004/sda1',
|
|
]
|
|
for raw_dev_str in devs:
|
|
dev = ring_utils.parse_add_value(raw_dev_str)
|
|
dev['weight'] = 1.0
|
|
ringbuilder.add_dev(dev)
|
|
ringbuilder.rebalance()
|
|
ringbuilder.get_ring().save(self.tmpfile_name2)
|
|
|
|
def test_gen_stats(self):
|
|
stats = self.recon_instance._gen_stats((1, 4, 10, None), 'Sample')
|
|
self.assertEqual(stats.get('name'), 'Sample')
|
|
self.assertEqual(stats.get('average'), 5.0)
|
|
self.assertEqual(stats.get('high'), 10)
|
|
self.assertEqual(stats.get('reported'), 3)
|
|
self.assertEqual(stats.get('low'), 1)
|
|
self.assertEqual(stats.get('total'), 15)
|
|
self.assertEqual(stats.get('number_none'), 1)
|
|
self.assertEqual(stats.get('perc_none'), 25.0)
|
|
|
|
def test_ptime(self):
|
|
with mock.patch('time.gmtime') as mock_gmtime:
|
|
mock_gmtime.return_value = time.struct_time(
|
|
(2013, 12, 17, 10, 0, 0, 1, 351, 0))
|
|
|
|
timestamp = self.recon_instance._ptime(1387274400)
|
|
self.assertEqual(timestamp, "2013-12-17 10:00:00")
|
|
mock_gmtime.assert_called_with(1387274400)
|
|
|
|
timestamp2 = self.recon_instance._ptime()
|
|
self.assertEqual(timestamp2, "2013-12-17 10:00:00")
|
|
mock_gmtime.assert_called_with()
|
|
|
|
def test_get_hosts(self):
|
|
self._make_object_rings()
|
|
|
|
ips = self.recon_instance.get_hosts(
|
|
None, None, self.swift_dir, [self.ring_name])
|
|
self.assertEqual(
|
|
set([('127.0.0.1', 10000), ('127.0.0.1', 10001),
|
|
('127.0.0.1', 10002), ('127.0.0.1', 10003)]), ips)
|
|
|
|
ips = self.recon_instance.get_hosts(
|
|
0, None, self.swift_dir, [self.ring_name])
|
|
self.assertEqual(
|
|
set([('127.0.0.1', 10000), ('127.0.0.1', 10001)]), ips)
|
|
|
|
ips = self.recon_instance.get_hosts(
|
|
1, None, self.swift_dir, [self.ring_name])
|
|
self.assertEqual(
|
|
set([('127.0.0.1', 10002), ('127.0.0.1', 10003)]), ips)
|
|
|
|
ips = self.recon_instance.get_hosts(
|
|
0, 0, self.swift_dir, [self.ring_name])
|
|
self.assertEqual(set([('127.0.0.1', 10000)]), ips)
|
|
|
|
ips = self.recon_instance.get_hosts(
|
|
1, 1, self.swift_dir, [self.ring_name])
|
|
self.assertEqual(set([('127.0.0.1', 10003)]), ips)
|
|
|
|
ips = self.recon_instance.get_hosts(
|
|
None, None, self.swift_dir, [self.ring_name, self.ring_name2])
|
|
self.assertEqual(
|
|
set([('127.0.0.1', 10000), ('127.0.0.1', 10001),
|
|
('127.0.0.1', 10002), ('127.0.0.1', 10003),
|
|
('127.0.0.2', 10004)]), ips)
|
|
|
|
ips = self.recon_instance.get_hosts(
|
|
0, None, self.swift_dir, [self.ring_name, self.ring_name2])
|
|
self.assertEqual(
|
|
set([('127.0.0.1', 10000), ('127.0.0.1', 10001),
|
|
('127.0.0.2', 10004)]), ips)
|
|
|
|
ips = self.recon_instance.get_hosts(
|
|
1, None, self.swift_dir, [self.ring_name, self.ring_name2])
|
|
self.assertEqual(
|
|
set([('127.0.0.1', 10002), ('127.0.0.1', 10003)]), ips)
|
|
|
|
ips = self.recon_instance.get_hosts(
|
|
0, 1, self.swift_dir, [self.ring_name, self.ring_name2])
|
|
self.assertEqual(set([('127.0.0.1', 10001),
|
|
('127.0.0.2', 10004)]), ips)
|
|
|
|
def test_get_error_ringnames(self):
|
|
# create invalid ring name files
|
|
invalid_ring_file_names = ('object.sring.gz',
|
|
'object-1.sring.gz',
|
|
'broken')
|
|
for invalid_ring in invalid_ring_file_names:
|
|
ring_path = os.path.join(self.swift_dir, invalid_ring)
|
|
with open(ring_path, 'w'):
|
|
pass
|
|
|
|
hosts = [("127.0.0.1", "8080")]
|
|
self.recon_instance.verbose = True
|
|
self.recon_instance.server_type = 'object'
|
|
stdout = StringIO()
|
|
with mock.patch('sys.stdout', new=stdout), \
|
|
mock.patch('swift.common.utils.md5'):
|
|
self.recon_instance.get_ringmd5(hosts, self.swift_dir)
|
|
output = stdout.getvalue()
|
|
self.assertNotIn('On disk ', output)
|
|
|
|
def test_get_ringmd5(self):
|
|
for server_type in ('account', 'container', 'object', 'object-1'):
|
|
ring_name = '%s.ring.gz' % server_type
|
|
ring_file = os.path.join(self.swift_dir, ring_name)
|
|
open(ring_file, 'w')
|
|
|
|
empty_file_hash = 'd41d8cd98f00b204e9800998ecf8427e'
|
|
bad_file_hash = '00000000000000000000000000000000'
|
|
hosts = [("127.0.0.1", "8080")]
|
|
with mock.patch('swift.cli.recon.Scout') as mock_scout:
|
|
scout_instance = mock.MagicMock()
|
|
url = 'http://%s:%s/recon/ringmd5' % hosts[0]
|
|
response = {
|
|
'/etc/swift/account.ring.gz': empty_file_hash,
|
|
'/etc/swift/container.ring.gz': empty_file_hash,
|
|
'/etc/swift/object.ring.gz': empty_file_hash,
|
|
'/etc/swift/object-1.ring.gz': empty_file_hash,
|
|
}
|
|
status = 200
|
|
scout_instance.scout.return_value = (url, response, status, 0, 0)
|
|
mock_scout.return_value = scout_instance
|
|
mock_hash = mock.MagicMock()
|
|
|
|
# Check correct account, container and object ring hashes
|
|
for server_type in ('account', 'container', 'object'):
|
|
self.recon_instance.server_type = server_type
|
|
stdout = StringIO()
|
|
with mock.patch('sys.stdout', new=stdout), \
|
|
mock.patch('swift.common.utils.md5', new=mock_hash):
|
|
mock_hash.return_value.hexdigest.return_value = \
|
|
empty_file_hash
|
|
self.recon_instance.get_ringmd5(hosts, self.swift_dir)
|
|
output = stdout.getvalue()
|
|
expected = '1/1 hosts matched'
|
|
found = False
|
|
for line in output.splitlines():
|
|
if '!!' in line:
|
|
self.fail('Unexpected Error in output: %r' % line)
|
|
if expected in line:
|
|
found = True
|
|
if not found:
|
|
self.fail('Did not find expected substring %r '
|
|
'in output:\n%s' % (expected, output))
|
|
|
|
# Check bad container ring hash
|
|
self.recon_instance.server_type = 'container'
|
|
response = {
|
|
'/etc/swift/account.ring.gz': empty_file_hash,
|
|
'/etc/swift/container.ring.gz': bad_file_hash,
|
|
'/etc/swift/object.ring.gz': empty_file_hash,
|
|
'/etc/swift/object-1.ring.gz': empty_file_hash,
|
|
}
|
|
scout_instance.scout.return_value = (url, response, status, 0, 0)
|
|
mock_scout.return_value = scout_instance
|
|
stdout = StringIO()
|
|
with mock.patch('sys.stdout', new=stdout), \
|
|
mock.patch('swift.common.utils.md5', new=mock_hash):
|
|
mock_hash.return_value.hexdigest.return_value = \
|
|
empty_file_hash
|
|
self.recon_instance.get_ringmd5(hosts, self.swift_dir)
|
|
output = stdout.getvalue()
|
|
expected = '0/1 hosts matched'
|
|
found = False
|
|
for line in output.splitlines():
|
|
if '!!' in line:
|
|
self.assertIn('doesn\'t match on disk md5sum', line)
|
|
if expected in line:
|
|
found = True
|
|
if not found:
|
|
self.fail('Did not find expected substring %r '
|
|
'in output:\n%s' % (expected, output))
|
|
|
|
# Check object ring, container mismatch should be ignored
|
|
self.recon_instance.server_type = 'object'
|
|
stdout = StringIO()
|
|
with mock.patch('sys.stdout', new=stdout), \
|
|
mock.patch('swift.common.utils.md5', new=mock_hash):
|
|
mock_hash.return_value.hexdigest.return_value = \
|
|
empty_file_hash
|
|
self.recon_instance.get_ringmd5(hosts, self.swift_dir)
|
|
output = stdout.getvalue()
|
|
expected = '1/1 hosts matched'
|
|
for line in output.splitlines():
|
|
if '!!' in line:
|
|
self.fail('Unexpected Error in output: %r' % line)
|
|
if expected in line:
|
|
found = True
|
|
if not found:
|
|
self.fail('Did not find expected substring %r '
|
|
'in output:\n%s' % (expected, output))
|
|
|
|
# Cleanup
|
|
self.recon_instance.server_type = 'object'
|
|
for ring in ('account', 'container', 'object', 'object-1'):
|
|
os.remove(os.path.join(self.swift_dir, "%s.ring.gz" % ring))
|
|
|
|
def test_quarantine_check(self):
|
|
hosts = [('127.0.0.1', 6010), ('127.0.0.1', 6020),
|
|
('127.0.0.1', 6030), ('127.0.0.1', 6040),
|
|
('127.0.0.1', 6050)]
|
|
# sample json response from http://<host>:<port>/recon/quarantined
|
|
responses = {6010: {'accounts': 0, 'containers': 0, 'objects': 1,
|
|
'policies': {'0': {'objects': 0},
|
|
'1': {'objects': 1}}},
|
|
6020: {'accounts': 1, 'containers': 1, 'objects': 3,
|
|
'policies': {'0': {'objects': 1},
|
|
'1': {'objects': 2}}},
|
|
6030: {'accounts': 2, 'containers': 2, 'objects': 5,
|
|
'policies': {'0': {'objects': 2},
|
|
'1': {'objects': 3}}},
|
|
6040: {'accounts': 3, 'containers': 3, 'objects': 7,
|
|
'policies': {'0': {'objects': 3},
|
|
'1': {'objects': 4}}},
|
|
# A server without storage policies enabled
|
|
6050: {'accounts': 0, 'containers': 0, 'objects': 4}}
|
|
# <low> <high> <avg> <total> <Failed> <no_result> <reported>
|
|
expected = {'objects_0': (0, 3, 1.5, 6, 0.0, 0, 4),
|
|
'objects_1': (1, 4, 2.5, 10, 0.0, 0, 4),
|
|
'objects': (1, 7, 4.0, 20, 0.0, 0, 5),
|
|
'accounts': (0, 3, 1.2, 6, 0.0, 0, 5),
|
|
'containers': (0, 3, 1.2, 6, 0.0, 0, 5)}
|
|
|
|
def mock_scout_quarantine(app, host):
|
|
url = 'http://%s:%s/recon/quarantined' % host
|
|
response = responses[host[1]]
|
|
status = 200
|
|
return url, response, status, 0, 0
|
|
|
|
stdout = StringIO()
|
|
with mock.patch('swift.cli.recon.Scout.scout',
|
|
mock_scout_quarantine), \
|
|
mock.patch('sys.stdout', new=stdout):
|
|
self.recon_instance.quarantine_check(hosts)
|
|
|
|
output = stdout.getvalue()
|
|
r = re.compile(r"\[quarantined_(.*)\](.*)")
|
|
for line in output.splitlines():
|
|
m = r.match(line)
|
|
if m:
|
|
ex = expected.pop(m.group(1))
|
|
self.assertEqual(m.group(2),
|
|
" low: %s, high: %s, avg: %s, total: %s,"
|
|
" Failed: %s%%, no_result: %s, reported: %s"
|
|
% ex)
|
|
self.assertFalse(expected)
|
|
|
|
def test_async_check(self):
|
|
hosts = [('127.0.0.1', 6011), ('127.0.0.1', 6021),
|
|
('127.0.0.1', 6031), ('127.0.0.1', 6041)]
|
|
# sample json response from http://<host>:<port>/recon/async
|
|
responses = {6011: {'async_pending': 15},
|
|
6021: {'async_pending': 0},
|
|
6031: {'async_pending': 257},
|
|
6041: {'async_pending': 56}}
|
|
# <low> <high> <avg> <total> <Failed> <no_result> <reported>
|
|
expected = (0, 257, 82.0, 328, 0.0, 0, 4)
|
|
|
|
def mock_scout_async(app, host):
|
|
url = 'http://%s:%s/recon/async' % host
|
|
response = responses[host[1]]
|
|
status = 200
|
|
return url, response, status, 0, 0
|
|
|
|
stdout = StringIO()
|
|
with mock.patch('swift.cli.recon.Scout.scout',
|
|
mock_scout_async), \
|
|
mock.patch('sys.stdout', new=stdout):
|
|
self.recon_instance.async_check(hosts)
|
|
|
|
output = stdout.getvalue()
|
|
r = re.compile(r"\[async_pending(.*)\](.*)")
|
|
lines = output.splitlines()
|
|
self.assertTrue(lines)
|
|
for line in lines:
|
|
m = r.match(line)
|
|
if m:
|
|
self.assertEqual(m.group(2),
|
|
" low: %s, high: %s, avg: %s, total: %s,"
|
|
" Failed: %s%%, no_result: %s, reported: %s"
|
|
% expected)
|
|
break
|
|
else:
|
|
self.fail('The expected line is not found')
|
|
|
|
def test_umount_check(self):
|
|
hosts = [('127.0.0.1', 6010), ('127.0.0.1', 6020),
|
|
('127.0.0.1', 6030), ('127.0.0.1', 6040)]
|
|
# sample json response from http://<host>:<port>/recon/unmounted
|
|
responses = {6010: [{'device': 'sdb1', 'mounted': False}],
|
|
6020: [{'device': 'sdb2', 'mounted': False}],
|
|
6030: [{'device': 'sdb3', 'mounted': False}],
|
|
6040: [{'device': 'sdb4', 'mounted': 'bad'}]}
|
|
|
|
expected = ['Not mounted: sdb1 on 127.0.0.1:6010',
|
|
'Not mounted: sdb2 on 127.0.0.1:6020',
|
|
'Not mounted: sdb3 on 127.0.0.1:6030',
|
|
'Device errors: sdb4 on 127.0.0.1:6040']
|
|
|
|
def mock_scout_umount(app, host):
|
|
url = 'http://%s:%s/recon/unmounted' % host
|
|
response = responses[host[1]]
|
|
status = 200
|
|
return url, response, status, 0, 0
|
|
|
|
stdout = StringIO()
|
|
with mock.patch('swift.cli.recon.Scout.scout',
|
|
mock_scout_umount), \
|
|
mock.patch('sys.stdout', new=stdout):
|
|
self.recon_instance.umount_check(hosts)
|
|
|
|
output = stdout.getvalue()
|
|
r = re.compile(r"^Not mounted:|Device errors: .*")
|
|
lines = output.splitlines()
|
|
self.assertTrue(lines)
|
|
for line in lines:
|
|
m = r.match(line)
|
|
if m:
|
|
self.assertIn(line, expected)
|
|
expected.remove(line)
|
|
self.assertFalse(expected)
|
|
|
|
def test_drive_audit_check(self):
|
|
hosts = [('127.0.0.1', 6010), ('127.0.0.1', 6020),
|
|
('127.0.0.1', 6030), ('127.0.0.1', 6040)]
|
|
# sample json response from http://<host>:<port>/recon/driveaudit
|
|
responses = {6010: {'drive_audit_errors': 15},
|
|
6020: {'drive_audit_errors': 0},
|
|
6030: {'drive_audit_errors': 257},
|
|
6040: {'drive_audit_errors': 56}}
|
|
# <low> <high> <avg> <total> <Failed> <no_result> <reported>
|
|
expected = (0, 257, 82.0, 328, 0.0, 0, 4)
|
|
|
|
def mock_scout_driveaudit(app, host):
|
|
url = 'http://%s:%s/recon/driveaudit' % host
|
|
response = responses[host[1]]
|
|
status = 200
|
|
return url, response, status, 0, 0
|
|
|
|
stdout = StringIO()
|
|
with mock.patch('swift.cli.recon.Scout.scout',
|
|
mock_scout_driveaudit), \
|
|
mock.patch('sys.stdout', new=stdout):
|
|
self.recon_instance.driveaudit_check(hosts)
|
|
|
|
output = stdout.getvalue()
|
|
r = re.compile(r"\[drive_audit_errors(.*)\](.*)")
|
|
lines = output.splitlines()
|
|
self.assertTrue(lines)
|
|
for line in lines:
|
|
m = r.match(line)
|
|
if m:
|
|
self.assertEqual(m.group(2),
|
|
" low: %s, high: %s, avg: %s, total: %s,"
|
|
" Failed: %s%%, no_result: %s, reported: %s"
|
|
% expected)
|
|
|
|
def test_get_ring_names(self):
|
|
self.recon_instance.server_type = 'not-object'
|
|
self.assertEqual(self.recon_instance._get_ring_names(), ['not-object'])
|
|
|
|
self.recon_instance.server_type = 'object'
|
|
|
|
with patch_policies([StoragePolicy(0, 'zero', is_default=True)]):
|
|
self.assertEqual(self.recon_instance._get_ring_names(),
|
|
['object'])
|
|
|
|
with patch_policies([StoragePolicy(0, 'zero', is_default=True),
|
|
StoragePolicy(1, 'one')]):
|
|
self.assertEqual(self.recon_instance._get_ring_names(),
|
|
['object', 'object-1'])
|
|
self.assertEqual(self.recon_instance._get_ring_names('0'),
|
|
['object'])
|
|
self.assertEqual(self.recon_instance._get_ring_names('zero'),
|
|
['object'])
|
|
self.assertEqual(self.recon_instance._get_ring_names('1'),
|
|
['object-1'])
|
|
self.assertEqual(self.recon_instance._get_ring_names('one'),
|
|
['object-1'])
|
|
|
|
self.assertEqual(self.recon_instance._get_ring_names('3'), [])
|
|
self.assertEqual(self.recon_instance._get_ring_names('wrong'),
|
|
[])
|
|
|
|
def test_main_object_hosts_default_all_policies(self):
|
|
self._make_object_rings()
|
|
discovered_hosts = set()
|
|
|
|
def server_type_check(hosts):
|
|
for h in hosts:
|
|
discovered_hosts.add(h)
|
|
|
|
self.recon_instance.server_type_check = server_type_check
|
|
with mock.patch.object(sys, 'argv', [
|
|
"prog", "object", "--swiftdir=%s" % self.swift_dir,
|
|
"--validate-servers"]):
|
|
self.recon_instance.main()
|
|
|
|
expected = set([
|
|
('127.0.0.1', 10000),
|
|
('127.0.0.1', 10001),
|
|
('127.0.0.1', 10002),
|
|
('127.0.0.1', 10003),
|
|
('127.0.0.2', 10004),
|
|
])
|
|
|
|
self.assertEqual(expected, discovered_hosts)
|
|
|
|
def _test_main_object_hosts_policy_name(self, policy_name='unu'):
|
|
self._make_object_rings()
|
|
discovered_hosts = set()
|
|
|
|
def server_type_check(hosts):
|
|
for h in hosts:
|
|
discovered_hosts.add(h)
|
|
|
|
self.recon_instance.server_type_check = server_type_check
|
|
|
|
with mock.patch.object(sys, 'argv', [
|
|
"prog", "object", "--swiftdir=%s" % self.swift_dir,
|
|
"--validate-servers", '--policy', policy_name]):
|
|
|
|
self.recon_instance.main()
|
|
|
|
expected = set([
|
|
('127.0.0.1', 10000),
|
|
('127.0.0.2', 10004),
|
|
])
|
|
self.assertEqual(expected, discovered_hosts)
|
|
|
|
def test_main_object_hosts_default_unu(self):
|
|
self._test_main_object_hosts_policy_name()
|
|
|
|
def test_main_object_hosts_default_alias(self):
|
|
self._test_main_object_hosts_policy_name(self.policy_name)
|
|
|
|
def test_main_object_hosts_default_invalid(self):
|
|
self._make_object_rings()
|
|
stdout = StringIO()
|
|
with mock.patch.object(sys, 'argv', [
|
|
"prog", "object", "--swiftdir=%s" % self.swift_dir,
|
|
"--validate-servers", '--policy=invalid']),\
|
|
mock.patch('sys.stdout', stdout):
|
|
self.assertRaises(SystemExit, recon.main)
|
|
self.assertIn('Invalid Storage Policy', stdout.getvalue())
|
|
|
|
|
|
class TestReconCommands(unittest.TestCase):
|
|
def setUp(self):
|
|
self.recon = recon.SwiftRecon()
|
|
self.hosts = set([('127.0.0.1', 10000)])
|
|
|
|
def mock_responses(self, resps):
|
|
|
|
def fake_urlopen(url, timeout):
|
|
scheme, netloc, path, _, _, _ = urllib.parse.urlparse(url)
|
|
self.assertEqual(scheme, 'http') # can't handle anything else
|
|
self.assertTrue(path.startswith('/recon/'))
|
|
|
|
if ':' in netloc:
|
|
host, port = netloc.split(':', 1)
|
|
port = int(port)
|
|
else:
|
|
host = netloc
|
|
port = 80
|
|
|
|
response_body = resps[(host, port, path[7:])]
|
|
|
|
resp = mock.MagicMock()
|
|
resp.read = mock.MagicMock(side_effect=[
|
|
response_body if six.PY2 else response_body.encode('utf8')])
|
|
return resp
|
|
|
|
return mock.patch(GREEN_URLLIB_URLOPEN, fake_urlopen)
|
|
|
|
def test_server_type_check(self):
|
|
hosts = [('127.0.0.1', 6010), ('127.0.0.1', 6011),
|
|
('127.0.0.1', 6012)]
|
|
|
|
# sample json response from http://<host>:<port>/
|
|
responses = {6010: 'object-server', 6011: 'container-server',
|
|
6012: 'account-server'}
|
|
|
|
def mock_scout_server_type(app, host):
|
|
url = 'http://%s:%s/' % (host[0], host[1])
|
|
response = responses[host[1]]
|
|
status = 200
|
|
return url, response, status
|
|
|
|
stdout = StringIO()
|
|
res_object = 'Invalid: http://127.0.0.1:6010/ is object-server'
|
|
res_container = 'Invalid: http://127.0.0.1:6011/ is container-server'
|
|
res_account = 'Invalid: http://127.0.0.1:6012/ is account-server'
|
|
valid = "1/1 hosts ok, 0 error[s] while checking hosts."
|
|
|
|
# Test for object server type - default
|
|
with mock.patch('swift.cli.recon.Scout.scout_server_type',
|
|
mock_scout_server_type), \
|
|
mock.patch('sys.stdout', new=stdout):
|
|
self.recon.server_type_check(hosts)
|
|
|
|
output = stdout.getvalue()
|
|
self.assertIn(res_container, output.splitlines())
|
|
self.assertIn(res_account, output.splitlines())
|
|
stdout.truncate(0)
|
|
|
|
# Test ok for object server type - default
|
|
with mock.patch('swift.cli.recon.Scout.scout_server_type',
|
|
mock_scout_server_type), \
|
|
mock.patch('sys.stdout', new=stdout):
|
|
self.recon.server_type_check([hosts[0]])
|
|
|
|
output = stdout.getvalue()
|
|
self.assertIn(valid, output.splitlines())
|
|
stdout.truncate(0)
|
|
|
|
# Test for account server type
|
|
with mock.patch('swift.cli.recon.Scout.scout_server_type',
|
|
mock_scout_server_type), \
|
|
mock.patch('sys.stdout', new=stdout):
|
|
self.recon.server_type = 'account'
|
|
self.recon.server_type_check(hosts)
|
|
|
|
output = stdout.getvalue()
|
|
self.assertIn(res_container, output.splitlines())
|
|
self.assertIn(res_object, output.splitlines())
|
|
stdout.truncate(0)
|
|
|
|
# Test ok for account server type
|
|
with mock.patch('swift.cli.recon.Scout.scout_server_type',
|
|
mock_scout_server_type), \
|
|
mock.patch('sys.stdout', new=stdout):
|
|
self.recon.server_type = 'account'
|
|
self.recon.server_type_check([hosts[2]])
|
|
|
|
output = stdout.getvalue()
|
|
self.assertIn(valid, output.splitlines())
|
|
stdout.truncate(0)
|
|
|
|
# Test for container server type
|
|
with mock.patch('swift.cli.recon.Scout.scout_server_type',
|
|
mock_scout_server_type), \
|
|
mock.patch('sys.stdout', new=stdout):
|
|
self.recon.server_type = 'container'
|
|
self.recon.server_type_check(hosts)
|
|
|
|
output = stdout.getvalue()
|
|
self.assertIn(res_account, output.splitlines())
|
|
self.assertIn(res_object, output.splitlines())
|
|
stdout.truncate(0)
|
|
|
|
# Test ok for container server type
|
|
with mock.patch('swift.cli.recon.Scout.scout_server_type',
|
|
mock_scout_server_type), \
|
|
mock.patch('sys.stdout', new=stdout):
|
|
self.recon.server_type = 'container'
|
|
self.recon.server_type_check([hosts[1]])
|
|
|
|
output = stdout.getvalue()
|
|
self.assertIn(valid, output.splitlines())
|
|
|
|
def test_get_swiftconfmd5(self):
|
|
hosts = set([('10.1.1.1', 10000),
|
|
('10.2.2.2', 10000)])
|
|
cksum = '729cf900f2876dead617d088ece7fe8c'
|
|
|
|
responses = {
|
|
('10.1.1.1', 10000, 'swiftconfmd5'):
|
|
json.dumps({'/etc/swift/swift.conf': cksum}),
|
|
('10.2.2.2', 10000, 'swiftconfmd5'):
|
|
json.dumps({'/etc/swift/swift.conf': cksum})}
|
|
|
|
printed = []
|
|
with self.mock_responses(responses):
|
|
with mock.patch('swift.cli.recon.md5_hash_for_file',
|
|
lambda _: cksum):
|
|
self.recon.get_swiftconfmd5(hosts, printfn=printed.append)
|
|
|
|
output = '\n'.join(printed) + '\n'
|
|
self.assertIn("2/2 hosts matched", output)
|
|
|
|
def test_get_swiftconfmd5_mismatch(self):
|
|
hosts = set([('10.1.1.1', 10000),
|
|
('10.2.2.2', 10000)])
|
|
cksum = '29d5912b1fcfcc1066a7f51412769c1d'
|
|
|
|
responses = {
|
|
('10.1.1.1', 10000, 'swiftconfmd5'):
|
|
json.dumps({'/etc/swift/swift.conf': cksum}),
|
|
('10.2.2.2', 10000, 'swiftconfmd5'):
|
|
json.dumps({'/etc/swift/swift.conf': 'bogus'})}
|
|
|
|
printed = []
|
|
with self.mock_responses(responses):
|
|
with mock.patch('swift.cli.recon.md5_hash_for_file',
|
|
lambda _: cksum):
|
|
self.recon.get_swiftconfmd5(hosts, printfn=printed.append)
|
|
|
|
output = '\n'.join(printed) + '\n'
|
|
self.assertIn("1/2 hosts matched", output)
|
|
self.assertIn("http://10.2.2.2:10000/recon/swiftconfmd5 (bogus) "
|
|
"doesn't match on disk md5sum", output)
|
|
|
|
def test_object_auditor_check(self):
|
|
# Recon middleware response from an object server
|
|
def dummy_request(*args, **kwargs):
|
|
values = {
|
|
'passes': 0, 'errors': 0, 'audit_time': 0,
|
|
'start_time': 0, 'quarantined': 0, 'bytes_processed': 0}
|
|
|
|
return [('http://127.0.0.1:6010/recon/auditor/object', {
|
|
'object_auditor_stats_ALL': values,
|
|
'object_auditor_stats_ZBF': values,
|
|
}, 200, 0, 0)]
|
|
|
|
response = {}
|
|
|
|
def catch_print(computed):
|
|
response[computed.get('name')] = computed
|
|
|
|
cli = recon.SwiftRecon()
|
|
cli.pool.imap = dummy_request
|
|
cli._print_stats = catch_print
|
|
|
|
cli.object_auditor_check([('127.0.0.1', 6010)])
|
|
|
|
# Now check that output contains all keys and names
|
|
keys = ['average', 'number_none', 'high',
|
|
'reported', 'low', 'total', 'perc_none']
|
|
|
|
names = [
|
|
'ALL_audit_time_last_path',
|
|
'ALL_quarantined_last_path',
|
|
'ALL_errors_last_path',
|
|
'ALL_passes_last_path',
|
|
'ALL_bytes_processed_last_path',
|
|
'ZBF_audit_time_last_path',
|
|
'ZBF_quarantined_last_path',
|
|
'ZBF_errors_last_path',
|
|
'ZBF_bytes_processed_last_path'
|
|
]
|
|
|
|
for name in names:
|
|
computed = response.get(name)
|
|
self.assertTrue(computed)
|
|
for key in keys:
|
|
self.assertIn(key, computed)
|
|
|
|
def test_disk_usage(self):
|
|
def dummy_request(*args, **kwargs):
|
|
return [('http://127.0.0.1:6010/recon/diskusage', [
|
|
{"device": "sdb1", "mounted": True,
|
|
"avail": 10, "used": 90, "size": 100},
|
|
{"device": "sdc1", "mounted": True,
|
|
"avail": 15, "used": 85, "size": 100},
|
|
{"device": "sdd1", "mounted": True,
|
|
"avail": 15, "used": 85, "size": 100}],
|
|
200,
|
|
0,
|
|
0)]
|
|
|
|
cli = recon.SwiftRecon()
|
|
cli.pool.imap = dummy_request
|
|
|
|
default_calls = [
|
|
mock.call('Distribution Graph:'),
|
|
mock.call(' 85% 2 **********************************' +
|
|
'***********************************'),
|
|
mock.call(' 90% 1 **********************************'),
|
|
mock.call('Disk usage: space used: 260 of 300'),
|
|
mock.call('Disk usage: space free: 40 of 300'),
|
|
mock.call('Disk usage: lowest: 85.0%, ' +
|
|
'highest: 90.0%%, avg: %s' %
|
|
('86.6666666667%' if six.PY2 else
|
|
'86.66666666666667%')),
|
|
mock.call('=' * 79),
|
|
]
|
|
|
|
with mock.patch('six.moves.builtins.print') as mock_print:
|
|
cli.disk_usage([('127.0.0.1', 6010)])
|
|
mock_print.assert_has_calls(default_calls)
|
|
|
|
with mock.patch('six.moves.builtins.print') as mock_print:
|
|
expected_calls = default_calls + [
|
|
mock.call('LOWEST 5'),
|
|
mock.call('85.00% 127.0.0.1 sdc1'),
|
|
mock.call('85.00% 127.0.0.1 sdd1'),
|
|
mock.call('90.00% 127.0.0.1 sdb1')
|
|
]
|
|
cli.disk_usage([('127.0.0.1', 6010)], 0, 5)
|
|
mock_print.assert_has_calls(expected_calls)
|
|
|
|
with mock.patch('six.moves.builtins.print') as mock_print:
|
|
expected_calls = default_calls + [
|
|
mock.call('TOP 5'),
|
|
mock.call('90.00% 127.0.0.1 sdb1'),
|
|
mock.call('85.00% 127.0.0.1 sdc1'),
|
|
mock.call('85.00% 127.0.0.1 sdd1')
|
|
]
|
|
cli.disk_usage([('127.0.0.1', 6010)], 5, 0)
|
|
mock_print.assert_has_calls(expected_calls)
|
|
|
|
@mock.patch('six.moves.builtins.print')
|
|
@mock.patch('time.time')
|
|
def test_replication_check(self, mock_now, mock_print):
|
|
now = 1430000000.0
|
|
|
|
def dummy_request(*args, **kwargs):
|
|
return [
|
|
('http://127.0.0.1:6011/recon/replication/container',
|
|
{"replication_last": now,
|
|
"replication_stats": {
|
|
"no_change": 2, "rsync": 0, "success": 3, "failure": 1,
|
|
"attempted": 0, "ts_repl": 0, "remove": 0,
|
|
"remote_merge": 0, "diff_capped": 0, "start": now,
|
|
"hashmatch": 0, "diff": 0, "empty": 0},
|
|
"replication_time": 42},
|
|
200,
|
|
0,
|
|
0),
|
|
('http://127.0.0.1:6021/recon/replication/container',
|
|
{"replication_last": now,
|
|
"replication_stats": {
|
|
"no_change": 0, "rsync": 0, "success": 1, "failure": 0,
|
|
"attempted": 0, "ts_repl": 0, "remove": 0,
|
|
"remote_merge": 0, "diff_capped": 0, "start": now,
|
|
"hashmatch": 0, "diff": 0, "empty": 0},
|
|
"replication_time": 23},
|
|
200,
|
|
0,
|
|
0),
|
|
]
|
|
|
|
cli = recon.SwiftRecon()
|
|
cli.pool.imap = dummy_request
|
|
|
|
default_calls = [
|
|
mock.call('[replication_failure] low: 0, high: 1, avg: 0.5, ' +
|
|
'total: 1, Failed: 0.0%, no_result: 0, reported: 2'),
|
|
mock.call('[replication_success] low: 1, high: 3, avg: 2.0, ' +
|
|
'total: 4, Failed: 0.0%, no_result: 0, reported: 2'),
|
|
mock.call('[replication_time] low: 23, high: 42, avg: 32.5, ' +
|
|
'total: 65, Failed: 0.0%, no_result: 0, reported: 2'),
|
|
mock.call('[replication_attempted] low: 0, high: 0, avg: 0.0, ' +
|
|
'total: 0, Failed: 0.0%, no_result: 0, reported: 2'),
|
|
mock.call('Oldest completion was 2015-04-25 22:13:20 ' +
|
|
'(42 seconds ago) by 127.0.0.1:6011.'),
|
|
mock.call('Most recent completion was 2015-04-25 22:13:20 ' +
|
|
'(42 seconds ago) by 127.0.0.1:6011.'),
|
|
]
|
|
|
|
mock_now.return_value = now + 42
|
|
cli.replication_check([('127.0.0.1', 6011), ('127.0.0.1', 6021)])
|
|
# We need any_order=True because the order of calls depends on the dict
|
|
# that is returned from the recon middleware, thus can't rely on it
|
|
mock_print.assert_has_calls(default_calls, any_order=True)
|
|
|
|
@mock.patch('six.moves.builtins.print')
|
|
@mock.patch('time.time')
|
|
def test_load_check(self, mock_now, mock_print):
|
|
now = 1430000000.0
|
|
|
|
def dummy_request(*args, **kwargs):
|
|
return [
|
|
('http://127.0.0.1:6010/recon/load',
|
|
{"1m": 0.2, "5m": 0.4, "15m": 0.25,
|
|
"processes": 10000, "tasks": "1/128"},
|
|
200,
|
|
0,
|
|
0),
|
|
('http://127.0.0.1:6020/recon/load',
|
|
{"1m": 0.4, "5m": 0.8, "15m": 0.75,
|
|
"processes": 9000, "tasks": "1/200"},
|
|
200,
|
|
0,
|
|
0),
|
|
]
|
|
|
|
cli = recon.SwiftRecon()
|
|
cli.pool.imap = dummy_request
|
|
|
|
default_calls = [
|
|
mock.call('[5m_load_avg] low: 0, high: 0, avg: 0.6, total: 1, ' +
|
|
'Failed: 0.0%, no_result: 0, reported: 2'),
|
|
mock.call('[15m_load_avg] low: 0, high: 0, avg: 0.5, total: 1, ' +
|
|
'Failed: 0.0%, no_result: 0, reported: 2'),
|
|
mock.call('[1m_load_avg] low: 0, high: 0, avg: 0.3, total: 0, ' +
|
|
'Failed: 0.0%, no_result: 0, reported: 2'),
|
|
]
|
|
|
|
mock_now.return_value = now + 42
|
|
cli.load_check([('127.0.0.1', 6010), ('127.0.0.1', 6020)])
|
|
# We need any_order=True because the order of calls depends on the dict
|
|
# that is returned from the recon middleware, thus can't rely on it
|
|
mock_print.assert_has_calls(default_calls, any_order=True)
|
|
|
|
@mock.patch('six.moves.builtins.print')
|
|
@mock.patch('time.time')
|
|
def test_time_check(self, mock_now, mock_print):
|
|
now = 1430000000.0
|
|
mock_now.return_value = now
|
|
|
|
def dummy_request(*args, **kwargs):
|
|
return [
|
|
('http://127.0.0.1:6010/recon/time',
|
|
now,
|
|
200,
|
|
now - 0.5,
|
|
now + 0.5),
|
|
('http://127.0.0.1:6020/recon/time',
|
|
now,
|
|
200,
|
|
now,
|
|
now),
|
|
]
|
|
|
|
cli = recon.SwiftRecon()
|
|
cli.pool.imap = dummy_request
|
|
|
|
default_calls = [
|
|
mock.call('2/2 hosts matched, 0 error[s] while checking hosts.')
|
|
]
|
|
|
|
cli.time_check([('127.0.0.1', 6010), ('127.0.0.1', 6020)])
|
|
# We need any_order=True because the order of calls depends on the dict
|
|
# that is returned from the recon middleware, thus can't rely on it
|
|
mock_print.assert_has_calls(default_calls, any_order=True)
|
|
|
|
@mock.patch('six.moves.builtins.print')
|
|
@mock.patch('time.time')
|
|
def test_time_check_mismatch(self, mock_now, mock_print):
|
|
now = 1430000000.0
|
|
mock_now.return_value = now
|
|
|
|
def dummy_request(*args, **kwargs):
|
|
return [
|
|
('http://127.0.0.1:6010/recon/time',
|
|
now,
|
|
200,
|
|
now + 0.5,
|
|
now + 1.3),
|
|
('http://127.0.0.1:6020/recon/time',
|
|
now,
|
|
200,
|
|
now,
|
|
now),
|
|
]
|
|
|
|
cli = recon.SwiftRecon()
|
|
cli.pool.imap = dummy_request
|
|
|
|
default_calls = [
|
|
mock.call("!! http://127.0.0.1:6010/recon/time current time is "
|
|
"2015-04-25 22:13:21, but remote is "
|
|
"2015-04-25 22:13:20, differs by 1.3000 sec"),
|
|
mock.call('1/2 hosts matched, 0 error[s] while checking hosts.'),
|
|
]
|
|
|
|
cli.time_check([('127.0.0.1', 6010), ('127.0.0.1', 6020)])
|
|
|
|
# We need any_order=True because the order of calls depends on the dict
|
|
# that is returned from the recon middleware, thus can't rely on it
|
|
mock_print.assert_has_calls(default_calls, any_order=True)
|
|
|
|
@mock.patch('six.moves.builtins.print')
|
|
@mock.patch('time.time')
|
|
def test_time_check_jitter(self, mock_now, mock_print):
|
|
now = 1430000000.0
|
|
mock_now.return_value = now
|
|
|
|
def dummy_request(*args, **kwargs):
|
|
return [
|
|
('http://127.0.0.1:6010/recon/time',
|
|
now - 2,
|
|
200,
|
|
now,
|
|
now + 3),
|
|
('http://127.0.0.1:6020/recon/time',
|
|
now + 2,
|
|
200,
|
|
now - 3,
|
|
now),
|
|
]
|
|
|
|
cli = recon.SwiftRecon()
|
|
cli.pool.imap = dummy_request
|
|
|
|
default_calls = [
|
|
mock.call('2/2 hosts matched, 0 error[s] while checking hosts.')
|
|
]
|
|
|
|
cli.time_check([('127.0.0.1', 6010), ('127.0.0.1', 6020)], 3)
|
|
# We need any_order=True because the order of calls depends on the dict
|
|
# that is returned from the recon middleware, thus can't rely on it
|
|
mock_print.assert_has_calls(default_calls, any_order=True)
|
|
|
|
@mock.patch('six.moves.builtins.print')
|
|
def test_version_check(self, mock_print):
|
|
version = "2.7.1.dev144"
|
|
|
|
def dummy_request(*args, **kwargs):
|
|
return [
|
|
('http://127.0.0.1:6010/recon/version',
|
|
{'version': version},
|
|
200,
|
|
0,
|
|
0),
|
|
('http://127.0.0.1:6020/recon/version',
|
|
{'version': version},
|
|
200,
|
|
0,
|
|
0),
|
|
]
|
|
|
|
cli = recon.SwiftRecon()
|
|
cli.pool.imap = dummy_request
|
|
|
|
default_calls = [
|
|
mock.call("Versions matched (%s), "
|
|
"0 error[s] while checking hosts." % version)
|
|
]
|
|
|
|
cli.version_check([('127.0.0.1', 6010), ('127.0.0.1', 6020)])
|
|
# We need any_order=True because the order of calls depends on the dict
|
|
# that is returned from the recon middleware, thus can't rely on it
|
|
mock_print.assert_has_calls(default_calls, any_order=True)
|
|
|
|
@mock.patch('six.moves.builtins.print')
|
|
@mock.patch('time.time')
|
|
def test_time_check_jitter_mismatch(self, mock_now, mock_print):
|
|
now = 1430000000.0
|
|
mock_now.return_value = now
|
|
|
|
def dummy_request(*args, **kwargs):
|
|
return [
|
|
('http://127.0.0.1:6010/recon/time',
|
|
now - 4,
|
|
200,
|
|
now,
|
|
now + 2),
|
|
('http://127.0.0.1:6020/recon/time',
|
|
now + 4,
|
|
200,
|
|
now - 2,
|
|
now),
|
|
]
|
|
|
|
cli = recon.SwiftRecon()
|
|
cli.pool.imap = dummy_request
|
|
|
|
default_calls = [
|
|
mock.call("!! http://127.0.0.1:6010/recon/time current time is "
|
|
"2015-04-25 22:13:22, but remote is "
|
|
"2015-04-25 22:13:16, differs by 6.0000 sec"),
|
|
mock.call("!! http://127.0.0.1:6020/recon/time current time is "
|
|
"2015-04-25 22:13:20, but remote is "
|
|
"2015-04-25 22:13:24, differs by 4.0000 sec"),
|
|
mock.call('0/2 hosts matched, 0 error[s] while checking hosts.'),
|
|
]
|
|
|
|
cli.time_check([('127.0.0.1', 6010), ('127.0.0.1', 6020)], 3)
|
|
# We need any_order=True because the order of calls depends on the dict
|
|
# that is returned from the recon middleware, thus can't rely on it
|
|
mock_print.assert_has_calls(default_calls, any_order=True)
|
|
|
|
@mock.patch('six.moves.builtins.print')
|
|
def test_version_check_differs(self, mock_print):
|
|
def dummy_request(*args, **kwargs):
|
|
return [
|
|
('http://127.0.0.1:6010/recon/version',
|
|
{'version': "2.7.1.dev144"},
|
|
200,
|
|
0,
|
|
0),
|
|
('http://127.0.0.1:6020/recon/version',
|
|
{'version': "2.7.1.dev145"},
|
|
200,
|
|
0,
|
|
0),
|
|
]
|
|
|
|
cli = recon.SwiftRecon()
|
|
cli.pool.imap = dummy_request
|
|
|
|
default_calls = [
|
|
mock.call("Versions not matched (2.7.1.dev144, 2.7.1.dev145), "
|
|
"0 error[s] while checking hosts.")
|
|
]
|
|
|
|
cli.version_check([('127.0.0.1', 6010), ('127.0.0.1', 6020)])
|
|
# We need any_order=True because the order of calls depends on the dict
|
|
# that is returned from the recon middleware, thus can't rely on it
|
|
mock_print.assert_has_calls(default_calls, any_order=True)
|
|
|
|
@mock.patch('six.moves.builtins.print')
|
|
@mock.patch('swift.cli.recon.SwiftRecon.get_hosts')
|
|
def test_multiple_server_types(self, mock_get_hosts, mock_print):
|
|
mock_get_hosts.return_value = set([('127.0.0.1', 10000)])
|
|
|
|
self.recon.object_auditor_check = mock.MagicMock()
|
|
self.recon.auditor_check = mock.MagicMock()
|
|
|
|
with mock.patch.object(
|
|
sys, 'argv',
|
|
["prog", "account", "container", "object", "--auditor"]):
|
|
self.recon.main()
|
|
expected_calls = [
|
|
mock.call("--> Starting reconnaissance on 1 hosts (account)"),
|
|
mock.call("--> Starting reconnaissance on 1 hosts (container)"),
|
|
mock.call("--> Starting reconnaissance on 1 hosts (object)"),
|
|
]
|
|
mock_print.assert_has_calls(expected_calls, any_order=True)
|
|
|
|
expected = mock.call(set([('127.0.0.1', 10000)]))
|
|
self.recon.object_auditor_check.assert_has_calls([expected])
|
|
# Two calls expected - one account, one container
|
|
self.recon.auditor_check.assert_has_calls([expected, expected])
|