def generateFromServerConfig(self): """ Generate the client config file from the servers """ clusterId = self._clusterId fn = '/'.join([X.cfgDir, 'arakoonclusters']) p = X.getConfig(fn) clusterExists = p.has_section(clusterId) if not clusterExists: X.raiseError("No server cluster '%s' is defined." % clusterId) serverConfigDir = p.get(clusterId, "path") serverConfigPath = '/'.join([serverConfigDir, clusterId]) serverConfig = X.getConfig(serverConfigPath) if serverConfig.has_section("global"): nodes = self.__getNodes(serverConfig) for name in nodes: if name in self.getNodes(): self.removeNode(name) ips = serverConfig.get(name, 'ip') ip_list = map(lambda x: x.strip(), ips.split(',')) self.addNode(name, ip_list, serverConfig.get(name, "client_port"))
def inspect_cluster(cluster): # cleanup inspect dumps cluster_id = cluster._getClusterId() node_names = cluster.listLocalNodes() for node_name in node_names: dn = '%s/%s/' % ( cluster_id, node_name, ) logging.info("deleting %s", dn) X.removeDirTree(dn) cfg_fn = cluster._getConfigFileName() r = call_arakoon("--inspect-cluster", "-config", "%s.cfg" % cfg_fn) dump_paths = [] for node_name in node_names: dump_path = './%s/%s/store.db.dump' % (cluster_id, node_name) dump_paths.append(dump_path) size = len(node_names) for i in xrange(size - 1): for j in xrange(i + 1, size): fn0 = dump_paths[i] fn1 = dump_paths[j] compare_files(fn0, fn1) logging.info("%s == %s", fn0, fn1) logging.info("inspect_cluster(%s): ok", cluster_id)
def testAddLocalNode(self): cid = self._clusterId cluster = self._getCluster() for i in range(0, 3): cluster.addNode("%s_%s" % (cid, i)) n0 = '%s_0' % cid n1 = '%s_1' % cid cluster.addLocalNode(n1) sn = self.__servernodes() cfgPath = '/'.join( [X.cfgDir, "qconfig", "arakoon", cid, "%s_local_nodes" % cid]) config = X.getConfig(cfgPath) assert_equals(Compat.sectionAsDict(config, "global"), {'cluster': n1}) cluster.addLocalNode(n0) config = X.getConfig(cfgPath) assert_equals(Compat.sectionAsDict(config, "global"), {'cluster': '%s,%s' % (n1, n0)})
def testNameDiffersFromId(self): name = self._clusterId id_inside = "id_inside" cluster = C._getCluster(name) cfg_name = cluster._getConfigFileName() logging.debug("cfg_name = %s", cfg_name) #/opt/qbase3/cfg//qconfig/arakoon/cluster_name ok = cfg_name.endswith(name) assert_true(ok) cluster.addNode('node_0') cfg = X.getConfig(cfg_name) logging.debug("cfg = %s", X.cfg2str(cfg)) id0 = cfg.get('global', 'cluster_id') assert_equals(id0, name) # now set it to id cfg.set('global', 'cluster_id', id_inside) X.writeConfig(cfg, cfg_name) logging.debug('cfg_after = %s', X.cfg2str(cfg)) cluster = C._getCluster(name) #ccfg = cluster.getClientConfig() #print ccfg client = cluster.getClient() ccfg2 = client._config logging.debug("ccfg2=%s", ccfg2) ccfg_id = ccfg2.getClusterId() assert_equals(ccfg_id, id_inside)
def test_sabotage(): pass """ scenario countering a sysadmin removing files (s)he shouldn't (eta : 16s) """ clu = Common._getCluster() tlog_size = 1000 num_tlogs = 2 test_size = num_tlogs * tlog_size Common.iterate_n_times(test_size, Common.simple_set) time.sleep(10) clu.stop() node_id = Common.node_names[0] node_cfg = clu.getNodeConfig(node_id) node_home_dir = node_cfg ['home'] node_tlf_dir = node_cfg ['tlf_dir'] logging.debug("node_tlf_dir=%s", node_tlf_dir) files = map(lambda x : "%s/%s" % (node_home_dir, x), [ "002.tlog", "%s.db" % (node_id,), #"%s.db.wal" % (node_id,), # should not exist after a `proper` close ]) for f in files: print f X.removeFile(f) cmd = clu._cmd('sturdy_0') returncode = X.subprocess.call(cmd) assert_equals(returncode, 50)
def shift_logs ( ) : log_to_remove = old_log_fmt % (max_logs_to_keep - 1) if X.fileExists ( log_to_remove ) : fs.unlink(log_to_remove) for i in range( 1, max_logs_to_keep - 1) : j = max_logs_to_keep - 1 - i log_to_move = old_log_fmt % j new_log_name = old_log_fmt % (j + 1) if X.fileExists( log_to_move ) : os.rename ( log_to_move, new_log_name )
def testRemoveDirs(self): cid = self._clusterId n0 = '%s_%i' % (cid, 0) cluster = self._getCluster() cluster.addNode(n0) cluster.createDirs(n0) cluster.removeDirs(n0) p0 = '/'.join([X.logDir, cid, n0]) p1 = '/'.join([X.varDir, "db", cid, n0]) assert_false(X.fileExists(p0)) assert_false(X.fileExists(p1))
def setUp(self): logging.debug("setUp") for node in self._nodes: home = '%s/%s' % (self._root, node) X.removeDirTree(home) X.createDir(home) self._server.start() cfg = self._config() cfg_s = X.cfg2str(cfg) logging.debug("cfg_s='%s'", cfg_s) self._etcdClient.set(self._cluster_id, cfg_s)
def regenerateClientConfig( cluster_id ): h = '/'.join([X.cfgDir,'arakoonclients']) p = X.getConfig(h) if cluster_id in p.sections(): clusterDir = p.get(cluster_id, "path") clientCfgFile = '/'.join([clusterDir, "%s_client.cfg" % cluster_id]) if X.fileExists(clientCfgFile): X.removeFile(clientCfgFile) client = ArakoonClient.ArakoonClient() cliCfg = client.getClientConfig( cluster_id ) cliCfg.generateFromServerConfig()
def test_issue125(): n = 31234 Common.iterate_n_times(n, Common.simple_set) slave = Common.CONFIG.node_names[1] Common.collapse(slave, 10) Common.stopOne(slave) Common.iterate_n_times(n, Common.simple_set) # others move forward dir_names = Common.build_node_dir_names(slave) db_dir = dir_names[0] log_dir = dir_names[1] tlx_dir = dir_names[2] X.removeFile('%s/035.tlog' % db_dir) X.removeFile('%s/034.tlx' % tlx_dir) X.removeFile('%s/%s.log' % (log_dir, slave)) X.removeFile('%s/%s.db' % (db_dir, slave)) # we have a cluster with head.db, no db and no tlog file. # can we launch ? Common.startOne(slave, ['-autofix']) time.sleep(20) Common.assert_running_nodes(3)
def _check_tlog_dirs(node, n): (home_dir, _, tlf_dir, head_dir) = Common.build_node_dir_names(node) tlogs = X.listFilesInDir(home_dir, filter="*.tlog") tlxs = X.listFilesInDir(tlf_dir, filter="*.tlx") logging.info("tlogs:%s", tlogs) logging.info("tlxs:%s", tlxs) print tlxs assert_equals(len(tlogs) + len(tlxs), n, msg="(%s + %s) should have %i file(s)" % (tlogs, tlxs, n)) assert_true(X.fileExists(head_dir + "/head.db")) logging.info("tlog_dirs are as expected")
def setup(c_id, tlog_max_entries): node_0 = "%s_0" % c_id c_nodes = [node_0] c_home = "/".join([Common.data_base_dir, c_id]) node_dir = "/".join([Common.data_base_dir, node_0]) X.removeDirTree(node_dir) c = Common.setup_n_nodes_base( c_id, c_nodes, False, c_home, Common.node_msg_base_port, Common.node_client_base_port, extra={'tlog_max_entries': str(tlog_max_entries)}) return c
def test_copy_db_to_head2(): logging.info("test_copy_db_to_head") zero = C.node_names[0] one = C.node_names[1] n = 29876 C.iterate_n_times(n, C.simple_set) logging.info("did %i sets, now copying db to head" % n) C.copyDbToHead(one,1) head_name = '%s/%s/head/head.db' %(C.data_base_dir, one) logging.info(head_name) assert_true(X.fileExists(head_name)) C.stopOne(zero) C.wipe(zero) C.startOne(zero) cli = C.get_client() logging.info("cli class:%s", cli.__class__) assert_false(cli.expectProgressPossible()) up2date = False counter = 0 while not up2date and counter < 100: time.sleep(1.0) counter = counter + 1 up2date = cli.expectProgressPossible() logging.info("catchup from 'collapsed' node finished")
def destroy_ram_fs( node_index ) : (mount_target,log_dir,tlf_dir,head_dir) = build_node_dir_names( node_names[node_index] ) if os.path.isdir(mount_target) and os.path.ismount(mount_target): cmd = ["sudo", "/bin/umount", mount_target] (rc,out,err) = X.run(cmd) if rc: raise Exception("cmd:%s failed (%s,%s,%s)" % (str(cmd), rc,out,err))
def _assert_n_running(self, n): cluster = self._getCluster() status = cluster.getStatus() logging.debug('status=%s', status) c = 0 for key in status.keys(): if status[key] == X.AppStatusType.RUNNING: c = c + 1 if c != n: for node in status.keys(): if status[node] == X.AppStatusType.HALTED: cfg = cluster._getConfigFile() logDir = cfg.get(node, "log_dir") fn = "%s/%s.log" % (logDir, node) logging.info("fn=%s", fn) def cat_log(fn): with open(fn, 'r') as f: lines = f.readlines() logging.info("fn:%s for %s", fn, node) for l in lines: ls = l.strip() logging.info(ls) #crash log ? cat_log(fn) filter = '%s.debug.*' % node crash = X.listFilesInDir(logDir, filter=filter) if len(crash): crash_fn = crash[0] cat_log(crash_fn) msg = "expected %i running nodes, but got %i" % (n, c) assert_equals(c, n, msg=msg)
def test_delete_non_existing_with_catchup (): pass """ catchup after deleting a non existing value (eta: 6s) """ Common.stopOne( Common.node_names[1] ) key='key' value='value' cli = Common.get_client() try: cli.delete( key ) except: pass cli.set(key,value) cli.set(key,value) cli.set(key,value) slave = Common.node_names[1] Common.startOne( slave ) time.sleep(2.0) cluster = Common._getCluster() log_dir = cluster.getNodeConfig(slave ) ['log_dir'] log_file = "%s/%s.log" % (log_dir, slave) log = X.getFileContents( log_file ) assert_equals( log.find( "don't fit" ), -1, "Store counter out of sync" )
def test_local_collapse(): logging.info("starting test_local_collapse") zero = Common.node_names[0] one = Common.node_names[1] n = 29876 Common.iterate_n_times(n, Common.simple_set) logging.info("did %i sets, now going into collapse scenario" % n) rc = Common.local_collapse(zero, 1) assert_equal(rc, 0) head_name = '%s/%s/head/head.db' % (Common.data_base_dir, zero) logging.info(head_name) assert_true(X.fileExists(head_name)) # logging.info("collapsing done") Common.stopOne(one) Common.wipe(one) Common.startOne(one) cli = Common.get_client() logging.info("cli class:%s", cli.__class__) assert_false(cli.expectProgressPossible()) up2date = False counter = 0 while not up2date and counter < 100: time.sleep(1.0) counter = counter + 1 up2date = cli.expectProgressPossible() logging.info("catchup from collapsed node finished")
def test_learner(): op_count = 54321 Common.iterate_n_times(op_count, Common.simple_set) cluster = Common._getCluster(Common.cluster_id) logging.info("adding learner") name = Common.node_names[2] (db_dir, log_dir, tlf_dir, head_dir) = Common.build_node_dir_names(name) cluster.addNode(name, Common.node_ips[2], clientPort=Common.node_client_base_port + 2, messagingPort=Common.node_msg_base_port + 2, logDir=log_dir, tlfDir=tlf_dir, headDir=head_dir, logLevel='debug', home=db_dir, isLearner=True, targets=[Common.node_names[0]]) cfg = cluster._getConfigFile() logging.info("cfg=%s", X.cfg2str(cfg)) cluster.disableFsync([name]) cluster.addLocalNode(name) cluster.createDirs(name) cluster.startOne(name) time.sleep(1.0) Common.assert_running_nodes(3) time.sleep(op_count / 1000 + 1) # 1000/s in catchup should be no problem #use a client ??" Common.stop_all() i2 = int(Common.get_last_i_tlog(name)) assert_true(i2 >= op_count - 1)
def test_max_value_size_tinkering(): cluster = C._getCluster() C.assert_running_nodes(1) key = "key_not_so_big_v" value = "xxxxxxxxxx" * 2000 client = C.get_client() client.set(key, value) cluster.stop() logging.debug("set succeeded") cfg = cluster._getConfigFile() cfg.set("global", "__tainted_max_value_size", "1024") X.writeConfig(cfg, cluster._getConfigFileName()) cluster.start() time.sleep(1.0) C.assert_running_nodes(1) client = C.get_client() assert_raises(X.arakoon_client.ArakoonException, client.set, key, value)
def getClientConfig(self, clusterName, configName=None): """ Adds an Arakoon client to the configuration. @type clusterName: string @param clusterName: the name of the cluster for which you want to add a client @type configName: optional string @param configName: the name of the client configuration for this cluster """ fn = '/'.join([X.cfgDir, 'arakoonclients']) p = X.getConfig(fn) if not p.has_section(clusterName): p.add_section(clusterName) cfgDir = '/'.join([X.cfgDir, "qconfig", "arakoon", clusterName]) p.set(clusterName, "path", cfgDir) X.writeConfig(p, fn) cfgFile = self._getConfig(clusterName, configName) return ArakoonClientExtConfig(clusterName, cfgFile)
def getClientConfig (self, clusterName, configName = None): """ Adds an Arakoon client to the configuration. @type clusterName: string @param clusterName: the name of the cluster for which you want to add a client @type configName: optional string @param configName: the name of the client configuration for this cluster """ fn = '/'.join([X.cfgDir, 'arakoonclients']) p = X.getConfig(fn) if not p.has_section(clusterName): p.add_section(clusterName) cfgDir = '/'.join([X.cfgDir, "qconfig", "arakoon", clusterName]) p.set(clusterName, "path", cfgDir) X.writeConfig(p, fn) cfgFile = self._getConfig(clusterName, configName) return ArakoonClientExtConfig(clusterName, cfgFile)
def test_sabotage(): pass """ scenario countering a sysadmin removing files (s)he shouldn't (eta : 16s) """ clu = Common._getCluster() tlog_size = 1000 num_tlogs = 2 test_size = num_tlogs * tlog_size Common.iterate_n_times(test_size, Common.simple_set) time.sleep(10) print "stopping" clu.stop() node_id = Common.node_names[0] node_cfg = clu.getNodeConfig(node_id) node_home_dir = node_cfg ['home'] node_tlf_dir = node_cfg ['tlf_dir'] logging.debug("node_tlf_dir=%s", node_tlf_dir) files = map(lambda x : "%s/%s" % (node_home_dir, x), [ "002.tlog", "%s.db" % (node_id,), #"%s.db.wal" % (node_id,), # should not exist after a `proper` close ]) for f in files: print "removing", f X.removeFile(f) print "starting" cmd = clu._cmd('sturdy_0') print cmd def start_node(): returncode = X.subprocess.call(cmd) assert_equals(returncode, 50) print "startup failure + correct returncode" try: t = threading.Thread(target = start_node) t.start() t.join(10.0) except Exception,e: print e assert_true(False)
def test_mixed_tlog_formats(): cluster = C._getCluster() cluster.disableFsync(C.node_names[:2]) s0 = 10500 logging.info("going to do %i sets",s0) C.iterate_n_times(s0,C.simple_set) C.stop_all() cluster.enableTlogCompression(compressor = 'bz2') C.start_all() logging.info("another %i sets", s0) C.iterate_n_times(s0,C.simple_set) C.stop_all() # do we have both .tlf and .tlx files? n0 = C.node_names[0] n1 = C.node_names[1] config = C.getConfig(n0) tlx_dir = config.get('tlf_dir') if not tlx_dir: tlx_dir = config.get('home') files = os.listdir(tlx_dir) tls = filter(lambda x:x.endswith(".tlx"), files) tlf = filter(lambda x:x.endswith(".tlf"), files) assert_true(len(tls) > 5, "we should have .tlx files" ) assert_true(len(tlf) > 5, "we should have .tlf files" ) # does catchup still work? C.wipe(n0) C.startOne(n1) #wait for n1 to respond to client requests... time.sleep(5) rc = cluster.catchupOnly(n0) logging.info("catchup had rc=%i", rc) C.flush_store(n1) C.stop_all() C.compare_stores(n0,n1) C.start_all() rc = C.collapse(name=n1,n = 2) logging.info("collapse had rc=%i", rc) assert_true(rc == 0, "this should not have failed") head_dir = C.build_node_dir_names(n1)[3] db_file = head_dir + "/head.db" time.sleep(1.0) # give it time to move assert_true(X.fileExists(db_file), "%s should exist" % db_file)
def start(self): logging.debug("ETCD:start on %s", self._home) X.removeDirTree(self._home) X.createDir(self._home) address = "http://%s:%i" % (self._host, self._port) real_cmd = [ 'nohup', 'etcd', '-advertise-client-urls=%s' % address, '-listen-client-urls=%s' % address, '-data-dir', self._home, '>> %s/stdout' % self._home, '2>&1 &' ] real_cmd_s = ' '.join(real_cmd) fn = '%s/start.sh' % self._home with open(fn, 'w') as f: print >> f, real_cmd_s os.chmod(fn, 0755) os.system(fn) time.sleep(5)
def _getConfig(clusterName, configName): fn = '/'.join([X.cfgDir, 'arakoonclients']) p = X.getConfig(fn) clusterDir = p.get(clusterName, "path") last = None if configName is None: last = "%s_client" % clusterName else: last = "%s_client_%s" % (clusterName, configName) return '/'.join([clusterDir, last])
def setup_3_nodes_ram_fs(home_dir): cluster = Common._getCluster(Common.cluster_id) cluster.remove() cluster = Common._getCluster(Common.cluster_id) logging.info("Creating data base dir %s" % home_dir) X.createDir(home_dir) try: for i in range(len(Common.node_names)): mount_ram_fs(i) nodeName = Common.node_names[i] (db_dir, log_dir, tlf_dir, head_dir) = Common.build_node_dir_names(Common.node_names[i]) cluster.addNode(nodeName, Common.node_ips[i], clientPort=Common.node_client_base_port + i, messagingPort=Common.node_msg_base_port + i, logDir=log_dir, tlfDir=tlf_dir, home=db_dir, headDir=head_dir) cluster.addLocalNode(nodeName) cluster.createDirs(nodeName) except Exception as ex: teardown_ram_fs(True) (a, b, c) = sys.exc_info() raise a, b, c logging.info("Changing log level to debug for all nodes") cluster.setLogLevel("debug") cluster.setMasterLease(int(CONFIG.lease_duration)) logging.info("Creating client config") Common.regenerateClientConfig(Common.cluster_id) Common.start_all()
def _getClientConfig(clusterName, configName=None): """ Gets an Arakoon client object for an existing cluster @type clusterName: string @param clusterName: the name of the cluster for which you want to get a client @return arakoon client object """ clientConfig = X.getConfig('/'.join([X.cfgDir, "arakoonclients"])) if not clientConfig.has_section(clusterName): X.raiseError("No such client configured for cluster [%s]" % clusterName) else: node_dict = {} clientCfg = ArakoonClient._getConfig(clusterName, configName) cfgFile = X.getConfig(clientCfg) if not cfgFile.has_section("global"): if configName is not None: msg = "Named client '%s' for cluster '%s' does not exist" % ( configName, clusterName) else: msg = "No client available for cluster '%s'" % clusterName X.raiseError(msg) clusterParam = cfgFile.get("global", "cluster") for node in clusterParam.split(","): node = node.strip() ips = cfgFile.get(node, "ip") ip_list = map(lambda x: x.strip(), ips.split(',')) port = cfgFile.get(node, "client_port") ip_port = (ip_list, port) node_dict.update({node: ip_port}) clusterId = cfgFile.get('global', 'cluster_id') config = X.arakoon_client.ArakoonClientConfig(clusterId, node_dict) return config
def _getClientConfig(clusterName, configName = None): """ Gets an Arakoon client object for an existing cluster @type clusterName: string @param clusterName: the name of the cluster for which you want to get a client @return arakoon client object """ clientConfig = X.getConfig('/'.join ([X.cfgDir,"arakoonclients"])) if not clientConfig.has_section(clusterName): X.raiseError("No such client configured for cluster [%s]" % clusterName) else: node_dict = {} clientCfg = ArakoonClient._getConfig(clusterName, configName) cfgFile = X.getConfig( clientCfg ) if not cfgFile.has_section("global") : if configName is not None: msg = "Named client '%s' for cluster '%s' does not exist" % (configName, clusterName) else : msg = "No client available for cluster '%s'" % clusterName X.raiseError(msg ) clusterParam = cfgFile.get("global", "cluster") for node in clusterParam.split(",") : node = node.strip() ips = cfgFile.get(node, "ip") ip_list = map(lambda x: x.strip(), ips.split(',')) port = cfgFile.get(node, "client_port") ip_port = (ip_list, port) node_dict.update({node: ip_port}) clusterId = cfgFile.get('global', 'cluster_id') config = X.arakoon_client.ArakoonClientConfig(clusterId, node_dict) return config
def test_copy_db_to_head(): # fill cluster until they have at least 10 tlogs C.iterate_n_times(5000, C.set_get_and_delete) slave = C.node_names[1] # n < 1 fails assert_raises( Exception, lambda: C.copyDbToHead(slave, 0)) # fails on master assert_raises( Exception, lambda: C.copyDbToHead(C.node_names[0], 2)) C.copyDbToHead(slave, 1) C.stop_all() (home_dir, _, tlf_dir, head_dir) = C.build_node_dir_names(slave) tlogs_count = len(X.listFilesInDir( home_dir, filter="*.tlog" )) tlf_count = len(X.listFilesInDir( tlf_dir, filter="*.tlf" )) assert(tlogs_count + tlf_count < 5) assert(X.fileExists(head_dir + "/head.db")) a = C.get_i(slave, True) logging.info("slave_head_i='%s'", a) assert(a >= 5000)
def test_start_stop_wrapper(): cluster = C._getCluster() fn = "%s/my_wrapper.sh" % X.tmpDir X.createDir(X.tmpDir) try: with open(fn, 'w') as f: f.write('#!/bin/bash -xue\n') f.write("logger wrapper called with '$@'\n") f.write('$@\n') subprocess.call(['chmod', '+x', fn]) nn = "wrapper" cluster.addNode(nn, "127.0.0.1", 8000, wrapper=fn) cluster.addLocalNode(nn) cluster.createDirs(nn) C.assert_running_nodes(0) cluster.start() time.sleep(1) C.assert_running_nodes(1) cluster.stop() C.assert_running_nodes(0) finally: cluster.remove()
def addNode(self, name, ip, clientPort): """ Add a node to the client configuration @param name: the name of the node @param ip: the ip the node @param clientPort: the port of the node """ self.__validateName(name) if isinstance(ip, basestring): ip = [ip] clusterId = self._clusterId inifile_path = self._configPath config = X.getConfig(inifile_path) if not config.has_section("global"): config.add_section("global") config.set("global", "cluster_id", clusterId) config.set("global", "cluster", "") nodes = self.__getNodes(config) if name in nodes: raise Exception("There is already a node with name %s configured" % name) nodes.append(name) config.add_section(name) config.set(name, "ip", ', '.join(ip)) config.set(name, "client_port", clientPort) config.set("global", "cluster", ",".join(nodes)) X.writeConfig(config, inifile_path)
def addNode(self, name, ip, clientPort): """ Add a node to the client configuration @param name: the name of the node @param ip: the ip the node @param clientPort: the port of the node """ self.__validateName(name) if isinstance(ip, basestring): ip = [ip] clusterId = self._clusterId inifile_path = self._configPath config = X.getConfig(inifile_path) if not config.has_section("global"): config.add_section("global") config.set("global", "cluster_id", clusterId) config.set("global","cluster", "") nodes = self.__getNodes(config) if name in nodes: raise Exception("There is already a node with name %s configured" % name) nodes.append(name) config.add_section(name) config.set(name, "ip", ', '.join(ip)) config.set(name, "client_port", clientPort) config.set("global","cluster", ",".join(nodes)) X.writeConfig(config,inifile_path)
def decorate(*args,**kwargs): global data_base_dir data_base_dir = '/'.join([X.tmpDir,'arakoon_system_tests' , func.func_name]) global test_failed test_failed = False fatal_ex = None home_dir = data_base_dir if X.fileExists( data_base_dir): remove_dirs () self.__setup( home_dir ) try: func(*args,**kwargs) except Exception, outer : tb = traceback.format_exc() logging.fatal( tb ) fatal_ex = outer
def getNodes(self): """ Get an object that contains all node information @return dict the dict can be used as param for the ArakoonConfig object """ config = X.getConfig(self._configPath) clientconfig = {} if config.has_section("global"): nodes = self.__getNodes(config) for name in nodes: ips = config.get(name, 'ip') ip_list = map(lambda x: x.strip(), ips.split(',')) clientconfig[name] = (ip_list, config.get(name, "client_port")) return clientconfig
def listClients(self): """ Returns a list with the existing clients. """ config = X.getConfig("arakoonclients") return config.sections()