swift/test/unit/common/test_manager.py

1743 lines
70 KiB
Python
Raw Normal View History

# Copyright (c) 2010-2012 OpenStack Foundation
2011-02-11 13:21:28 -06:00
#
# 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 unittest
from test.unit import temptree
import os
import sys
2011-02-11 14:56:03 -06:00
import resource
2011-02-11 13:21:28 -06:00
import signal
import errno
from collections import defaultdict
from threading import Thread
from time import sleep, time
from swift.common import manager
DUMMY_SIG = 1
2011-02-11 13:21:28 -06:00
class MockOs():
RAISE_EPERM_SIG = 99
2011-02-11 13:21:28 -06:00
def __init__(self, pids):
self.running_pids = pids
self.pid_sigs = defaultdict(list)
self.closed_fds = []
self.child_pid = 9999 # fork defaults to test parent process path
self.execlp_called = False
def kill(self, pid, sig):
if sig == self.RAISE_EPERM_SIG:
raise OSError(errno.EPERM, 'Operation not permitted')
2011-02-11 13:21:28 -06:00
if pid not in self.running_pids:
raise OSError(3, 'No such process')
self.pid_sigs[pid].append(sig)
def __getattr__(self, name):
# I only over-ride portions of the os module
try:
return object.__getattr__(self, name)
except AttributeError:
return getattr(os, name)
def pop_stream(f):
"""read everything out of file from the top and clear it out
"""
f.flush()
f.seek(0)
output = f.read()
f.seek(0)
f.truncate()
#print >> sys.stderr, output
return output
2011-02-11 14:56:03 -06:00
class TestManagerModule(unittest.TestCase):
2011-02-11 13:21:28 -06:00
def test_servers(self):
main_plus_rest = set(manager.MAIN_SERVERS + manager.REST_SERVERS)
self.assertEquals(set(manager.ALL_SERVERS), main_plus_rest)
# make sure there's no server listed in both
self.assertEquals(len(main_plus_rest), len(manager.MAIN_SERVERS) +
len(manager.REST_SERVERS))
def test_setup_env(self):
2011-02-11 14:56:03 -06:00
class MockResource():
def __init__(self, error=None):
self.error = error
self.called_with_args = []
2011-02-11 14:56:03 -06:00
def setrlimit(self, resource, limits):
if self.error:
raise self.error
self.called_with_args.append((resource, limits))
def __getattr__(self, name):
# I only over-ride portions of the resource module
try:
return object.__getattr__(self, name)
except AttributeError:
return getattr(resource, name)
_orig_resource = manager.resource
_orig_environ = os.environ
try:
manager.resource = MockResource()
manager.os.environ = {}
manager.setup_env()
expected = [
(resource.RLIMIT_NOFILE, (manager.MAX_DESCRIPTORS,
manager.MAX_DESCRIPTORS)),
(resource.RLIMIT_DATA, (manager.MAX_MEMORY,
manager.MAX_MEMORY)),
(resource.RLIMIT_NPROC, (manager.MAX_PROCS,
manager.MAX_PROCS)),
2011-02-11 14:56:03 -06:00
]
self.assertEquals(manager.resource.called_with_args, expected)
self.assertTrue(
manager.os.environ['PYTHON_EGG_CACHE'].startswith('/tmp'))
2011-02-11 14:56:03 -06:00
# test error condition
manager.resource = MockResource(error=ValueError())
manager.os.environ = {}
manager.setup_env()
self.assertEquals(manager.resource.called_with_args, [])
self.assertTrue(
manager.os.environ['PYTHON_EGG_CACHE'].startswith('/tmp'))
2011-02-11 14:56:03 -06:00
manager.resource = MockResource(error=OSError())
manager.os.environ = {}
self.assertRaises(OSError, manager.setup_env)
self.assertEquals(manager.os.environ.get('PYTHON_EGG_CACHE'), None)
finally:
manager.resource = _orig_resource
os.environ = _orig_environ
2011-02-11 13:21:28 -06:00
def test_command_wrapper(self):
@manager.command
def myfunc(arg1):
"""test doc
"""
return arg1
self.assertEquals(myfunc.__doc__.strip(), 'test doc')
self.assertEquals(myfunc(1), 1)
self.assertEquals(myfunc(0), 0)
self.assertEquals(myfunc(True), 1)
self.assertEquals(myfunc(False), 0)
self.assert_(hasattr(myfunc, 'publicly_accessible'))
self.assert_(myfunc.publicly_accessible)
def test_watch_server_pids(self):
class MockOs():
WNOHANG = os.WNOHANG
def __init__(self, pid_map={}):
self.pid_map = {}
for pid, v in pid_map.items():
self.pid_map[pid] = (x for x in v)
def waitpid(self, pid, options):
try:
rv = self.pid_map[pid].next()
except StopIteration:
raise OSError(errno.ECHILD, os.strerror(errno.ECHILD))
except KeyError:
raise OSError(errno.ESRCH, os.strerror(errno.ESRCH))
if isinstance(rv, Exception):
raise rv
else:
return rv
class MockTime():
def __init__(self, ticks=None):
self.tock = time()
if not ticks:
ticks = []
self.ticks = (t for t in ticks)
def time(self):
try:
self.tock += self.ticks.next()
except StopIteration:
self.tock += 1
return self.tock
def sleep(*args):
return
class MockServer():
def __init__(self, pids, run_dir=manager.RUN_DIR, zombie=0):
self.heartbeat = (pids for _ in range(zombie))
def get_running_pids(self):
try:
rv = self.heartbeat.next()
return rv
except StopIteration:
return {}
_orig_os = manager.os
_orig_time = manager.time
_orig_server = manager.Server
try:
manager.time = MockTime()
manager.os = MockOs()
# this server always says it's dead when you ask for running pids
server = MockServer([1])
# list of pids keyed on servers to watch
server_pids = {
server: [1],
}
# basic test, server dies
gen = manager.watch_server_pids(server_pids)
expected = [(server, 1)]
2011-02-14 14:52:49 -06:00
self.assertEquals([x for x in gen], expected)
# start long running server and short interval
server = MockServer([1], zombie=15)
server_pids = {
server: [1],
}
gen = manager.watch_server_pids(server_pids)
self.assertEquals([x for x in gen], [])
# wait a little longer
gen = manager.watch_server_pids(server_pids, interval=15)
self.assertEquals([x for x in gen], [(server, 1)])
# zombie process
server = MockServer([1], zombie=200)
server_pids = {
server: [1],
}
# test weird os error
manager.os = MockOs({1: [OSError()]})
gen = manager.watch_server_pids(server_pids)
self.assertRaises(OSError, lambda: [x for x in gen])
# test multi-server
server1 = MockServer([1, 10], zombie=200)
server2 = MockServer([2, 20], zombie=8)
server_pids = {
server1: [1, 10],
server2: [2, 20],
}
pid_map = {
1: [None for _ in range(10)],
2: [None for _ in range(8)],
20: [None for _ in range(4)],
}
manager.os = MockOs(pid_map)
gen = manager.watch_server_pids(server_pids,
interval=manager.KILL_WAIT)
expected = [
(server2, 2),
(server2, 20),
]
self.assertEquals([x for x in gen], expected)
finally:
manager.os = _orig_os
manager.time = _orig_time
manager.Server = _orig_server
2011-02-11 13:21:28 -06:00
def test_exc(self):
self.assert_(issubclass(manager.UnknownCommandError, Exception))
2011-02-11 13:21:28 -06:00
class TestServer(unittest.TestCase):
def tearDown(self):
reload(manager)
def join_swift_dir(self, path):
return os.path.join(manager.SWIFT_DIR, path)
def join_run_dir(self, path):
return os.path.join(manager.RUN_DIR, path)
def test_create_server(self):
server = manager.Server('proxy')
self.assertEquals(server.server, 'proxy-server')
self.assertEquals(server.type, 'proxy')
self.assertEquals(server.cmd, 'swift-proxy-server')
server = manager.Server('object-replicator')
self.assertEquals(server.server, 'object-replicator')
self.assertEquals(server.type, 'object')
self.assertEquals(server.cmd, 'swift-object-replicator')
def test_server_to_string(self):
server = manager.Server('Proxy')
self.assertEquals(str(server), 'proxy-server')
server = manager.Server('object-replicator')
self.assertEquals(str(server), 'object-replicator')
def test_server_repr(self):
server = manager.Server('proxy')
self.assert_(server.__class__.__name__ in repr(server))
self.assert_(str(server) in repr(server))
def test_server_equality(self):
server1 = manager.Server('Proxy')
server2 = manager.Server('proxy-server')
self.assertEquals(server1, server2)
# it is NOT a string
self.assertNotEquals(server1, 'proxy-server')
def test_get_pid_file_name(self):
server = manager.Server('proxy')
conf_file = self.join_swift_dir('proxy-server.conf')
2011-02-11 13:21:28 -06:00
pid_file = self.join_run_dir('proxy-server.pid')
self.assertEquals(pid_file, server.get_pid_file_name(conf_file))
2011-02-11 13:21:28 -06:00
server = manager.Server('object-replicator')
conf_file = self.join_swift_dir('object-server/1.conf')
2011-02-11 13:21:28 -06:00
pid_file = self.join_run_dir('object-replicator/1.pid')
self.assertEquals(pid_file, server.get_pid_file_name(conf_file))
2011-02-11 13:21:28 -06:00
server = manager.Server('container-auditor')
conf_file = self.join_swift_dir(
2011-02-11 13:21:28 -06:00
'container-server/1/container-auditor.conf')
pid_file = self.join_run_dir(
'container-auditor/1/container-auditor.pid')
self.assertEquals(pid_file, server.get_pid_file_name(conf_file))
2011-02-11 13:21:28 -06:00
def test_get_custom_pid_file_name(self):
random_run_dir = "/random/dir"
get_random_run_dir = lambda x: os.path.join(random_run_dir, x)
server = manager.Server('proxy', run_dir=random_run_dir)
conf_file = self.join_swift_dir('proxy-server.conf')
pid_file = get_random_run_dir('proxy-server.pid')
self.assertEquals(pid_file, server.get_pid_file_name(conf_file))
server = manager.Server('object-replicator', run_dir=random_run_dir)
conf_file = self.join_swift_dir('object-server/1.conf')
pid_file = get_random_run_dir('object-replicator/1.pid')
self.assertEquals(pid_file, server.get_pid_file_name(conf_file))
server = manager.Server('container-auditor', run_dir=random_run_dir)
conf_file = self.join_swift_dir(
'container-server/1/container-auditor.conf')
pid_file = get_random_run_dir(
'container-auditor/1/container-auditor.pid')
self.assertEquals(pid_file, server.get_pid_file_name(conf_file))
def test_get_conf_file_name(self):
2011-02-11 13:21:28 -06:00
server = manager.Server('proxy')
conf_file = self.join_swift_dir('proxy-server.conf')
2011-02-11 13:21:28 -06:00
pid_file = self.join_run_dir('proxy-server.pid')
self.assertEquals(conf_file, server.get_conf_file_name(pid_file))
2011-02-11 13:21:28 -06:00
server = manager.Server('object-replicator')
conf_file = self.join_swift_dir('object-server/1.conf')
2011-02-11 13:21:28 -06:00
pid_file = self.join_run_dir('object-replicator/1.pid')
self.assertEquals(conf_file, server.get_conf_file_name(pid_file))
2011-02-11 13:21:28 -06:00
server = manager.Server('container-auditor')
conf_file = self.join_swift_dir(
2011-02-11 13:21:28 -06:00
'container-server/1/container-auditor.conf')
pid_file = self.join_run_dir(
'container-auditor/1/container-auditor.pid')
self.assertEquals(conf_file, server.get_conf_file_name(pid_file))
server_name = manager.STANDALONE_SERVERS[0]
server = manager.Server(server_name)
conf_file = self.join_swift_dir(server_name + '.conf')
pid_file = self.join_run_dir(server_name + '.pid')
self.assertEquals(conf_file, server.get_conf_file_name(pid_file))
2011-02-11 13:21:28 -06:00
def test_conf_files(self):
2011-02-12 14:50:24 -06:00
# test get single conf file
conf_files = (
2011-02-11 13:21:28 -06:00
'proxy-server.conf',
'proxy-server.ini',
'auth-server.conf',
)
with temptree(conf_files) as t:
2011-02-11 13:21:28 -06:00
manager.SWIFT_DIR = t
server = manager.Server('proxy')
conf_files = server.conf_files()
self.assertEquals(len(conf_files), 1)
conf_file = conf_files[0]
2011-02-11 13:21:28 -06:00
proxy_conf = self.join_swift_dir('proxy-server.conf')
self.assertEquals(conf_file, proxy_conf)
2011-02-11 13:21:28 -06:00
# test multi server conf files & grouping of server-type config
conf_files = (
2011-02-11 13:21:28 -06:00
'object-server1.conf',
'object-server/2.conf',
'object-server/object3.conf',
'object-server/conf/server4.conf',
'object-server.txt',
'proxy-server.conf',
)
with temptree(conf_files) as t:
2011-02-11 13:21:28 -06:00
manager.SWIFT_DIR = t
server = manager.Server('object-replicator')
conf_files = server.conf_files()
self.assertEquals(len(conf_files), 4)
2011-02-11 13:21:28 -06:00
c1 = self.join_swift_dir('object-server1.conf')
c2 = self.join_swift_dir('object-server/2.conf')
c3 = self.join_swift_dir('object-server/object3.conf')
c4 = self.join_swift_dir('object-server/conf/server4.conf')
for c in [c1, c2, c3, c4]:
self.assert_(c in conf_files)
2011-02-11 13:21:28 -06:00
# test configs returned sorted
sorted_confs = sorted([c1, c2, c3, c4])
self.assertEquals(conf_files, sorted_confs)
2011-02-11 13:21:28 -06:00
# test get single numbered conf
conf_files = (
2011-02-11 13:21:28 -06:00
'account-server/1.conf',
'account-server/2.conf',
'account-server/3.conf',
'account-server/4.conf',
)
with temptree(conf_files) as t:
2011-02-11 13:21:28 -06:00
manager.SWIFT_DIR = t
server = manager.Server('account')
conf_files = server.conf_files(number=2)
self.assertEquals(len(conf_files), 1)
conf_file = conf_files[0]
self.assertEquals(conf_file,
2011-02-11 13:21:28 -06:00
self.join_swift_dir('account-server/2.conf'))
# test missing config number
conf_files = server.conf_files(number=5)
self.assertFalse(conf_files)
2011-02-11 13:21:28 -06:00
# test verbose & quiet
conf_files = (
2011-02-11 13:21:28 -06:00
'auth-server.ini',
'container-server/1.conf',
)
with temptree(conf_files) as t:
2011-02-11 13:21:28 -06:00
manager.SWIFT_DIR = t
old_stdout = sys.stdout
try:
with open(os.path.join(t, 'output'), 'w+') as f:
sys.stdout = f
server = manager.Server('auth')
# check warn "unable to locate"
conf_files = server.conf_files()
self.assertFalse(conf_files)
2011-02-11 13:21:28 -06:00
self.assert_('unable to locate' in pop_stream(f).lower())
# check quiet will silence warning
conf_files = server.conf_files(verbose=True, quiet=True)
2011-02-11 13:21:28 -06:00
self.assertEquals(pop_stream(f), '')
# check found config no warning
server = manager.Server('container-auditor')
conf_files = server.conf_files()
2011-02-11 13:21:28 -06:00
self.assertEquals(pop_stream(f), '')
# check missing config number warn "unable to locate"
conf_files = server.conf_files(number=2)
2011-02-11 13:21:28 -06:00
self.assert_('unable to locate' in pop_stream(f).lower())
# check verbose lists configs
conf_files = server.conf_files(number=2, verbose=True)
2011-02-11 13:21:28 -06:00
c1 = self.join_swift_dir('container-server/1.conf')
self.assert_(c1 in pop_stream(f))
finally:
sys.stdout = old_stdout
# test standalone conf file
server_name = manager.STANDALONE_SERVERS[0]
conf_files = (server_name + '.conf',)
with temptree(conf_files) as t:
manager.SWIFT_DIR = t
server = manager.Server(server_name)
conf_files = server.conf_files()
self.assertEquals(len(conf_files), 1)
conf_file = conf_files[0]
conf = self.join_swift_dir(server_name + '.conf')
self.assertEquals(conf_file, conf)
def test_proxy_conf_dir(self):
conf_files = (
'proxy-server.conf.d/00.conf',
'proxy-server.conf.d/01.conf',
)
with temptree(conf_files) as t:
manager.SWIFT_DIR = t
server = manager.Server('proxy')
conf_dirs = server.conf_files()
self.assertEquals(len(conf_dirs), 1)
conf_dir = conf_dirs[0]
proxy_conf_dir = self.join_swift_dir('proxy-server.conf.d')
self.assertEquals(proxy_conf_dir, conf_dir)
def test_conf_dir(self):
conf_files = (
'object-server/object-server.conf-base',
'object-server/1.conf.d/base.conf',
'object-server/1.conf.d/1.conf',
'object-server/2.conf.d/base.conf',
'object-server/2.conf.d/2.conf',
'object-server/3.conf.d/base.conf',
'object-server/3.conf.d/3.conf',
'object-server/4.conf.d/base.conf',
'object-server/4.conf.d/4.conf',
)
with temptree(conf_files) as t:
manager.SWIFT_DIR = t
server = manager.Server('object-replicator')
conf_dirs = server.conf_files()
self.assertEquals(len(conf_dirs), 4)
c1 = self.join_swift_dir('object-server/1.conf.d')
c2 = self.join_swift_dir('object-server/2.conf.d')
c3 = self.join_swift_dir('object-server/3.conf.d')
c4 = self.join_swift_dir('object-server/4.conf.d')
for c in [c1, c2, c3, c4]:
self.assert_(c in conf_dirs)
# test configs returned sorted
sorted_confs = sorted([c1, c2, c3, c4])
self.assertEquals(conf_dirs, sorted_confs)
2011-02-11 13:21:28 -06:00
def test_iter_pid_files(self):
"""
Server.iter_pid_files is kinda boring, test the
Server.pid_files stuff here as well
"""
pid_files = (
('proxy-server.pid', 1),
('auth-server.pid', 'blah'),
('object-replicator/1.pid', 11),
('object-replicator/2.pid', 12),
)
files, contents = zip(*pid_files)
with temptree(files, contents) as t:
manager.RUN_DIR = t
server = manager.Server('proxy', run_dir=t)
2011-02-11 13:21:28 -06:00
# test get one file
iter = server.iter_pid_files()
pid_file, pid = iter.next()
self.assertEquals(pid_file, self.join_run_dir('proxy-server.pid'))
self.assertEquals(pid, 1)
# ... and only one file
self.assertRaises(StopIteration, iter.next)
# test invalid value in pid file
server = manager.Server('auth', run_dir=t)
2011-02-11 13:21:28 -06:00
self.assertRaises(ValueError, server.iter_pid_files().next)
# test object-server doesn't steal pids from object-replicator
server = manager.Server('object', run_dir=t)
2011-02-11 13:21:28 -06:00
self.assertRaises(StopIteration, server.iter_pid_files().next)
# test multi-pid iter
server = manager.Server('object-replicator', run_dir=t)
2011-02-11 13:21:28 -06:00
real_map = {
11: self.join_run_dir('object-replicator/1.pid'),
12: self.join_run_dir('object-replicator/2.pid'),
}
pid_map = {}
for pid_file, pid in server.iter_pid_files():
pid_map[pid] = pid_file
self.assertEquals(pid_map, real_map)
# test get pid_files by number
conf_files = (
2011-02-11 13:21:28 -06:00
'object-server/1.conf',
'object-server/2.conf',
'object-server/3.conf',
'object-server/4.conf',
)
pid_files = (
('object-server/1.pid', 1),
('object-server/2.pid', 2),
('object-server/5.pid', 5),
)
with temptree(conf_files) as swift_dir:
2011-02-11 13:21:28 -06:00
manager.SWIFT_DIR = swift_dir
files, pids = zip(*pid_files)
with temptree(files, pids) as t:
manager.RUN_DIR = t
server = manager.Server('object', run_dir=t)
2011-02-11 13:21:28 -06:00
# test get all pid files
real_map = {
1: self.join_run_dir('object-server/1.pid'),
2: self.join_run_dir('object-server/2.pid'),
5: self.join_run_dir('object-server/5.pid'),
}
pid_map = {}
for pid_file, pid in server.iter_pid_files():
pid_map[pid] = pid_file
self.assertEquals(pid_map, real_map)
# test get pid with matching conf
pids = list(server.iter_pid_files(number=2))
self.assertEquals(len(pids), 1)
pid_file, pid = pids[0]
self.assertEquals(pid, 2)
pid_two = self.join_run_dir('object-server/2.pid')
self.assertEquals(pid_file, pid_two)
# try to iter on a pid number with a matching conf but no pid
pids = list(server.iter_pid_files(number=3))
self.assertFalse(pids)
# test get pids w/o matching conf
pids = list(server.iter_pid_files(number=5))
self.assertFalse(pids)
def test_signal_pids(self):
pid_files = (
('proxy-server.pid', 1),
('auth-server.pid', 2),
('object-server.pid', 3),
2011-02-11 13:21:28 -06:00
)
files, pids = zip(*pid_files)
with temptree(files, pids) as t:
manager.RUN_DIR = t
# mock os with both pids running
manager.os = MockOs([1, 2])
server = manager.Server('proxy', run_dir=t)
2011-02-11 13:21:28 -06:00
pids = server.signal_pids(DUMMY_SIG)
self.assertEquals(len(pids), 1)
self.assert_(1 in pids)
self.assertEquals(manager.os.pid_sigs[1], [DUMMY_SIG])
# make sure other process not signaled
self.assertFalse(2 in pids)
self.assertFalse(2 in manager.os.pid_sigs)
# capture stdio
old_stdout = sys.stdout
try:
with open(os.path.join(t, 'output'), 'w+') as f:
sys.stdout = f
#test print details
pids = server.signal_pids(DUMMY_SIG)
output = pop_stream(f)
self.assert_('pid: %s' % 1 in output)
self.assert_('signal: %s' % DUMMY_SIG in output)
# test no details on signal.SIG_DFL
pids = server.signal_pids(signal.SIG_DFL)
self.assertEquals(pop_stream(f), '')
# reset mock os so only the other server is running
manager.os = MockOs([2])
# test pid not running
pids = server.signal_pids(signal.SIG_DFL)
self.assert_(1 not in pids)
self.assert_(1 not in manager.os.pid_sigs)
# test remove stale pid file
self.assertFalse(os.path.exists(
self.join_run_dir('proxy-server.pid')))
# reset mock os with no running pids
manager.os = MockOs([])
server = manager.Server('auth', run_dir=t)
2011-02-11 13:21:28 -06:00
# test verbose warns on removing pid file
pids = server.signal_pids(signal.SIG_DFL, verbose=True)
output = pop_stream(f)
self.assert_('stale pid' in output.lower())
auth_pid = self.join_run_dir('auth-server.pid')
self.assert_(auth_pid in output)
# test warning with insufficient permissions
server = manager.Server('object', run_dir=t)
pids = server.signal_pids(manager.os.RAISE_EPERM_SIG)
output = pop_stream(f)
self.assert_('no permission to signal pid 3' in
output.lower(), output)
2011-02-11 13:21:28 -06:00
finally:
sys.stdout = old_stdout
def test_get_running_pids(self):
# test only gets running pids
pid_files = (
('test-server1.pid', 1),
('test-server2.pid', 2),
)
with temptree(*zip(*pid_files)) as t:
manager.RUN_DIR = t
server = manager.Server('test-server', run_dir=t)
2011-02-11 13:21:28 -06:00
# mock os, only pid '1' is running
manager.os = MockOs([1])
running_pids = server.get_running_pids()
self.assertEquals(len(running_pids), 1)
self.assert_(1 in running_pids)
self.assert_(2 not in running_pids)
# test persistent running pid files
2011-02-11 13:21:28 -06:00
self.assert_(os.path.exists(os.path.join(t, 'test-server1.pid')))
# test clean up stale pids
pid_two = self.join_swift_dir('test-server2.pid')
self.assertFalse(os.path.exists(pid_two))
# reset mock os, no pids running
manager.os = MockOs([])
running_pids = server.get_running_pids()
self.assertFalse(running_pids)
# and now all pid files are cleaned out
pid_one = self.join_run_dir('test-server1.pid')
self.assertFalse(os.path.exists(pid_one))
all_pids = os.listdir(t)
self.assertEquals(len(all_pids), 0)
# test only get pids for right server
pid_files = (
('thing-doer.pid', 1),
('thing-sayer.pid', 2),
('other-doer.pid', 3),
('other-sayer.pid', 4),
)
files, pids = zip(*pid_files)
with temptree(files, pids) as t:
manager.RUN_DIR = t
# all pids are running
manager.os = MockOs(pids)
server = manager.Server('thing-doer', run_dir=t)
2011-02-11 13:21:28 -06:00
running_pids = server.get_running_pids()
# only thing-doer.pid, 1
self.assertEquals(len(running_pids), 1)
self.assert_(1 in running_pids)
# no other pids returned
for n in (2, 3, 4):
self.assert_(n not in running_pids)
# assert stale pids for other servers ignored
manager.os = MockOs([1]) # only thing-doer is running
running_pids = server.get_running_pids()
for f in ('thing-sayer.pid', 'other-doer.pid', 'other-sayer.pid'):
# other server pid files persist
self.assert_(os.path.exists, os.path.join(t, f))
# verify that servers are in fact not running
for server_name in ('thing-sayer', 'other-doer', 'other-sayer'):
server = manager.Server(server_name, run_dir=t)
2011-02-11 13:21:28 -06:00
running_pids = server.get_running_pids()
self.assertFalse(running_pids)
# and now all OTHER pid files are cleaned out
all_pids = os.listdir(t)
self.assertEquals(len(all_pids), 1)
self.assert_(os.path.exists(os.path.join(t, 'thing-doer.pid')))
def test_kill_running_pids(self):
pid_files = (
('object-server.pid', 1),
('object-replicator1.pid', 11),
('object-replicator2.pid', 12),
)
files, running_pids = zip(*pid_files)
with temptree(files, running_pids) as t:
manager.RUN_DIR = t
server = manager.Server('object', run_dir=t)
2011-02-11 13:21:28 -06:00
# test no servers running
manager.os = MockOs([])
pids = server.kill_running_pids()
self.assertFalse(pids, pids)
files, running_pids = zip(*pid_files)
with temptree(files, running_pids) as t:
manager.RUN_DIR = t
server.run_dir = t
2011-02-11 13:21:28 -06:00
# start up pid
manager.os = MockOs([1])
server = manager.Server('object', run_dir=t)
2011-02-11 13:21:28 -06:00
# test kill one pid
pids = server.kill_running_pids()
self.assertEquals(len(pids), 1)
self.assert_(1 in pids)
self.assertEquals(manager.os.pid_sigs[1], [signal.SIGTERM])
# reset os mock
manager.os = MockOs([1])
# test shutdown
self.assert_('object-server' in
manager.GRACEFUL_SHUTDOWN_SERVERS)
pids = server.kill_running_pids(graceful=True)
self.assertEquals(len(pids), 1)
self.assert_(1 in pids)
self.assertEquals(manager.os.pid_sigs[1], [signal.SIGHUP])
# start up other servers
manager.os = MockOs([11, 12])
2011-02-12 14:50:24 -06:00
# test multi server kill & ignore graceful on unsupported server
2011-02-11 13:21:28 -06:00
self.assertFalse('object-replicator' in
manager.GRACEFUL_SHUTDOWN_SERVERS)
server = manager.Server('object-replicator', run_dir=t)
2011-02-11 13:21:28 -06:00
pids = server.kill_running_pids(graceful=True)
self.assertEquals(len(pids), 2)
for pid in (11, 12):
self.assert_(pid in pids)
self.assertEquals(manager.os.pid_sigs[pid],
[signal.SIGTERM])
# and the other pid is of course not signaled
self.assert_(1 not in manager.os.pid_sigs)
def test_status(self):
conf_files = (
2011-02-11 13:21:28 -06:00
'test-server/1.conf',
'test-server/2.conf',
'test-server/3.conf',
'test-server/4.conf',
)
pid_files = (
('test-server/1.pid', 1),
('test-server/2.pid', 2),
('test-server/3.pid', 3),
('test-server/4.pid', 4),
)
with temptree(conf_files) as swift_dir:
2011-02-11 13:21:28 -06:00
manager.SWIFT_DIR = swift_dir
files, pids = zip(*pid_files)
with temptree(files, pids) as t:
manager.RUN_DIR = t
# setup running servers
server = manager.Server('test', run_dir=t)
2011-02-11 13:21:28 -06:00
# capture stdio
old_stdout = sys.stdout
try:
with open(os.path.join(t, 'output'), 'w+') as f:
sys.stdout = f
# test status for all running
manager.os = MockOs(pids)
self.assertEquals(server.status(), 0)
output = pop_stream(f).strip().splitlines()
self.assertEquals(len(output), 4)
for line in output:
self.assert_('test-server running' in line)
# test get single server by number
self.assertEquals(server.status(number=4), 0)
output = pop_stream(f).strip().splitlines()
self.assertEquals(len(output), 1)
line = output[0]
self.assert_('test-server running' in line)
conf_four = self.join_swift_dir(conf_files[3])
2011-02-11 13:21:28 -06:00
self.assert_('4 - %s' % conf_four in line)
# test some servers not running
manager.os = MockOs([1, 2, 3])
self.assertEquals(server.status(), 0)
output = pop_stream(f).strip().splitlines()
self.assertEquals(len(output), 3)
for line in output:
self.assert_('test-server running' in line)
# test single server not running
manager.os = MockOs([1, 2])
self.assertEquals(server.status(number=3), 1)
output = pop_stream(f).strip().splitlines()
self.assertEquals(len(output), 1)
line = output[0]
self.assert_('not running' in line)
conf_three = self.join_swift_dir(conf_files[2])
2011-02-11 13:21:28 -06:00
self.assert_(conf_three in line)
# test no running pids
manager.os = MockOs([])
self.assertEquals(server.status(), 1)
output = pop_stream(f).lower()
self.assert_('no test-server running' in output)
# test use provided pids
pids = {
1: '1.pid',
2: '2.pid',
}
# shouldn't call get_running_pids
called = []
def mock(*args, **kwargs):
called.append(True)
server.get_running_pids = mock
status = server.status(pids=pids)
self.assertEquals(status, 0)
self.assertFalse(called)
output = pop_stream(f).strip().splitlines()
self.assertEquals(len(output), 2)
for line in output:
self.assert_('test-server running' in line)
finally:
sys.stdout = old_stdout
def test_spawn(self):
# mocks
class MockProcess():
NOTHING = 'default besides None'
STDOUT = 'stdout'
PIPE = 'pipe'
def __init__(self, pids=None):
if pids is None:
pids = []
self.pids = (p for p in pids)
def Popen(self, args, **kwargs):
return MockProc(self.pids.next(), args, **kwargs)
class MockProc():
def __init__(self, pid, args, stdout=MockProcess.NOTHING,
stderr=MockProcess.NOTHING):
self.pid = pid
self.args = args
self.stdout = stdout
if stderr == MockProcess.STDOUT:
self.stderr = self.stdout
else:
self.stderr = stderr
# setup running servers
server = manager.Server('test')
with temptree(['test-server.conf']) as swift_dir:
manager.SWIFT_DIR = swift_dir
with temptree([]) as t:
manager.RUN_DIR = t
server.run_dir = t
2011-02-11 13:21:28 -06:00
old_subprocess = manager.subprocess
try:
# test single server process calls spawn once
manager.subprocess = MockProcess([1])
conf_file = self.join_swift_dir('test-server.conf')
# spawn server no kwargs
server.spawn(conf_file)
# test pid file
pid_file = self.join_run_dir('test-server.pid')
self.assert_(os.path.exists(pid_file))
pid_on_disk = int(open(pid_file).read().strip())
self.assertEquals(pid_on_disk, 1)
# assert procs args
self.assert_(server.procs)
self.assertEquals(len(server.procs), 1)
proc = server.procs[0]
expected_args = [
'swift-test-server',
conf_file,
]
self.assertEquals(proc.args, expected_args)
2011-02-15 13:19:33 -06:00
# assert stdout is piped
self.assertEquals(proc.stdout, MockProcess.PIPE)
2011-02-11 13:21:28 -06:00
self.assertEquals(proc.stderr, proc.stdout)
# test multi server process calls spawn multiple times
manager.subprocess = MockProcess([11, 12, 13, 14])
conf1 = self.join_swift_dir('test-server/1.conf')
conf2 = self.join_swift_dir('test-server/2.conf')
conf3 = self.join_swift_dir('test-server/3.conf')
conf4 = self.join_swift_dir('test-server/4.conf')
server = manager.Server('test', run_dir=t)
2011-02-11 13:21:28 -06:00
# test server run once
server.spawn(conf1, once=True)
self.assert_(server.procs)
self.assertEquals(len(server.procs), 1)
proc = server.procs[0]
expected_args = ['swift-test-server', conf1, 'once']
2011-02-15 13:19:33 -06:00
# assert stdout is piped
self.assertEquals(proc.stdout, MockProcess.PIPE)
2011-02-11 13:21:28 -06:00
self.assertEquals(proc.stderr, proc.stdout)
# test server not daemon
server.spawn(conf2, daemon=False)
self.assert_(server.procs)
self.assertEquals(len(server.procs), 2)
proc = server.procs[1]
expected_args = ['swift-test-server', conf2, 'verbose']
self.assertEquals(proc.args, expected_args)
# assert stdout is not changed
self.assertEquals(proc.stdout, None)
self.assertEquals(proc.stderr, None)
# test server wait
2011-02-15 13:19:33 -06:00
server.spawn(conf3, wait=False)
2011-02-11 13:21:28 -06:00
self.assert_(server.procs)
self.assertEquals(len(server.procs), 3)
proc = server.procs[2]
2011-02-15 13:19:33 -06:00
# assert stdout is /dev/null
self.assert_(isinstance(proc.stdout, file))
self.assertEquals(proc.stdout.name, os.devnull)
self.assertEquals(proc.stdout.mode, 'w+b')
2011-02-11 13:21:28 -06:00
self.assertEquals(proc.stderr, proc.stdout)
# test not daemon over-rides wait
2011-02-15 13:19:33 -06:00
server.spawn(conf4, wait=False, daemon=False, once=True)
2011-02-11 13:21:28 -06:00
self.assert_(server.procs)
self.assertEquals(len(server.procs), 4)
proc = server.procs[3]
expected_args = ['swift-test-server', conf4, 'once',
'verbose']
self.assertEquals(proc.args, expected_args)
# daemon behavior should trump wait, once shouldn't matter
self.assertEquals(proc.stdout, None)
self.assertEquals(proc.stderr, None)
# assert pids
for i, proc in enumerate(server.procs):
pid_file = self.join_run_dir('test-server/%d.pid' %
(i + 1))
pid_on_disk = int(open(pid_file).read().strip())
self.assertEquals(pid_on_disk, proc.pid)
finally:
manager.subprocess = old_subprocess
def test_wait(self):
server = manager.Server('test')
self.assertEquals(server.wait(), 0)
class MockProcess(Thread):
def __init__(self, delay=0.1, fail_to_start=False):
Thread.__init__(self)
# setup pipe
rfd, wfd = os.pipe()
# subprocess connection to read stdout
self.stdout = os.fdopen(rfd)
# real process connection to write stdout
self._stdout = os.fdopen(wfd, 'w')
self.delay = delay
self.finished = False
self.returncode = None
if fail_to_start:
2011-02-14 14:52:49 -06:00
self._returncode = 1
2011-02-11 13:21:28 -06:00
self.run = self.fail
2011-02-14 14:52:49 -06:00
else:
self._returncode = 0
2011-02-11 13:21:28 -06:00
def __enter__(self):
self.start()
return self
def __exit__(self, *args):
if self.isAlive():
self.join()
def close_stdout(self):
self._stdout.flush()
with open(os.devnull, 'wb') as nullfile:
try:
os.dup2(nullfile.fileno(), self._stdout.fileno())
except OSError:
pass
def fail(self):
print >>self._stdout, 'mock process started'
sleep(self.delay) # perform setup processing
print >>self._stdout, 'mock process failed to start'
self.close_stdout()
def poll(self):
2011-02-14 14:52:49 -06:00
self.returncode = self._returncode
return self.returncode or None
2011-02-14 14:52:49 -06:00
2011-02-11 13:21:28 -06:00
def run(self):
print >>self._stdout, 'mock process started'
sleep(self.delay) # perform setup processing
print >>self._stdout, 'setup complete!'
self.close_stdout()
sleep(self.delay) # do some more processing
print >>self._stdout, 'mock process finished'
self.finished = True
class MockTime():
def time(self):
return time()
def sleep(self, *args, **kwargs):
pass
2011-02-11 13:21:28 -06:00
with temptree([]) as t:
old_stdout = sys.stdout
old_wait = manager.WARNING_WAIT
old_time = manager.time
2011-02-11 13:21:28 -06:00
try:
manager.WARNING_WAIT = 0.01
manager.time = MockTime()
2011-02-11 13:21:28 -06:00
with open(os.path.join(t, 'output'), 'w+') as f:
# acctually capture the read stdout (for prints)
sys.stdout = f
# test closing pipe in subprocess unblocks read
with MockProcess() as proc:
server.procs = [proc]
status = server.wait()
self.assertEquals(status, 0)
# wait should return before process exits
2011-02-11 13:21:28 -06:00
self.assert_(proc.isAlive())
self.assertFalse(proc.finished)
self.assert_(proc.finished) # make sure it did finish...
# test output kwarg prints subprocess output
with MockProcess() as proc:
server.procs = [proc]
status = server.wait(output=True)
output = pop_stream(f)
self.assert_('mock process started' in output)
self.assert_('setup complete' in output)
# make sure we don't get prints after stdout was closed
self.assert_('mock process finished' not in output)
# test process which fails to start
with MockProcess(fail_to_start=True) as proc:
server.procs = [proc]
status = server.wait()
self.assertEquals(status, 1)
self.assert_('failed' in pop_stream(f))
# test multiple procs
procs = [MockProcess(delay=.5) for i in range(3)]
2011-02-11 13:21:28 -06:00
for proc in procs:
proc.start()
server.procs = procs
status = server.wait()
self.assertEquals(status, 0)
for proc in procs:
self.assert_(proc.isAlive())
for proc in procs:
proc.join()
finally:
sys.stdout = old_stdout
manager.WARNING_WAIT = old_wait
manager.time = old_time
2011-02-11 13:21:28 -06:00
def test_interact(self):
class MockProcess():
def __init__(self, fail=False):
self.returncode = None
if fail:
self._returncode = 1
else:
self._returncode = 0
def communicate(self):
self.returncode = self._returncode
return '', ''
server = manager.Server('test')
server.procs = [MockProcess()]
self.assertEquals(server.interact(), 0)
server.procs = [MockProcess(fail=True)]
self.assertEquals(server.interact(), 1)
procs = []
for fail in (False, True, True):
procs.append(MockProcess(fail=fail))
server.procs = procs
self.assert_(server.interact() > 0)
2011-02-11 13:21:28 -06:00
def test_launch(self):
# stubs
conf_files = (
2011-02-11 13:21:28 -06:00
'proxy-server.conf',
2011-02-12 14:50:24 -06:00
'auth-server.conf',
2011-02-11 13:21:28 -06:00
'object-server/1.conf',
'object-server/2.conf',
'object-server/3.conf',
'object-server/4.conf',
)
pid_files = (
('proxy-server.pid', 1),
('proxy-server/2.pid', 2),
)
#mocks
class MockSpawn():
def __init__(self, pids=None):
self.conf_files = []
2011-02-11 13:21:28 -06:00
self.kwargs = []
if not pids:
def one_forever():
while True:
yield 1
self.pids = one_forever()
else:
self.pids = (x for x in pids)
def __call__(self, conf_file, **kwargs):
self.conf_files.append(conf_file)
2011-02-11 13:21:28 -06:00
self.kwargs.append(kwargs)
2011-02-12 14:50:24 -06:00
rv = self.pids.next()
if isinstance(rv, Exception):
raise rv
else:
return rv
2011-02-11 13:21:28 -06:00
with temptree(conf_files) as swift_dir:
2011-02-11 13:21:28 -06:00
manager.SWIFT_DIR = swift_dir
files, pids = zip(*pid_files)
with temptree(files, pids) as t:
manager.RUN_DIR = t
old_stdout = sys.stdout
try:
with open(os.path.join(t, 'output'), 'w+') as f:
sys.stdout = f
# can't start server w/o an conf
server = manager.Server('test', run_dir=t)
2011-02-11 13:21:28 -06:00
self.assertFalse(server.launch())
# start mock os running all pids
manager.os = MockOs(pids)
server = manager.Server('proxy', run_dir=t)
2011-02-11 13:21:28 -06:00
# can't start server if it's already running
self.assertFalse(server.launch())
output = pop_stream(f)
self.assert_('running' in output)
conf_file = self.join_swift_dir('proxy-server.conf')
self.assert_(conf_file in output)
2011-02-11 13:21:28 -06:00
pid_file = self.join_run_dir('proxy-server/2.pid')
self.assert_(pid_file in output)
self.assert_('already started' in output)
# no running pids
manager.os = MockOs([])
# test ignore once for non-start-once server
mock_spawn = MockSpawn([1])
server.spawn = mock_spawn
conf_file = self.join_swift_dir('proxy-server.conf')
2011-02-11 13:21:28 -06:00
expected = {
1: conf_file,
2011-02-11 13:21:28 -06:00
}
self.assertEquals(server.launch(once=True), expected)
self.assertEquals(mock_spawn.conf_files, [conf_file])
2011-02-11 13:21:28 -06:00
expected = {
'once': False,
}
self.assertEquals(mock_spawn.kwargs, [expected])
output = pop_stream(f)
self.assert_('Starting' in output)
self.assert_('once' not in output)
# test multi-server kwarg once
server = manager.Server('object-replicator')
mock_spawn = MockSpawn([1, 2, 3, 4])
server.spawn = mock_spawn
conf1 = self.join_swift_dir('object-server/1.conf')
conf2 = self.join_swift_dir('object-server/2.conf')
conf3 = self.join_swift_dir('object-server/3.conf')
conf4 = self.join_swift_dir('object-server/4.conf')
expected = {
1: conf1,
2: conf2,
3: conf3,
4: conf4,
}
self.assertEquals(server.launch(once=True), expected)
self.assertEquals(mock_spawn.conf_files, [
conf1, conf2, conf3, conf4])
2011-02-11 13:21:28 -06:00
expected = {
'once': True,
}
self.assertEquals(len(mock_spawn.kwargs), 4)
for kwargs in mock_spawn.kwargs:
self.assertEquals(kwargs, expected)
# test number kwarg
mock_spawn = MockSpawn([4])
server.spawn = mock_spawn
expected = {
4: conf4,
}
self.assertEquals(server.launch(number=4), expected)
self.assertEquals(mock_spawn.conf_files, [conf4])
2011-02-11 13:21:28 -06:00
expected = {
'number': 4
}
self.assertEquals(mock_spawn.kwargs, [expected])
2011-02-12 14:50:24 -06:00
# test cmd does not exist
server = manager.Server('auth')
mock_spawn = MockSpawn([OSError(errno.ENOENT, 'blah')])
server.spawn = mock_spawn
self.assertEquals(server.launch(), {})
self.assert_('swift-auth-server does not exist' in
pop_stream(f))
2011-02-11 13:21:28 -06:00
finally:
sys.stdout = old_stdout
def test_stop(self):
conf_files = (
2011-02-11 13:21:28 -06:00
'account-server/1.conf',
'account-server/2.conf',
'account-server/3.conf',
'account-server/4.conf',
)
pid_files = (
('account-reaper/1.pid', 1),
('account-reaper/2.pid', 2),
('account-reaper/3.pid', 3),
('account-reaper/4.pid', 4),
)
with temptree(conf_files) as swift_dir:
2011-02-11 13:21:28 -06:00
manager.SWIFT_DIR = swift_dir
files, pids = zip(*pid_files)
with temptree(files, pids) as t:
manager.RUN_DIR = t
# start all pids in mock os
manager.os = MockOs(pids)
server = manager.Server('account-reaper', run_dir=t)
2011-02-11 13:21:28 -06:00
# test kill all running pids
pids = server.stop()
self.assertEquals(len(pids), 4)
for pid in (1, 2, 3, 4):
self.assert_(pid in pids)
self.assertEquals(manager.os.pid_sigs[pid],
[signal.SIGTERM])
conf1 = self.join_swift_dir('account-reaper/1.conf')
conf2 = self.join_swift_dir('account-reaper/2.conf')
conf3 = self.join_swift_dir('account-reaper/3.conf')
conf4 = self.join_swift_dir('account-reaper/4.conf')
# reset mock os with only 2 running pids
manager.os = MockOs([3, 4])
pids = server.stop()
self.assertEquals(len(pids), 2)
for pid in (3, 4):
self.assert_(pid in pids)
self.assertEquals(manager.os.pid_sigs[pid],
[signal.SIGTERM])
self.assertFalse(os.path.exists(conf1))
self.assertFalse(os.path.exists(conf2))
# test number kwarg
manager.os = MockOs([3, 4])
pids = server.stop(number=3)
self.assertEquals(len(pids), 1)
expected = {
3: conf3,
}
self.assert_(pids, expected)
self.assertEquals(manager.os.pid_sigs[3], [signal.SIGTERM])
self.assertFalse(os.path.exists(conf4))
self.assertFalse(os.path.exists(conf3))
2011-02-11 13:21:28 -06:00
class TestManager(unittest.TestCase):
def test_create(self):
2011-02-11 14:56:03 -06:00
m = manager.Manager(['test'])
self.assertEquals(len(m.servers), 1)
server = m.servers.pop()
2011-02-11 13:21:28 -06:00
self.assert_(isinstance(server, manager.Server))
self.assertEquals(server.server, 'test-server')
# test multi-server and simple dedupe
servers = ['object-replicator', 'object-auditor', 'object-replicator']
2011-02-11 14:56:03 -06:00
m = manager.Manager(servers)
self.assertEquals(len(m.servers), 2)
for server in m.servers:
2011-02-11 13:21:28 -06:00
self.assert_(server.server in servers)
# test all
2011-02-11 14:56:03 -06:00
m = manager.Manager(['all'])
self.assertEquals(len(m.servers), len(manager.ALL_SERVERS))
for server in m.servers:
2011-02-11 13:21:28 -06:00
self.assert_(server.server in manager.ALL_SERVERS)
# test main
2011-02-11 14:56:03 -06:00
m = manager.Manager(['main'])
self.assertEquals(len(m.servers), len(manager.MAIN_SERVERS))
for server in m.servers:
2011-02-11 13:21:28 -06:00
self.assert_(server.server in manager.MAIN_SERVERS)
# test rest
2011-02-11 14:56:03 -06:00
m = manager.Manager(['rest'])
self.assertEquals(len(m.servers), len(manager.REST_SERVERS))
for server in m.servers:
2011-02-11 13:21:28 -06:00
self.assert_(server.server in manager.REST_SERVERS)
# test main + rest == all
2011-02-11 14:56:03 -06:00
m = manager.Manager(['main', 'rest'])
self.assertEquals(len(m.servers), len(manager.ALL_SERVERS))
for server in m.servers:
2011-02-11 13:21:28 -06:00
self.assert_(server.server in manager.ALL_SERVERS)
# test dedupe
2011-02-11 14:56:03 -06:00
m = manager.Manager(['main', 'rest', 'proxy', 'object',
'container', 'account'])
2011-02-11 14:56:03 -06:00
self.assertEquals(len(m.servers), len(manager.ALL_SERVERS))
for server in m.servers:
2011-02-11 13:21:28 -06:00
self.assert_(server.server in manager.ALL_SERVERS)
2011-02-11 14:56:03 -06:00
# test glob
m = manager.Manager(['object-*'])
object_servers = [s for s in manager.ALL_SERVERS if
s.startswith('object')]
self.assertEquals(len(m.servers), len(object_servers))
for s in m.servers:
self.assert_(str(s) in object_servers)
m = manager.Manager(['*-replicator'])
replicators = [s for s in manager.ALL_SERVERS if
s.endswith('replicator')]
for s in m.servers:
self.assert_(str(s) in replicators)
2011-02-11 13:21:28 -06:00
def test_status(self):
class MockServer():
def __init__(self, server, run_dir=manager.RUN_DIR):
2011-02-11 13:21:28 -06:00
self.server = server
self.called_kwargs = []
2011-02-11 13:21:28 -06:00
def status(self, **kwargs):
self.called_kwargs.append(kwargs)
if 'error' in self.server:
return 1
else:
return 0
old_server_class = manager.Server
try:
manager.Server = MockServer
2011-02-11 14:56:03 -06:00
m = manager.Manager(['test'])
status = m.status()
2011-02-11 13:21:28 -06:00
self.assertEquals(status, 0)
2011-02-11 14:56:03 -06:00
m = manager.Manager(['error'])
status = m.status()
2011-02-11 13:21:28 -06:00
self.assertEquals(status, 1)
# test multi-server
2011-02-11 14:56:03 -06:00
m = manager.Manager(['test', 'error'])
2011-02-11 13:21:28 -06:00
kwargs = {'key': 'value'}
2011-02-11 14:56:03 -06:00
status = m.status(**kwargs)
2011-02-11 13:21:28 -06:00
self.assertEquals(status, 1)
2011-02-11 14:56:03 -06:00
for server in m.servers:
2011-02-11 13:21:28 -06:00
self.assertEquals(server.called_kwargs, [kwargs])
finally:
manager.Server = old_server_class
def test_start(self):
def mock_setup_env():
getattr(mock_setup_env, 'called', []).append(True)
class MockServer():
def __init__(self, server, run_dir=manager.RUN_DIR):
2011-02-11 13:21:28 -06:00
self.server = server
self.called = defaultdict(list)
def launch(self, **kwargs):
self.called['launch'].append(kwargs)
def wait(self, **kwargs):
self.called['wait'].append(kwargs)
2011-02-15 13:19:33 -06:00
return int('error' in self.server)
def stop(self, **kwargs):
self.called['stop'].append(kwargs)
2011-02-11 13:21:28 -06:00
def interact(self, **kwargs):
self.called['interact'].append(kwargs)
if 'raise' in self.server:
raise KeyboardInterrupt
elif 'error' in self.server:
2011-02-11 13:21:28 -06:00
return 1
else:
return 0
old_setup_env = manager.setup_env
old_swift_server = manager.Server
try:
manager.setup_env = mock_setup_env
manager.Server = MockServer
# test no errors on launch
2011-02-15 13:19:33 -06:00
m = manager.Manager(['proxy'])
2011-02-11 14:56:03 -06:00
status = m.start()
2011-02-11 13:21:28 -06:00
self.assertEquals(status, 0)
2011-02-11 14:56:03 -06:00
for server in m.servers:
2011-02-11 13:21:28 -06:00
self.assertEquals(server.called['launch'], [{}])
2011-02-15 13:19:33 -06:00
# test error on launch
2011-02-11 14:56:03 -06:00
m = manager.Manager(['proxy', 'error'])
2011-02-15 13:19:33 -06:00
status = m.start()
2011-02-11 13:21:28 -06:00
self.assertEquals(status, 1)
2011-02-11 14:56:03 -06:00
for server in m.servers:
2011-02-15 13:19:33 -06:00
self.assertEquals(server.called['launch'], [{}])
self.assertEquals(server.called['wait'], [{}])
2011-02-11 13:21:28 -06:00
# test interact
2011-02-11 14:56:03 -06:00
m = manager.Manager(['proxy', 'error'])
2011-02-11 13:21:28 -06:00
kwargs = {'daemon': False}
2011-02-11 14:56:03 -06:00
status = m.start(**kwargs)
2011-02-11 13:21:28 -06:00
self.assertEquals(status, 1)
2011-02-11 14:56:03 -06:00
for server in m.servers:
2011-02-11 13:21:28 -06:00
self.assertEquals(server.called['launch'], [kwargs])
self.assertEquals(server.called['interact'], [kwargs])
m = manager.Manager(['raise'])
kwargs = {'daemon': False}
status = m.start(**kwargs)
2011-02-11 13:21:28 -06:00
finally:
manager.setup_env = old_setup_env
manager.Server = old_swift_server
2011-02-15 13:19:33 -06:00
def test_no_wait(self):
2011-02-11 13:21:28 -06:00
class MockServer():
def __init__(self, server, run_dir=manager.RUN_DIR):
2011-02-11 13:21:28 -06:00
self.server = server
self.called = defaultdict(list)
def launch(self, **kwargs):
self.called['launch'].append(kwargs)
def wait(self, **kwargs):
self.called['wait'].append(kwargs)
return int('error' in self.server)
orig_swift_server = manager.Server
try:
manager.Server = MockServer
# test success
init = manager.Manager(['proxy'])
2011-02-15 13:19:33 -06:00
status = init.no_wait()
2011-02-11 13:21:28 -06:00
self.assertEquals(status, 0)
for server in init.servers:
self.assertEquals(len(server.called['launch']), 1)
called_kwargs = server.called['launch'][0]
2011-02-15 13:19:33 -06:00
self.assertFalse(called_kwargs['wait'])
self.assertFalse(server.called['wait'])
# test no errocode status even on error
2011-02-11 13:21:28 -06:00
init = manager.Manager(['error'])
2011-02-15 13:19:33 -06:00
status = init.no_wait()
self.assertEquals(status, 0)
2011-02-11 13:21:28 -06:00
for server in init.servers:
self.assertEquals(len(server.called['launch']), 1)
called_kwargs = server.called['launch'][0]
self.assert_('wait' in called_kwargs)
2011-02-15 13:19:33 -06:00
self.assertFalse(called_kwargs['wait'])
self.assertFalse(server.called['wait'])
2011-02-11 13:21:28 -06:00
# test wait with once option
init = manager.Manager(['updater', 'replicator-error'])
2011-02-15 13:19:33 -06:00
status = init.no_wait(once=True)
self.assertEquals(status, 0)
2011-02-11 13:21:28 -06:00
for server in init.servers:
self.assertEquals(len(server.called['launch']), 1)
called_kwargs = server.called['launch'][0]
self.assert_('wait' in called_kwargs)
2011-02-15 13:19:33 -06:00
self.assertFalse(called_kwargs['wait'])
2011-02-11 13:21:28 -06:00
self.assert_('once' in called_kwargs)
self.assert_(called_kwargs['once'])
2011-02-15 13:19:33 -06:00
self.assertFalse(server.called['wait'])
2011-02-11 13:21:28 -06:00
finally:
manager.Server = orig_swift_server
def test_no_daemon(self):
class MockServer():
def __init__(self, server, run_dir=manager.RUN_DIR):
2011-02-11 13:21:28 -06:00
self.server = server
self.called = defaultdict(list)
def launch(self, **kwargs):
self.called['launch'].append(kwargs)
def interact(self, **kwargs):
self.called['interact'].append(kwargs)
return int('error' in self.server)
orig_swift_server = manager.Server
try:
manager.Server = MockServer
# test success
init = manager.Manager(['proxy'])
stats = init.no_daemon()
self.assertEquals(stats, 0)
# test error
init = manager.Manager(['proxy', 'object-error'])
stats = init.no_daemon()
self.assertEquals(stats, 1)
# test once
init = manager.Manager(['proxy', 'object-error'])
stats = init.no_daemon()
for server in init.servers:
self.assertEquals(len(server.called['launch']), 1)
self.assertEquals(len(server.called['wait']), 0)
self.assertEquals(len(server.called['interact']), 1)
finally:
manager.Server = orig_swift_server
def test_once(self):
class MockServer():
def __init__(self, server, run_dir=manager.RUN_DIR):
2011-02-11 13:21:28 -06:00
self.server = server
self.called = defaultdict(list)
2011-02-15 13:19:33 -06:00
def wait(self, **kwargs):
self.called['wait'].append(kwargs)
if 'error' in self.server:
return 1
else:
return 0
2011-02-11 13:21:28 -06:00
def launch(self, **kwargs):
return self.called['launch'].append(kwargs)
orig_swift_server = manager.Server
try:
manager.Server = MockServer
# test no errors
init = manager.Manager(['account-reaper'])
status = init.once()
self.assertEquals(status, 0)
2011-02-15 13:19:33 -06:00
# test error code on error
2011-02-11 13:21:28 -06:00
init = manager.Manager(['error-reaper'])
status = init.once()
2011-02-15 13:19:33 -06:00
self.assertEquals(status, 1)
2011-02-11 13:21:28 -06:00
for server in init.servers:
self.assertEquals(len(server.called['launch']), 1)
called_kwargs = server.called['launch'][0]
self.assertEquals(called_kwargs, {'once': True})
2011-02-15 13:19:33 -06:00
self.assertEquals(len(server.called['wait']), 1)
2011-02-11 13:21:28 -06:00
self.assertEquals(len(server.called['interact']), 0)
finally:
manager.Server = orig_swift_server
def test_stop(self):
class MockServerFactory():
class MockServer():
def __init__(self, pids, run_dir=manager.RUN_DIR):
self.pids = pids
def stop(self, **kwargs):
return self.pids
def __init__(self, server_pids, run_dir=manager.RUN_DIR):
self.server_pids = server_pids
def __call__(self, server, run_dir=manager.RUN_DIR):
return MockServerFactory.MockServer(self.server_pids[server])
def mock_watch_server_pids(server_pids, **kwargs):
for server, pids in server_pids.items():
for pid in pids:
if pid is None:
continue
yield server, pid
_orig_server = manager.Server
_orig_watch_server_pids = manager.watch_server_pids
try:
manager.watch_server_pids = mock_watch_server_pids
# test stop one server
server_pids = {
'test': [1]
}
manager.Server = MockServerFactory(server_pids)
m = manager.Manager(['test'])
status = m.stop()
self.assertEquals(status, 0)
# test not running
server_pids = {
'test': []
}
manager.Server = MockServerFactory(server_pids)
m = manager.Manager(['test'])
status = m.stop()
self.assertEquals(status, 1)
# test won't die
server_pids = {
'test': [None]
}
manager.Server = MockServerFactory(server_pids)
m = manager.Manager(['test'])
status = m.stop()
self.assertEquals(status, 1)
finally:
manager.Server = _orig_server
manager.watch_server_pids = _orig_watch_server_pids
2011-02-11 13:21:28 -06:00
# TODO(clayg): more tests
2011-02-11 13:21:28 -06:00
def test_shutdown(self):
2011-02-12 14:50:24 -06:00
m = manager.Manager(['test'])
m.stop_was_called = False
def mock_stop(*args, **kwargs):
m.stop_was_called = True
expected = {'graceful': True}
self.assertEquals(kwargs, expected)
return 0
m.stop = mock_stop
status = m.shutdown()
self.assertEquals(status, 0)
self.assertEquals(m.stop_was_called, True)
2011-02-11 13:21:28 -06:00
def test_restart(self):
2011-02-12 14:50:24 -06:00
m = manager.Manager(['test'])
m.stop_was_called = False
def mock_stop(*args, **kwargs):
m.stop_was_called = True
return 0
m.start_was_called = False
def mock_start(*args, **kwargs):
m.start_was_called = True
return 0
m.stop = mock_stop
m.start = mock_start
status = m.restart()
self.assertEquals(status, 0)
self.assertEquals(m.stop_was_called, True)
self.assertEquals(m.start_was_called, True)
2011-02-11 13:21:28 -06:00
def test_reload(self):
2011-02-12 14:50:24 -06:00
class MockManager():
called = defaultdict(list)
def __init__(self, servers):
pass
@classmethod
def reset_called(cls):
cls.called = defaultdict(list)
def stop(self, **kwargs):
MockManager.called['stop'].append(kwargs)
return 0
def start(self, **kwargs):
MockManager.called['start'].append(kwargs)
return 0
_orig_manager = manager.Manager
try:
m = _orig_manager(['auth'])
for server in m.servers:
self.assert_(server.server in
manager.GRACEFUL_SHUTDOWN_SERVERS)
manager.Manager = MockManager
status = m.reload()
self.assertEquals(status, 0)
expected = {
'start': [{'graceful': True}],
'stop': [{'graceful': True}],
}
self.assertEquals(MockManager.called, expected)
# test force graceful
MockManager.reset_called()
m = _orig_manager(['*-server'])
self.assertEquals(len(m.servers), 4)
2011-02-12 14:50:24 -06:00
for server in m.servers:
self.assert_(server.server in
manager.GRACEFUL_SHUTDOWN_SERVERS)
manager.Manager = MockManager
status = m.reload(graceful=False)
self.assertEquals(status, 0)
expected = {
'start': [{'graceful': True}] * 4,
'stop': [{'graceful': True}] * 4,
}
self.assertEquals(MockManager.called, expected)
finally:
manager.Manager = _orig_manager
2011-02-11 13:21:28 -06:00
def test_force_reload(self):
2011-02-12 14:50:24 -06:00
m = manager.Manager(['test'])
m.reload_was_called = False
def mock_reload(*args, **kwargs):
m.reload_was_called = True
return 0
m.reload = mock_reload
status = m.force_reload()
self.assertEquals(status, 0)
self.assertEquals(m.reload_was_called, True)
2011-02-11 13:21:28 -06:00
def test_get_command(self):
2011-02-12 14:50:24 -06:00
m = manager.Manager(['test'])
self.assertEquals(m.start, m.get_command('start'))
self.assertEquals(m.force_reload, m.get_command('force-reload'))
self.assertEquals(m.get_command('force-reload'),
m.get_command('force_reload'))
self.assertRaises(manager.UnknownCommandError, m.get_command,
'no_command')
self.assertRaises(manager.UnknownCommandError, m.get_command,
'__init__')
def test_list_commands(self):
for cmd, help in manager.Manager.list_commands():
method = getattr(manager.Manager, cmd.replace('-', '_'), None)
self.assert_(method, '%s is not a command' % cmd)
self.assert_(getattr(method, 'publicly_accessible', False))
self.assertEquals(method.__doc__.strip(), help)
def test_run_command(self):
2011-02-12 14:50:24 -06:00
m = manager.Manager(['test'])
m.cmd_was_called = False
def mock_cmd(*args, **kwargs):
m.cmd_was_called = True
expected = {'kw1': True, 'kw2': False}
self.assertEquals(kwargs, expected)
return 0
mock_cmd.publicly_accessible = True
m.mock_cmd = mock_cmd
kwargs = {'kw1': True, 'kw2': False}
status = m.run_command('mock_cmd', **kwargs)
self.assertEquals(status, 0)
self.assertEquals(m.cmd_was_called, True)
2011-02-11 13:21:28 -06:00
if __name__ == '__main__':
unittest.main()