def setUp(self):
self.servers = []
super(TestKineticECReplicator, self).setUp()
self.servers.extend(create_ac_servers(self.test_dir))
# create object server & rings
obj_socket = eventlet.listen(('127.0.0.1', 0))
obj_port = obj_socket.getsockname()[1]
create_ec_rings(self.test_dir, obj_port, *self.ports)
recon_cache_path = os.path.join(self.test_dir, 'recon_cache')
os.makedirs(recon_cache_path)
internal_client_path = os.path.join(
self.test_dir, 'internal-client.conf')
conf = {
'swift_dir': self.test_dir,
'mount_check': False,
'recon_cache_path': recon_cache_path,
'internal_client_conf_path': internal_client_path,
}
server.install_kinetic_diskfile()
self.app = server.ObjectController(
conf, logger=utils.debug_logger('object'))
self.servers.append(eventlet.spawn(
eventlet.wsgi.server, obj_socket, self.app, self.app.logger))
# setup replicator daemon
parser = ConfigParser()
parser.readfp(StringIO(ic_conf_body))
parser.set('DEFAULT', 'swift_dir', self.test_dir)
parser.set('DEFAULT', 'account_autocreate', 'true')
parser.set('DEFAULT', 'memcache_servers', '127.0.0.1:666')
with open(internal_client_path, 'w') as f:
parser.write(f)
self.daemon = replicator.KineticReplicator(conf)
# force ring reload
for policy in server.diskfile.POLICIES:
policy.object_ring = None
self.daemon.load_object_ring(policy)
self.logger = self.daemon.logger = \
utils.debug_logger('test-kinetic-replicator')
self.policy = random.choice([
p for p in storage_policy.POLICIES
if p.policy_type == storage_policy.EC_POLICY])
# give the servers a chance to start
timeout = time.time() + 30
i = 0
while time.time() < timeout:
try:
self.daemon.swift.create_container('a', 'c')
except Exception:
self.logger.debug('failed to create account attempt #%d' % i)
else:
break
i += 1
else:
self.tearDown()
self.fail('failed to create a container after %s attempts' % i)
def create_ac_servers(data_dir):
controller_map = {
'account': account_server.AccountController,
'container': container_server.ContainerController,
}
devices = ['sda', 'sdb', 'sdc']
device_dir = os.path.join(data_dir, 'devs')
os.makedirs(device_dir)
conf = {
'swift_dir': data_dir,
'devices': device_dir,
'mount_check': False,
}
servers = []
for server_type, controller_class in controller_map.items():
socket = eventlet.listen(('127.0.0.1', 0))
port = socket.getsockname()[1]
ring_path = os.path.join(data_dir, server_type + '.ring.gz')
with closing(gzip.GzipFile(ring_path, 'wb')) as f:
ring_data = create_replicated_ring_data(port, *devices)
pickle.dump(ring_data, f)
logger = utils.debug_logger(server_type)
app = controller_class(conf, logger=logger)
server = eventlet.spawn(eventlet.wsgi.server, socket, app, logger)
servers.append(server)
return servers
def setUp(self):
super(TestDiskFile, self).setUp()
self.port = self.ports[0]
self.device = 'localhost:%s' % self.port
self.client = self.client_map[self.port]
self.logger = debug_logger('test-kinetic')
self.mgr = server.DiskFileManager({}, self.logger)
self.policy = random.choice(list(server.diskfile.POLICIES))
def setUp(self):
super(TestDiskFile, self).setUp()
self.port = self.ports[0]
self.device = 'localhost:%s' % self.port
self.client = self.client_map[self.port]
self.logger = debug_logger('test-kinetic')
self.mgr = server.DiskFileManager({}, self.logger)
self.mgr.unlink_wait = True
self.policy = random.choice(list(server.diskfile.POLICIES))
def setUp(self):
super(TestKineticReplicator, self).setUp()
create_rings(self.test_dir, *self.ports)
conf = {
'swift_dir': self.test_dir,
'kinetic_replication_mode': self.REPLICATION_MODE,
}
self.daemon = replicator.KineticReplicator(conf)
self.logger = self.daemon.logger = \
utils.debug_logger('test-kinetic-replicator')
self.mgr = server.DiskFileManager({}, self.logger)
self.policy = random.choice(list(server.diskfile.POLICIES))
def setUp(self):
super(TestKineticObjectAuditor, self).setUp()
self.conf = {
'unlink_wait': 'true',
}
self.auditor = auditor.KineticAuditor(self.conf)
self.logger = debug_logger()
self.auditor.logger = self.logger
self.port = self.ports[0]
self.client = self.client_map[self.port]
self.device = 'localhost:%s' % self.port
self.policy = random.choice(list(POLICIES))
def setUp(self):
super(TestKineticReplicator, self).setUp()
create_rings(self.test_dir, *self.ports)
conf = {
'swift_dir': self.test_dir,
'kinetic_replication_mode': self.REPLICATION_MODE,
}
self.daemon = replicator.KineticReplicator(conf)
self.logger = self.daemon.logger = \
utils.debug_logger('test-kinetic-replicator')
self.mgr = server.DiskFileManager({}, self.logger)
self.policy = random.choice(list(server.diskfile.POLICIES))
def setUp(self):
super(TestDiskFile, self).setUp()
self.port = self.ports[0]
self.device = 'localhost:%s' % self.port
self.client = self.client_map[self.port]
self.logger = debug_logger('test-kinetic')
server.install_kinetic_diskfile()
self.policy = random.choice(list(server.diskfile.POLICIES))
self.router = server.diskfile.DiskFileRouter(
{}, self.logger)
self.mgr = self.router[self.policy]
self.mgr.unlink_wait = True
def setUp(self):
super(TestKineticObjectUpdater, self).setUp()
self.port = self.ports[0]
self.devices = 'localhost:%d' % self.port
self.client = self.client_map[self.port]
self.conf = {
'unlink_wait': 'true',
}
self.app = server.app_factory(self.conf)
self.policy = random.choice(list(server.diskfile.POLICIES))
self.container_ring = FakeRing()
self.logger = debug_logger()
self.updater = updater.KineticUpdater(self.conf)
self.updater.container_ring = self.container_ring
self.updater.logger = self.logger
def setUp(self):
super(TestKineticObjectUpdater, self).setUp()
self.port = self.ports[0]
self.devices = 'localhost:%d' % self.port
self.client = self.client_map[self.port]
self.conf = {
'unlink_wait': 'true',
}
self.app = server.app_factory(self.conf)
self.policy = random.choice(list(server.diskfile.POLICIES))
self.container_ring = FakeRing()
self.logger = debug_logger()
self.updater = updater.KineticUpdater(self.conf)
self.updater.container_ring = self.container_ring
self.updater.logger = self.logger
def setUp(self):
super(TestKineticReplicator, self).setUp()
create_rings(self.test_dir, *self.ports)
recon_cache_path = os.path.join(self.test_dir, 'recon_cache')
os.makedirs(recon_cache_path)
conf = {
'swift_dir': self.test_dir,
'kinetic_replication_mode': self.REPLICATION_MODE,
'recon_cache_path': recon_cache_path,
'disk_chunk_size': 100,
}
self.daemon = replicator.KineticReplicator(conf)
# force ring reload
for policy in server.diskfile.POLICIES:
policy.object_ring = None
self.daemon.load_object_ring(policy)
self.logger = self.daemon.logger = \
utils.debug_logger('test-kinetic-replicator')
self._df_router = server.diskfile.DiskFileRouter(
{'unlink_wait': True}, self.logger)
self.policy = random.choice(list(server.diskfile.POLICIES))
self.mgr = self._df_router[self.policy]
