def task2(ident): global running for i in range(numtrips): if ident == 0: # give it a good chance to enter the next # barrier before the others are all out # of the current one delay = 0.001 else: rmutex.acquire() delay = random.random() * numtasks * 0.02 rmutex.release() if verbose: print 'task', ident, 'will run for', round(delay, 2), 'sec' time.sleep(delay) if verbose: print 'task', ident, 'entering barrier', i bar.enter() if verbose: print 'task', ident, 'leaving barrier', i mutex.acquire() running -= 1 # Must release mutex before releasing done, else the main thread can # exit and set mutex to None as part of global teardown; then # mutex.release() raises AttributeError. finished = running == 0 mutex.release() if finished: done.release()
def time_based_blind(test_char, current_character, comparator, sleep_int, start_response, truth): # Snage the query string and parse it into a dict sleep_time = sleep_int * truth time.sleep(sleep_time) start_response('200 OK', [('Content-Type', 'text/plain')]) return ['Hello!\r\n']
def run(self): delay = random.random() * 0.1 if verbose: print 'task', self.getName(), 'will run for', delay, 'sec' self.sema.acquire() self.mutex.acquire() self.nrunning.inc() if verbose: print self.nrunning.get(), 'tasks are running' self.testcase.assert_(self.nrunning.get() <= 3) self.mutex.release() time.sleep(delay) if verbose: print 'task', self.getName(), 'done' self.mutex.acquire() self.nrunning.dec() self.testcase.assert_(self.nrunning.get() >= 0) if verbose: print self.getName(), 'is finished.', self.nrunning.get(), \ 'tasks are running' self.mutex.release() self.sema.release()
def testLruAgeExpiry(self): def callback(input): return input * 2 test_lru = lru.LruDict(callback, maximum_age=0.1) test_lru[100] self.assert_(100 in test_lru) time.sleep(0.2) self.assert_(100 not in test_lru)
def testLruAgeExpiry(self): def callback(input): return input*2 test_lru = lru.LruDict(callback, maximum_age=0.1) test_lru[100] self.assert_(100 in test_lru) time.sleep(0.2) self.assert_(100 not in test_lru)
def wait_running(nc): """Wait for running eventlet greenthreads. Eventlet sometimes has running greenthreads after waitall() returns. This requires a greened time module (so as not to block the I/O loop). """ while nc.num_requests_running: nc.wait_all() time.sleep(0.5)
def test_shell2(self): cmd = logshipper.input.Command("echo \"'\\\"\"") cmd.set_handler(self.handler) cmd.start() time.sleep(0.01) cmd.stop() self.assertEqual(self.messages[0]['message'], "'\"")
def test_oneshot(self): cmd = logshipper.input.Command("echo 123") cmd.set_handler(self.handler) cmd.start() time.sleep(0.1) cmd.stop() self.assertEqual(len(self.messages), 1)
def test_unicode2(self): cmd = logshipper.input.Command(u"echo \u2713") # unicode checkmark cmd.set_handler(self.handler) cmd.start() time.sleep(0.1) cmd.stop() self.assertEqual(self.messages[0]['message'], u"\u2713")
def run_interaction(run_client): s, port = init_server() start_new_thread(handle_request, (s, run_client)) if run_client: start_new_thread(make_request, (port, )) sleep(0.1 + SOCKET_TIMEOUT) #print sys.getrefcount(s.fd) #s.close() return weakref.ref(s.fd)
def test_repeat(self): cmd = logshipper.input.Command("echo 123", interval=.1) cmd.set_handler(self.handler) cmd.start() time.sleep(0.3) cmd.stop() self.assertGreater(len(self.messages), 1)
def run_interaction(run_client): s, port = init_server() start_new_thread(handle_request, (s, run_client)) if run_client: start_new_thread(make_request, (port,)) sleep(0.1+SOCKET_TIMEOUT) #print sys.getrefcount(s.fd) #s.close() return weakref.ref(s.fd)
def run(self): while self.should_run: start_time = time.time() if isinstance(self.commandline, six.string_types): self.process = subprocess.Popen(self.commandline, close_fds=True, env=self.env, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) else: self.process = subprocess.Popen(self.commandline, close_fds=True, env=self.env, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) self.process.stdin.close() if self.separator == '\n': def process_pipe(pipe): while not pipe.closed: line = pipe.readline() if not line: break line = line.decode('utf8') self.emit({"message": line.rstrip('\n')}) else: def process_pipe(pipe): buf = u"" for chunk in codecs.iterdecode(pipe, 'utf8'): buf += chunk messages = buf.split(self.separator) buf = messages[-1] messages = messages[:-1] for message in messages: self.emit({"message": message}) if buf: self.emit({"message": buf}) stdout_thread = eventlet.spawn(process_pipe, self.process.stdout) stderr_thread = eventlet.spawn(process_pipe, self.process.stderr) self.process.wait() self.process = None stdout_thread.wait() stderr_thread.wait() took = time.time() - start_time time.sleep(self.interval - took)
def test_kill(self): cmd = logshipper.input.Command("sleep .2; echo 123") cmd.set_handler(self.handler) cmd.start() time.sleep(0.01) cmd.stop() time.sleep(0.3) self.assertEqual(len(self.messages), 0)
def test_unicode1(self): test_string = u"\u2713" # unicode checkmark cmd = logshipper.input.Command(["echo", test_string]) cmd.set_handler(self.handler) cmd.start() time.sleep(0.1) cmd.stop() self.assertEqual(self.messages[0]['message'], test_string)
def time_based_line(test_char, current_character, comparator, sleep_int, start_response): try: truth = (cmp(test_char, ord(current_character)) == comparator) sleep_time = float(sleep_int) * truth time.sleep(sleep_time) start_response('200 OK', ['Content-Type', 'text/plain']) return ['Hello!\r\n'] except: start_response('400 Bad Request', [('Content-Type', 'text/plain')]) return ['error\r\n']
def __try_execute(cls, *command, **kwargs): tries = 0 while True: try: utils.execute(*command, **kwargs) return True except exception.ProcessExecutionError: tries += 1 if tries >= 3: raise time.sleep(tries ** 2)
def run(self): self.id = thread.get_ident() self.finished = False try: while True: worker_started.set() time.sleep(0.1) except AsyncExc: self.finished = True worker_saw_exception.set()
def time_based_blind(test_char, current_character, comparator, sleep_int, start_response): try: truth = (cmp(test_char,ord(current_character)) == comparator) # Snage the query string and parse it into a dict sleep_time = float(sleep_int) * truth time.sleep(sleep_time) start_response('200 OK', [('Content-Type', 'text/plain')]) return ['Hello!\r\n'] except: start_response('400 Bad Request', [('Content-Type', 'text/plain')]) return ['error\r\n']
def spam_to_me(address): sock = eventlet.connect(address) while True: try: sock.sendall(b'hello world') # Arbitrary delay to not use all available CPU, keeps the test # running quickly and reliably under a second time.sleep(0.001) except socket.error as e: if get_errno(e) == errno.EPIPE: return raise
def test_alt_separator(self): cmd = logshipper.input.Command(commandline="echo test__test2_boo", separator="__") cmd.set_handler(self.handler) cmd.start() time.sleep(0.1) cmd.stop() time.sleep(0.1) self.assertEqual(self.messages[0]['message'], "test") self.assertEqual(self.messages[1]['message'], "test2_boo\n")
def reader(): try: while True: data = client.recv(1024) assert data # Arbitrary delay to not use all available CPU, keeps the test # running quickly and reliably under a second time.sleep(0.001) except socket.error as e: # we get an EBADF because client is closed in the same process # (but a different greenthread) if get_errno(e) != errno.EBADF: raise
def main(mysql, cassandra): user_server = UserServer(mysql, cassandra) event_dispatcher = EventDispatcher(mysql, cassandra, user_server) event_server = EventServer(event_dispatcher) pinger = Pinger(mysql, user_server) eventlet.spawn(user_server) eventlet.spawn(event_server) eventlet.spawn(pinger) try: while True: time.sleep(1) except KeyboardInterrupt: clearViewers(mysql)
def task(ident): global running rmutex.acquire() delay = random.random() * numtasks * 0.02 rmutex.release() if verbose: print 'task', ident, 'will run for', round(delay, 2), 'sec' time.sleep(delay) if verbose: print 'task', ident, 'done' mutex.acquire() running = running - 1 if running == 0: done.release() mutex.release()
def test_service_check_timeout(self): init_config = {} agent_config = {'timeout': 4} instances = [] for wait in [1,2, 6, 8]: instances.append({'service_wait': wait, 'name' : 'dummy %d' % wait}) self.dummy_service = DummyServiceCheck("dummy service", init_config, agent_config, instances=instances) self.dummy_service.run() time.sleep(10) self.assertEqual(self.dummy_service.statuses['dummy 1'][0], Status.UP) self.assertEqual(self.dummy_service.statuses['dummy 2'][0], Status.UP) self.assertEqual(self.dummy_service.statuses['dummy 6'][0], "FAILURE") self.assertEqual(self.dummy_service.statuses['dummy 8'][0], "FAILURE")
def threading_cleanup(num_active, num_limbo): from eventlet.green import threading from eventlet.green import time _MAX_COUNT = 10 count = 0 while len(threading._active) != num_active and count < _MAX_COUNT: print threading._active count += 1 time.sleep(0.1) count = 0 while len(threading._limbo) != num_limbo and count < _MAX_COUNT: print threading._limbo count += 1 time.sleep(0.1)
def _get_output(self, prompt_expected=True, wait=200): """Retrieve output from _process. This method will wait until output is started to be received and then wait until no further output is received within a defined period :param prompt_expected: only return when regular expression defined in _prompt_pattern is matched :param wait: Time in milliseconds to wait in each of the two loops that wait for (more) output. """ tmp_out = '' while tmp_out == '': self._file_read.seek(0, 1) tmp_out += self._file_read.read() # leave loop if underlying process has a return code # obviously meaning that it has terminated if self._process.poll() is not None: import json error = {"error": tmp_out} raise SubprocessError("subprocess with pid: %s has terminated " "unexpectedly with return code: %s\n%s" % (self._process.pid, self._process.poll(), json.dumps(error))) time.sleep(wait / 1000) stdout = tmp_out while (not tmp_out == '' or (not self._prompt_pattern.findall(stdout) and prompt_expected)): self._file_read.seek(0, 1) tmp_out = self._file_read.read() stdout += tmp_out # leave loop if underlying process has a return code # obviously meaning that it has terminated if self._process.poll() is not None: import json error = {"error": stdout} raise SubprocessError("subprocess with pid: %s has terminated " "unexpectedly with return code: %s\n%s" % (self._process.pid, self._process.poll(), json.dumps(error))) time.sleep(wait / 1000) self._output += stdout stdout = stdout.replace('\r', '').replace('\x08', '') return stdout
def testloop(proto, servers, hdlrcls, testfunc): for svrcls in servers: addr = pickaddr(proto) if verbose: print "ADDR =", addr print "CLASS =", svrcls t = ServerThread(addr, svrcls, hdlrcls) if verbose: print "server created" t.start() if verbose: print "server running" for i in range(NREQ): time.sleep(DELAY) if verbose: print "test client", i testfunc(proto, addr) if verbose: print "waiting for server" t.join() if verbose: print "done"
def test_service_check_timeout(self): init_config = {} agent_config = {'timeout': 4} instances = [] for wait in [1, 2, 6, 8]: instances.append({'service_wait': wait, 'name': 'dummy %d' % wait}) self.dummy_service = DummyServiceCheck("dummy service", init_config, agent_config, instances=instances) self.dummy_service.run() time.sleep(10) self.assertEqual(self.dummy_service.statuses['dummy 1'][0], Status.UP) self.assertEqual(self.dummy_service.statuses['dummy 2'][0], Status.UP) self.assertEqual(self.dummy_service.statuses['dummy 6'][0], "FAILURE") self.assertEqual(self.dummy_service.statuses['dummy 8'][0], "FAILURE")
def parse_response(env, start_response): '''Parse out all necessary information and determine if the query resulted in a match''' #add in some random delay delay = random() time.sleep(delay / 10) try: params = parse_qs(env['QUERY_STRING']) # Extract out all of the sqli information row_index = int(params['row_index'][0]) char_index = int(params['character_index'][0]) - 1 test_char = int(params['character_value'][0]) comparator = comparators.index(params['comparator'][0]) - 1 try: sleep_int = float(params['sleep'].pop(0)) except KeyError: sleep_int = 1 # Determine which character position we are at during the injection current_character = datas[row_index][char_index] # figure out if it was true truth = (cmp(ord(current_character), test_char) == comparator) #some debugging #print "\n\n" #print "%d %s %d == %s" % (ord(current_character),params['comparator'][0],test_char,str(truth)) #print "char_index : %d" % char_index #print "row_index : %d" % row_index # Call the function for what path was given based on the path provided response = types[env['PATH_INFO']](test_char, current_character, comparator, sleep_int, start_response, truth) return response except: start_response('400 Bad Request', [('Content-Type', 'text/plain')]) return ['error\r\n']
class Tunnel(object): # pylint: disable=R0902 """Create a TCP server which will use TunnelHandler.""" def __init__(self, target_host, target_port, sshclient, tunnel_host='localhost', tunnel_port=0): """Constructor.""" if not isinstance(sshclient, paramiko.SSHClient): raise TypeError("'sshclient' must be an instance of " "paramiko.SSHClient.") self.target_host = target_host self.target_port = target_port self.target_address = (target_host, target_port) self.address = (tunnel_host, tunnel_port) self._tunnel = None self._tunnel_thread = None self.sshclient = sshclient self._ssh_transport = self.get_sshclient_transport(self.sshclient) TunnelHandler.target_address = self.target_address TunnelHandler.ssh_transport = self._ssh_transport self._tunnel = TunnelServer(self.address, TunnelHandler) # reset attribute to the port it has actually been set to self.address = self._tunnel.server_address tunnel_host, self.tunnel_port = self.address def get_sshclient_transport(self, sshclient): """Get the sshclient's transport. Connect the sshclient, that has been passed in and return its transport. """ sshclient.connect() return sshclient.get_transport() def serve_forever(self, async=True): """Serve the tunnel forever. if async is True, this will be done in a background thread """ if not async: self._tunnel.serve_forever() else: self._tunnel_thread = threading.Thread( target=self._tunnel.serve_forever) self._tunnel_thread.start() # cooperative yield time.sleep(0)
def _get_output(self, prompt_expected=True, wait=500): """Retrieve output from _process. This method will wait until output is started to be received and then wait until no further output is received within a defined period :param prompt_expected: only return when regular expression defined in _prompt_pattern is matched :param wait: Time in milliseconds to wait in each of the two loops that wait for (more) output. """ tmp_out = '' while tmp_out == '': self._file_read.seek(0, 1) tmp_out += self._file_read.read() # leave loop if underlying process has a return code # obviously meaning that it has terminated if self._handle_output(tmp_out): break time.sleep(float(wait) / 1000) else: LOG.debug("Loop 1 - stdout read: %s", tmp_out) stdout = tmp_out while (tmp_out != '' or (not self._prompt_pattern.findall(stdout) and prompt_expected)): self._file_read.seek(0, 1) tmp_out = self._file_read.read() stdout += tmp_out # leave loop if underlying process has a return code # obviously meaning that it has terminated if self._handle_output(tmp_out): break time.sleep(float(wait) / 1000) else: LOG.debug("Loop 2 - stdout read: %s", tmp_out) self._output += stdout stdout = stdout.replace('\r', '').replace('\x08', '') return stdout
def parse_response(env, start_response): '''Parse out all necessary information and determine if the query resulted in a match''' #add in some random delay delay = random() time.sleep(delay/10) try: params = parse_qs(env['QUERY_STRING']) # Extract out all of the sqli information row_index = int(params['row_index'][0]) char_index = int(params['character_index'][0]) - 1 test_char = int(params['character_value'][0]) comparator = comparators.index(params['comparator'][0]) - 1 try: sleep_int = float(params['sleep'].pop(0)) except KeyError: sleep_int = 1 # Determine which character position we are at during the injection current_character = datas[row_index][char_index] # figure out if it was true truth = (cmp(ord(current_character),test_char) == comparator) #some debugging #print "\n\n" #print "%d %s %d == %s" % (ord(current_character),params['comparator'][0],test_char,str(truth)) #print "char_index : %d" % char_index #print "row_index : %d" % row_index # Call the function for what path was given based on the path provided response = types[env['PATH_INFO']](test_char, current_character, comparator, sleep_int, start_response,truth) return response except: start_response('400 Bad Request', [('Content-Type', 'text/plain')]) return ['error\r\n']
def __call__(self): logging.info('Starting pinger') while True: time.sleep(60) self.ping()
def _wait_for_data(self): curpos = self.fileobj.tell() cursize = os.fstat(self.fileobj.fileno()).st_size while curpos >= cursize: time.sleep(0.01) cursize = os.fstat(self.fileobj.fileno()).st_size
def __init__(self): time.sleep(0.01)
def sleep_func(wait): green_time.sleep(wait)
def sleep(seconds=0): time.sleep(seconds)
def time_based_blind(test_char, current_character, comparator, sleep_int, start_response,truth): # Snage the query string and parse it into a dict sleep_time = sleep_int * truth time.sleep(sleep_time) start_response('200 OK', [('Content-Type', 'text/plain')]) return ['Hello!\r\n']
def _delay(self, secs): greentime.sleep(secs)
def t(): for i in range(1000): time.sleep(random.random() / 1000)