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 __init__(self, conf):
install_kinetic_diskfile()
super(KineticReplicator, self).__init__(conf)
self.replication_mode = conf.get('kinetic_replication_mode', 'push')
self.connect_timeout = int(conf.get('connect_timeout', 3))
self.response_timeout = int(conf.get('response_timeout', 30))
# device => [last_used, conn]
self._conn_pool = {}
self.max_connections = int(conf.get('max_connections', 10))
self.swift = get_internal_client(conf, 'Kinetic Object Rebuilder',
self.logger)
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
