def dump_evlist(self, poll, tag, evlist): if evlist: self.log.info("%s Event list from %s ...", my(self), tag) for fd, ev in evlist: self.log.info(" %s on fd %s", poll.get_event(ev), str(fd)) else: self.log.info("%s Event list from %s is empty", my(self), tag)
def dump_evlist(self, poll, tag, evlist): if evlist: self.log.info("%s Event list from %s ...", my(self), tag) for fd, ev in evlist: self.log.info(" %s on fd %s", poll.get_event(ev), str(fd)) else: self.log.info("%s Event list from %s is empty", my(self), tag)
def Test_C_poll(self): log_level = self.log.getEffectiveLevel() poll_fd, poll_send = self.self_pipe() poll = taskforce.poll.poll() poll.register(poll_fd, taskforce.poll.POLLIN) # Check active poll os.write(poll_send, '\0'.encode('utf-8')) evlist = poll.poll(timeout=30) self.dump_evlist(poll, 'active poll', evlist) assert evlist assert len(os.read(poll_fd, 10)) == 1 # Check timeout evlist = poll.poll(timeout=30) self.dump_evlist(poll, 'timeout poll', evlist) assert evlist == [] # Check timeout accuracy start = time.time() delay = 500 evlist = poll.poll(timeout=500) self.dump_evlist(poll, 'timeout accuracy', evlist) assert evlist == [] delta = abs(time.time() - start - delay/1000.0) self.log.info("%s poll timeout delta from wall clock %s", my(self), deltafmt(delta, decimals=6)) assert delta < 0.1 if poll.get_mode() == taskforce.poll.PL_SELECT: self.log.warning("%s Default mode is PL_SELECT so retest skipped", my(self)) else: poll = taskforce.poll.poll() poll.set_mode(taskforce.poll.PL_SELECT) poll.register(poll_fd, taskforce.poll.POLLIN) # Check active poll os.write(poll_send, '\0'.encode('utf-8')) evlist = poll.poll(timeout=30) self.dump_evlist(poll, 'select active poll', evlist) assert evlist assert len(os.read(poll_fd, 10)) == 1 # Check timeout evlist = poll.poll(timeout=30) self.dump_evlist(poll, 'select timeout poll', evlist) assert evlist == [] # Check timeout accuracy start = time.time() delay = 500 evlist = poll.poll(timeout=500) self.dump_evlist(poll, 'select timeout accuracy', evlist) assert evlist == [] delta = abs(time.time() - start - delay/1000.0) self.log.info("%s select poll timeout delta from wall clock %s", my(self), deltafmt(delta, decimals=6)) assert delta < 0.1 self.close_pipe()
def Test_A_my(self): has_place = re.compile(r'\[\+\d+\s+[^\]]+\]') here = my(log=self.log) self.log.info("%s with no class reference", here) assert here.startswith('Test.Test_A_my()') here = my(self) self.log.info("%s with class reference", here) assert here.startswith('Test.Test_A_my()') my_module_level() my_class_init() here = my(self, place=True, log=self.log) self.log.info("%s with place forced on", here) assert has_place.search(here) here = my(self, place=False, log=self.log) self.log.info("%s with place forced off", here) assert not has_place.search(here) my(self, persist_place=True, log=self.log) here = my(self, log=self.log) self.log.info("%s with persistent place forced on", here) assert has_place.search(here) my(self, persist_place=False, log=self.log) here = my(self, log=self.log) self.log.info("%s with persistent place forced off", here) assert not has_place.search(here)
def Test_C_poll(self): log_level = self.log.getEffectiveLevel() poll_fd, poll_send = self.self_pipe() poll = taskforce.poll.poll() poll.register(poll_fd, taskforce.poll.POLLIN) # Check active poll os.write(poll_send, '\0'.encode('utf-8')) evlist = poll.poll(timeout=30) self.dump_evlist(poll, 'active poll', evlist) assert evlist assert len(os.read(poll_fd, 10)) == 1 # Check timeout evlist = poll.poll(timeout=30) self.dump_evlist(poll, 'timeout poll', evlist) assert evlist == [] # Check timeout accuracy start = time.time() delay = 500 evlist = poll.poll(timeout=500) self.dump_evlist(poll, 'timeout accuracy', evlist) assert evlist == [] delta = abs(time.time() - start - delay/1000.0) self.log.info("%s poll timeout delta from wall clock %s", my(self), deltafmt(delta, decimals=6)) assert delta < 0.1 if poll.get_mode() == taskforce.poll.PL_SELECT: self.log.warning("%s Default mode is PL_SELECT so retest skipped", my(self)) else: poll = taskforce.poll.poll() poll.set_mode(taskforce.poll.PL_SELECT) poll.register(poll_fd, taskforce.poll.POLLIN) # Check active poll os.write(poll_send, '\0'.encode('utf-8')) evlist = poll.poll(timeout=30) self.dump_evlist(poll, 'select active poll', evlist) assert evlist assert len(os.read(poll_fd, 10)) == 1 # Check timeout evlist = poll.poll(timeout=30) self.dump_evlist(poll, 'select timeout poll', evlist) assert evlist == [] # Check timeout accuracy start = time.time() delay = 500 evlist = poll.poll(timeout=500) self.dump_evlist(poll, 'select timeout accuracy', evlist) assert evlist == [] delta = abs(time.time() - start - delay/1000.0) self.log.info("%s select poll timeout delta from wall clock %s", my(self), deltafmt(delta, decimals=6)) assert delta < 0.1 self.close_pipe()
def do_get(self, httpc, httpd, path='/test/json'): httpc.request('GET', path) pset = taskforce.poll.poll() pset.register(httpd, taskforce.poll.POLLIN) # This is a little bit tricky because we are talking to ourselves, # so immediately enter a poll loop, and collect the response once # the daemon thread has been started. This also means we can't # exercise SSL because the httpd service needs control to complete # the handshake. SSL testing is done against the actual taskforce # process in another test unit. # httpr = None done = False handled = False while not done: try: evlist = pset.poll(5000) except OSError as e: if e.errno != errno.EINTR: raise e else: self.log.info("%s Interrupted poll()", my(self)) continue if not evlist: raise Exception("Event loop timed out") for item, mask in evlist: if item == httpd: try: item.handle_request() except Exception as e: self.log.warning("%s HTTP error -- %s", my(self), str(e)) elif item == httpr: assert item.getheader('Content-Type') == 'application/json' text = httpr.read().decode('utf-8') self.log.info('%s %d byte response received', my(self), len(text)) self.log.debug('%s Answer ...', my(self)) for line in text.splitlines(): self.log.debug('%s', line) ans = json.loads(text) assert ans == self.http_test_map done = True break else: raise Exception("Unknown event item: " + str(item)) if not handled: httpr = httpc.getresponse() pset.register(httpr, taskforce.poll.POLLIN) self.log.info("%s HTTP response object successfully registered", my(self)) handled = True
def Test_I_getmap_non_json_error(self): self.log.info("Starting %s", my(self)) gc.collect() httpc = taskforce.http.Client(address='mmm.fullford.com:80', log=self.log) log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) httpc.getmap('/', {'with': 'invalid query'}) self.log.setLevel(log_level) expected_error_occurred = False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred
def start_client(self, address, use_ssl=None): start = time.time() give_up = start + 10 last_exc = None while time.time() < give_up: try: httpc = taskforce.http.Client(address=address, use_ssl=use_ssl, log=self.log) last_exc = None break except Exception as e: last_exc = e self.log.debug("%s Connection attempt failed after %s -- %s", my(self), deltafmt(time.time() - start), str(e)) time.sleep(0.5) if last_exc: self.log.error("%s Connection attempt failed after %s -- %s", my(self), deltafmt(time.time() - start), str(e), exc_info=True) raise last_exc return httpc
def Test_A_http_basics(self): # Force the default address to one that we can create # taskforce.httpd.def_address = self.unx_address # Start a service of the default address we just set # http_service = taskforce.httpd.HttpService() httpd = taskforce.httpd.server(http_service, log=self.log) # Check operation with default address # httpc = taskforce.http.Client(log=self.log) self.log.info("%s Default address is: %s", my(self), httpc.address) assert isinstance(httpc, taskforce.http.Client) del httpc del httpd # Check operation with invalid tcp port log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) httpc = taskforce.http.Client(address='nohost:noport', log=self.log) self.log.setLevel(log_level) expected_http_error_occurred = False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Received expected connect error -- %s", my(self), str(e)) expected_http_error_occurred = True assert expected_http_error_occurred # Check operation with default non-ssl port # http_service = taskforce.httpd.HttpService() http_service.listen = self.lo_address httpd = taskforce.httpd.server(http_service, log=self.log) httpc = taskforce.http.Client(address=http_service.listen, log=self.log) self.log.info("%s Address with default port is: %s", my(self), httpc.address) assert isinstance(httpc, taskforce.http.Client) del httpc del httpd
def start_client(self, address, use_ssl=None): start = time.time() give_up = start + 10 last_exc = None while time.time() < give_up: try: httpc = taskforce.http.Client(address=address, use_ssl=use_ssl, log=self.log) last_exc = None break except Exception as e: last_exc = e self.log.debug("%s Connection attempt failed after %s -- %s", my(self), deltafmt(time.time() - start), str(e)) time.sleep(0.5) if last_exc: self.log.error("%s Connection attempt failed after %s -- %s", my(self), deltafmt(time.time() - start), str(e), exc_info=True) raise last_exc return httpc
def self_pipe(self): """ A self-pipe is a convenient way of exercising some polling """ self.poll_fd, self.poll_send = os.pipe() for fd in [self.poll_fd, self.poll_send]: fl = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK) self.log.info("%s poll_fd = %d, poll_send = %d", my(self), self.poll_fd, self.poll_send) return (self.poll_fd, self.poll_send)
def Test_D_tcp_get(self): self.log.info("Starting %s", my(self)) gc.collect() http_service = taskforce.httpd.HttpService() http_service.listen = self.tcp_address httpd = taskforce.httpd.server(http_service, log=self.log) httpc = taskforce.http.Client(address=self.tcp_address, log=self.log) httpd.register_get(r'/test/.*', self.getter) self.do_get(httpc, httpd) httpd.close() del httpd
def self_pipe(self): """ A self-pipe is a convenient way of exercising some polling """ self.poll_fd, self.poll_send = os.pipe() for fd in [self.poll_fd, self.poll_send]: fl = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK) self.log.info("%s poll_fd = %d, poll_send = %d", my(self), self.poll_fd, self.poll_send) return (self.poll_fd, self.poll_send)
def Test_E_unx_get(self): self.log.info("Starting %s", my(self)) gc.collect() http_service = taskforce.httpd.HttpService() http_service.listen = self.unx_address httpd = taskforce.httpd.server(http_service, log=self.log) httpc = taskforce.http.Client(address=self.unx_address, log=self.log) httpd.register_get(r'/test/.*', self.getter) self.do_get(httpc, httpd) httpd.register_get(r'/bad/.*', self.bad_request) log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) self.do_get(httpc, httpd, path='/bad/path') self.log.setLevel(log_level) expected_get_error_occurred = False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Received expected GET error -- %s", my(self), str(e)) expected_get_error_occurred = True httpd.register_post(r'/bad/.*', self.bad_request) log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) self.do_post(httpc, httpd, '', path='/bad/path') self.log.setLevel(log_level) expected_post_error_occurred = False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Received expected POST error -- %s", my(self), str(e)) expected_post_error_occurred = True httpd.close() del httpd assert expected_get_error_occurred assert expected_post_error_occurred
def Test_B_http_unx_status(self): httpc = self.start_tf(self.unx_address, use_ssl=None) # Check the version info is sane resp = httpc.getmap('/status/version') self.log.info("Version info: %s", str(resp)) assert 'taskforce' in resp # Same, but use post resp = httpc.postmap('/status/version') self.log.info("Version info: %s", str(resp)) assert 'taskforce' in resp # Try a control operation that should be disabled on this path try: resp = httpc.post('/manage/control?db_server=off') assert "No exception on unauthorized control" is False except taskforce.http.HttpError as e: self.log.info("%s Expected exception on bad url: %s", my(self), str(e)) # Again but with different arg layout try: resp = httpc.post('/manage/control', query={'db_server': 'off'}) assert "No exception on unauthorized control" is False except taskforce.http.HttpError as e: self.log.info("%s Expected exception on bad url: %s", my(self), str(e)) # Try an illegal URL try: resp = httpc.getmap('/') assert "No exception on bad url" is False except taskforce.http.HttpError as e: self.log.info("%s Expected exception on bad url: %s", my(self), str(e)) support.check_procsim_errors(self.__module__, env, log=self.log) self.stop_tf()
def get_process_count(self, httpc, taskname, expect=None): count = None initial_delay = 0.5 backoff_delay = 3.0 max_delay = 8.0 max_attempts = 10 delay = initial_delay for attempt in range(max_attempts): self.log.debug("%s Attempt %d", my(self), attempt + 1) resp = httpc.getmap('/status/tasks') if taskname in resp and 'processes' in resp[taskname]: count = 0 for proc in resp[taskname]['processes']: if proc.get('pid'): count += 1 if attempt + 1 < max_attempts: self.log.info( "%s Task '%s' has %d process%s, expecting %s, next attempt in %s", my(self), taskname, count, ses(count, 'es'), expect, deltafmt(delay)) else: self.log.error( "%s Task '%s' has %d process%s, expecting %s, giving up", my(self), taskname, count, ses(count, 'es'), expect) else: count = None self.log.info("%s Task '%s' not found, expecting %s processes", my(self), taskname, expect) if expect is None: self.log.info( "%s Task '%s' has %d process%s with no expectation", my(self), taskname, count, ses(count, 'es')) return count elif count == expect: self.log.info("%s Task '%s' has all %d expected process%s", my(self), taskname, count, ses(count, 'es')) return count for tname in resp.keys(): count = 0 for proc in resp[tname]['processes']: if proc.get('pid'): count += 1 self.log.debug("While waiting, task '%s' has %d process%s", tname, count, ses(count, 'es')) self.log.debug("%s Next attempt in %s", my(self), deltafmt(delay)) time.sleep(delay) delay += backoff_delay if delay > max_delay: delay = max_delay if count is None: raise Exception("No processes seen for task '%s', %d expected" % (taskname, expected)) else: raise Exception("Task '%s' has %d process%s, %d expected" % (taskname, count, ses(count, 'es'), expect))
def Test_J_post(self): self.log.info("Starting %s", my(self)) gc.collect() http_service = taskforce.httpd.HttpService() http_service.listen = self.tcp_address httpd = taskforce.httpd.server(http_service, log=self.log) httpd.register_post(r'/test/.*', self.poster) body = urlencode({'data': json.dumps(self.http_test_map, indent=4)+'\n'}) httpc = taskforce.http.Client(address=self.tcp_address) self.do_post(httpc, httpd, body, path='/test/json?hello=world') httpd.close() del httpd
def Test_C_unx_https_connect(self): self.log.info("Starting %s", my(self)) gc.collect() http_service = taskforce.httpd.HttpService() http_service.listen = self.unx_address http_service.certfile = env.cert_file httpd = taskforce.httpd.server(http_service, log=self.log) l = support.listeners(log=self.log) self.log.info("Service active, listening on %s", l.get(self.unx_address)) assert self.unx_address in l del httpd l = support.listeners(log=self.log) self.log.info("Service deleted, listening on %s", l.get(self.unx_address)) assert self.tcp_port not in l
def Test_B_http_unx_status(self): httpc = self.start_tf(self.unx_address, use_ssl=None) # Check the version info is sane resp = httpc.getmap('/status/version') self.log.info("Version info: %s", str(resp)) assert 'taskforce' in resp # Same, but use post resp = httpc.postmap('/status/version') self.log.info("Version info: %s", str(resp)) assert 'taskforce' in resp # Try a control operation that should be disabled on this path try: resp = httpc.post('/manage/control?db_server=off') assert "No exception on unauthorized control" is False except taskforce.http.HttpError as e: self.log.info("%s Expected exception on bad url: %s", my(self), str(e)) # Again but with different arg layout try: resp = httpc.post('/manage/control', query={'db_server': 'off'}) assert "No exception on unauthorized control" is False except taskforce.http.HttpError as e: self.log.info("%s Expected exception on bad url: %s", my(self), str(e)) # Try an illegal URL try: resp = httpc.getmap('/') assert "No exception on bad url" is False except taskforce.http.HttpError as e: self.log.info("%s Expected exception on bad url: %s", my(self), str(e)) support.check_procsim_errors(self.__module__, env, log=self.log) self.stop_tf()
def get_process_count(self, httpc, taskname, expect=None): count = None initial_delay = 0.5 backoff_delay = 3.0 max_delay = 8.0 max_attempts = 10 delay = initial_delay for attempt in range(max_attempts): self.log.debug("%s Attempt %d", my(self), attempt+1) resp = httpc.getmap('/status/tasks') if taskname in resp and 'processes' in resp[taskname]: count = 0 for proc in resp[taskname]['processes']: if proc.get('pid'): count += 1 if attempt+1 < max_attempts: self.log.info("%s Task '%s' has %d process%s, expecting %s, next attempt in %s", my(self), taskname, count, ses(count, 'es'), expect, deltafmt(delay)) else: self.log.error("%s Task '%s' has %d process%s, expecting %s, giving up", my(self), taskname, count, ses(count, 'es'), expect) else: count = None self.log.info("%s Task '%s' not found, expecting %s processes", my(self), taskname, expect) if expect is None: self.log.info("%s Task '%s' has %d process%s with no expectation", my(self), taskname, count, ses(count, 'es')) return count elif count == expect: self.log.info("%s Task '%s' has all %d expected process%s", my(self), taskname, count, ses(count, 'es')) return count for tname in resp.keys(): count = 0 for proc in resp[tname]['processes']: if proc.get('pid'): count += 1 self.log.debug("While waiting, task '%s' has %d process%s", tname, count, ses(count, 'es')) self.log.debug("%s Next attempt in %s", my(self), deltafmt(delay)) time.sleep(delay) delay += backoff_delay if delay > max_delay: delay = max_delay if count is None: raise Exception("No processes seen for task '%s', %d expected" % (taskname, expected)) else: raise Exception("Task '%s' has %d process%s, %d expected" % (taskname, count, ses(count, 'es'), expect))
def Test_L_cmp(self): """ Test that system won't attempt to unlink an existing unx path that is not a socket and won't successfully create a socket anyway. """ http_service = taskforce.httpd.HttpService() http_service.listen = env.temp_dir log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) httpd = taskforce.httpd.server(http_service, log=self.log) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred
def __init__(self): here = my() support.logger().info("%s at class init level", here) assert here.startswith('my_class_init()')
def Test_C_https_unx_status(self): httpc = self.start_tf(self.unx_address, use_ssl=False, allow_control=True) # Check the version info is sane resp = httpc.getmap('/status/version') self.log.info("Version info: %s", str(resp)) assert 'taskforce' in resp assert 'platform' in resp assert 'release' in resp['platform'] # Allow some process startup time time.sleep(2) taskname = 'ws_server' initial_ws_server_count = self.get_process_count(httpc, taskname) if initial_ws_server_count != self.expected_ws_server_count: self.log.info("%s %d or %d expected %s processs at startup", my(self), initial_ws_server_count, self.expected_ws_server_count, taskname) # Send an invalid management path log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.get('/manage/nosuchpath') self.log.setLevel(log_level) assert "No exception on bad management path" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad management path: %s", my(self), str(e)) # Send a now-valid command but have it expect a JSON return, which doesn't happen log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.postmap('/manage/control', valuemap={'db_server': 'off'}) self.log.setLevel(log_level) assert "No exception on bad JSON return" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad url: %s", my(self), str(e)) # Repeat the last change to test the no-change response (off_code, content, content_type) = httpc.post('/manage/control', valuemap={'db_server': 'off'}) self.log.info('%s repeat-off response info: %d %s "%s"', taskname, off_code, content_type, content.strip()) assert off_code == 200 assert content.strip().endswith('no change') # Turn task back on. (wait_code, content, content_type) = httpc.post('/manage/control', valuemap={'db_server': 'wait'}) self.log.info('%s restart response info: %d %s "%s"', taskname, wait_code, content_type, content.strip()) assert wait_code == 202 assert content.strip().endswith('ok') # Send a control to an unknown task log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.postmap('/manage/control', valuemap={'no_such_task': 'off'}) self.log.setLevel(log_level) assert "No exception on bad task name" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad task name: %s", my(self), str(e)) # Send an invalid control to an known task log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.postmap('/manage/control', valuemap={'db_server': 'no_such_control'}) self.log.setLevel(log_level) assert "No exception on bad control name" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad control name: %s", my(self), str(e)) prior_ws_server_count = self.get_process_count(httpc, taskname, self.expected_ws_server_count) assert prior_ws_server_count == self.expected_ws_server_count # Change the count # new_count = 2 (count_code, content, content_type) = httpc.get('/manage/count?%s=%d' % (taskname, new_count)) self.log.info('%s count response info: %d %s "%s"', taskname, count_code, content_type, content.strip()) assert count_code < 300 ws_server_count = self.get_process_count(httpc, taskname, new_count) assert ws_server_count == new_count # Repeat the last change to test the no-change response (count_code, content, content_type) = httpc.get('/manage/count?%s=%d' % (taskname, new_count)) self.log.info('%s repeat-count response info: %d %s "%s"', taskname, off_code, content_type, content.strip()) assert off_code == 200 assert content.strip().endswith('no change') # Send a count to an unknown task log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.postmap('/manage/count', valuemap={'no_such_task': '1'}) self.log.setLevel(log_level) assert "No exception on bad task name for count" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad task name for count: %s", my(self), str(e)) # Send an invalid count log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.get('/manage/count?%s=nonumberhere' % (taskname, )) self.log.setLevel(log_level) self.log.error("%s Invalid bad count response: %s", my(self), str(resp)) assert "No exception on bad count" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad count value: %s", my(self), str(e)) # Send a zero count log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.post('/manage/count?%s=%d' % (taskname, 0, )) self.log.setLevel(log_level) self.log.error("%s Invalid zero count response: %s", my(self), str(resp)) assert "No exception on zero count" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on zero count: %s", my(self), str(e)) # Send a negative count log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.post('/manage/count', valuemap={taskname: '-42'}) self.log.setLevel(log_level) self.log.error("%s Invalid negative count response: %s", my(self), str(resp)) assert "No exception on negative count" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on negative count: %s", my(self), str(e)) # Reload config to put it back (reload_code, content, content_type) = httpc.get('/manage/reload') self.log.info('%s reload response info: %d %s "%s"', taskname, count_code, content_type, content.strip()) assert reload_code == 202 assert content.strip().endswith('reload initiated') ws_server_count = self.get_process_count(httpc, taskname, self.expected_ws_server_count) assert ws_server_count == self.expected_ws_server_count (reset_code, content, content_type) = httpc.get('/manage/reset') self.log.info('%s reset response info: %d %s "%s"', taskname, count_code, content_type, content.strip()) assert reset_code < 300 assert content.strip().endswith('reset initiated') time.sleep(2) # Reconnect to service and wait for the reset to complete then check that the version info is sane. # resp = None httpc = None for attempt in range(30): try: httpc = self.start_client(self.unx_address, use_ssl=False) resp = httpc.getmap('/status/version') break except taskforce.http.HttpError as e: self.log.error("%s HTTP exception while waiting for reset to complete on attempt %d -- %s", my(self), attempt+1, str(e)) break except Exception as e: self.log.info("%s Error waiting or reset to complete on attempt %d -- %s", my(self), attempt+1, str(e), exc_info=True) time.sleep(0.5) self.log.info("Version info: %s", str(resp)) assert 'taskforce' in resp try: (stop_code, content, content_type) = httpc.get('/manage/stop') self.log.info('%s stop response info: %d %s "%s"', taskname, count_code, content_type, content.strip()) assert stop_code < 300 assert content.strip().endswith('exit initiated') except (taskforce.http.BadStatusLine, taskforce.http.HttpError) as e: self.log.info('%s Expected possible error from stop manage -- %s', my(self), str(e)) except socket.error as e: if e.errno == errno.ECONNRESET: self.log.info('%s Expected possible socket error from stop manage -- %s', my(self), str(e)) else: raise e support.check_procsim_errors(self.__module__, env, log=self.log) self.stop_tf()
def Test_A_https_tcp_status(self): httpc = self.start_tf(self.tcp_address, use_ssl=False) # Check the version info is sane resp = httpc.getmap('/status/version') self.log.info("Version info: %s", str(resp)) assert 'taskforce' in resp assert 'platform' in resp # This is not a control path, so the os release and platform should be hidden assert 'release' not in resp['platform'] assert 'platform' not in resp['platform'] # Try a bogus format try: resp = httpc.getmap('/status/version?indent=4&fmt=xml') assert "No 'version' exception on bad 'fmt'" is False except taskforce.http.HttpError as e: self.log.info("%s Expected 'version' exception on bad format: %s", my(self), str(e)) give_up = time.time() + 30 toi = 'db_server' toi_started = None while time.time() < give_up: resp = httpc.getmap('/status/tasks') self.log.debug('Resp %s', json.dumps(resp, indent=4)) if toi in resp: if 'processes' in resp[toi] and len(resp[toi]['processes']) > 0: if 'started_t' in resp[toi]['processes'][0]: toi_started = resp[toi]['processes'][0]['started_t'] self.log.info("%s Task of interest '%s' started %s ago", my(self), toi, deltafmt(time.time() - toi_started)) break else: self.log.info("%s Task of interest '%s' is has procs", my(self), toi) else: self.log.info("%s Task of interest '%s' is known", my(self), toi) time.sleep(9) # Try a bogus format try: resp = httpc.getmap('/status/tasks?indent=4&fmt=xml') assert "No 'tasks' exception on bad 'fmt'" is False except taskforce.http.HttpError as e: self.log.info("%s Expected 'tasks' exception on bad format: %s", my(self), str(e)) # Check the config info is sane resp = httpc.getmap('/status/config?pending=0') assert 'tasks' in resp # Try a bogus format try: resp = httpc.getmap('/status/config?indent=4&fmt=xml') assert "No 'config' exception on bad 'fmt'" is False except taskforce.http.HttpError as e: self.log.info("%s Expected 'config' exception on bad format: %s", my(self), str(e)) support.check_procsim_errors(self.__module__, env, log=self.log) self.stop_tf() assert toi_started is not None
def Test_B_register(self): log_level = self.log.getEffectiveLevel() poll = taskforce.poll.poll() currmode = poll.get_mode() self.log.info("%s Default polling mode is '%s' of %s", my(self), poll.get_mode_name(mode=currmode), str(poll.get_available_mode_names())) # Find a valid mode that is not the current mode # nextmode = None for mode in poll.get_available_modes(): if mode != currmode: nextmode = mode self.log.info("%s Determined valid non-active mode as %s", my(self), poll.get_mode_name(mode=nextmode)) poll_fd, poll_send = self.self_pipe() poll.register(poll_fd) # Test that an attempt to change mode is rejected # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.set_mode(nextmode) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Test that an attempt to register an invalid fd fails # inv_fd = 999 # Make sure it is invalid try: os.close(inv_fd) except: pass try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.register(inv_fd) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected invalid fd error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Confirm new mode is same as previous poll = taskforce.poll.poll() mode = poll.get_mode() self.log.info("%s Default polling mode is '%s' and should be same as previous '%s'", my(self), poll.get_mode_name(mode=mode), poll.get_mode_name(mode=currmode)) # Change to PL_SELECT and register poll.set_mode(taskforce.poll.PL_SELECT) assert poll.get_mode() == taskforce.poll.PL_SELECT poll.register(poll_fd) # Check invalid unregister # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.unregister(self) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Check valid unregister # poll.unregister(poll_fd) self.close_pipe()
def Test_G_connect_to_nothing(self): log_level = self.log.getEffectiveLevel() # Test get_query() convenience function # element_path = 'http://' + self.lo_address + '/path?element=value' qdict = taskforce.httpd.get_query(element_path) self.log.info("%s get_query() returned: %s", my(self), str(qdict)) assert 'element' in qdict qdict = taskforce.httpd.get_query(element_path, force_unicode=False) self.log.info("%s get_query() returned: %s", my(self), str(qdict)) assert 'element' in qdict # Try to create service with a non-integer port # http_service = taskforce.httpd.HttpService() http_service.listen = self.tcp_address + ':not_an_int' try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) httpd = taskforce.httpd.server(http_service, log=self.log) self.log.setLevel(log_level) expected_tcp_port_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected tcp port error -- %s", my(self), str(e)) expected_tcp_port_error_occurred = True assert expected_tcp_port_error_occurred # Try tcp and unx connections with and without ssl, with nothing listening # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) httpc = taskforce.http.Client(address='localhost', log=self.log) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) httpc = taskforce.http.Client(address='/tmp/no/such/socket', log=self.log) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) httpc = taskforce.http.Client(address=self.lo_address, use_ssl=False, log=self.log) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) httpc = taskforce.http.Client(address='/tmp/no/such/socket', use_ssl=False, log=self.log) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred
def my_module_level(): here = my() support.logger().info("%s at module level", here) assert here.startswith('test_01_utils.my_module_level()')
def Test_B_register(self): log_level = self.log.getEffectiveLevel() poll = taskforce.poll.poll() currmode = poll.get_mode() self.log.info("%s Default polling mode is '%s' of %s", my(self), poll.get_mode_name(mode=currmode), str(poll.get_available_mode_names())) # Find a valid mode that is not the current mode # nextmode = None for mode in poll.get_available_modes(): if mode != currmode: nextmode = mode self.log.info("%s Determined valid non-active mode as %s", my(self), poll.get_mode_name(mode=nextmode)) poll_fd, poll_send = self.self_pipe() poll.register(poll_fd) # Test that an attempt to change mode is rejected # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.set_mode(nextmode) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Test that an attempt to register an invalid fd fails # inv_fd = 999 # Make sure it is invalid try: os.close(inv_fd) except: pass try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.register(inv_fd) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected invalid fd error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Confirm new mode is same as previous poll = taskforce.poll.poll() mode = poll.get_mode() self.log.info("%s Default polling mode is '%s' and should be same as previous '%s'", my(self), poll.get_mode_name(mode=mode), poll.get_mode_name(mode=currmode)) # Change to PL_SELECT and register poll.set_mode(taskforce.poll.PL_SELECT) assert poll.get_mode() == taskforce.poll.PL_SELECT poll.register(poll_fd) # Check invalid unregister # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.unregister(self) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Check valid unregister # poll.unregister(poll_fd) self.close_pipe()
def Test_A_mode(self): log_level = self.log.getEffectiveLevel() poll = taskforce.poll.poll() mode = poll.get_mode() allowed_modes = poll.get_available_modes() self.log.info("%s Default polling mode is '%s' of %s", my(self), poll.get_mode_name(mode=mode), str(poll.get_available_mode_names())) # get_mode_name() should always return a string # name = poll.get_mode_name(mode='junk') self.log.info("%s get_mode_name() response to invalid mode %s", my(self), name) assert type(name) is str # Format multiple events # evtext = poll.get_event(taskforce.poll.POLLIN|taskforce.poll.POLLOUT) self.log.info("%s get_event() response to multiple events %s", my(self), evtext) assert type(name) is str # Format bad events # evtext = poll.get_event(taskforce.poll.POLLIN|taskforce.poll.POLLOUT|0x800) self.log.info("%s get_event() response to multiple events %s", my(self), evtext) assert type(name) is str # Invalid event input # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.get_event(None) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected invalid event error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Should always be able to force PL_SELECT poll.set_mode(taskforce.poll.PL_SELECT) assert poll.get_mode() == taskforce.poll.PL_SELECT # Find a mode that is not available bad_mode = None for mode in known_polling_modes: if mode not in allowed_modes: bad_mode = mode break self.log.info("%s Determined unavailable mode as %s", my(self), poll.get_mode_name(mode=bad_mode)) # Check that we can't set mode to None # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.set_mode(None) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Check that we can't set mode to an impossible value # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.set_mode(-1) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Check that we can't set an unavailable mode # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.set_mode(bad_mode) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred
def Test_A_mode(self): log_level = self.log.getEffectiveLevel() poll = taskforce.poll.poll() mode = poll.get_mode() allowed_modes = poll.get_available_modes() self.log.info("%s Default polling mode is '%s' of %s", my(self), poll.get_mode_name(mode=mode), str(poll.get_available_mode_names())) # get_mode_name() should always return a string # name = poll.get_mode_name(mode='junk') self.log.info("%s get_mode_name() response to invalid mode %s", my(self), name) assert type(name) is str # Format multiple events # evtext = poll.get_event(taskforce.poll.POLLIN|taskforce.poll.POLLOUT) self.log.info("%s get_event() response to multiple events %s", my(self), evtext) assert type(name) is str # Format bad events # evtext = poll.get_event(taskforce.poll.POLLIN|taskforce.poll.POLLOUT|0x800) self.log.info("%s get_event() response to multiple events %s", my(self), evtext) assert type(name) is str # Invalid event input # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.get_event(None) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected invalid event error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Should always be able to force PL_SELECT poll.set_mode(taskforce.poll.PL_SELECT) assert poll.get_mode() == taskforce.poll.PL_SELECT # Find a mode that is not available bad_mode = None for mode in known_polling_modes: if mode not in allowed_modes: bad_mode = mode break self.log.info("%s Determined unavailable mode as %s", my(self), poll.get_mode_name(mode=bad_mode)) # Check that we can't set mode to None # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.set_mode(None) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Check that we can't set mode to an impossible value # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.set_mode(-1) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Check that we can't set an unavailable mode # try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) poll.set_mode(bad_mode) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred
def Test_C_https_unx_status(self): httpc = self.start_tf(self.unx_address, use_ssl=False, allow_control=True) # Check the version info is sane resp = httpc.getmap('/status/version') self.log.info("Version info: %s", str(resp)) assert 'taskforce' in resp assert 'platform' in resp assert 'release' in resp['platform'] # Allow some process startup time time.sleep(2) taskname = 'ws_server' initial_ws_server_count = self.get_process_count(httpc, taskname) if initial_ws_server_count != self.expected_ws_server_count: self.log.info("%s %d or %d expected %s processs at startup", my(self), initial_ws_server_count, self.expected_ws_server_count, taskname) # Send an invalid management path log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.get('/manage/nosuchpath') self.log.setLevel(log_level) assert "No exception on bad management path" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad management path: %s", my(self), str(e)) # Send a now-valid command but have it expect a JSON return, which doesn't happen log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.postmap('/manage/control', valuemap={'db_server': 'off'}) self.log.setLevel(log_level) assert "No exception on bad JSON return" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad url: %s", my(self), str(e)) # Repeat the last change to test the no-change response (off_code, content, content_type) = httpc.post('/manage/control', valuemap={'db_server': 'off'}) self.log.info('%s repeat-off response info: %d %s "%s"', taskname, off_code, content_type, content.strip()) assert off_code == 200 assert content.strip().endswith('no change') # Turn task back on. (wait_code, content, content_type) = httpc.post('/manage/control', valuemap={'db_server': 'wait'}) self.log.info('%s restart response info: %d %s "%s"', taskname, wait_code, content_type, content.strip()) assert wait_code == 202 assert content.strip().endswith('ok') # Send a control to an unknown task log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.postmap('/manage/control', valuemap={'no_such_task': 'off'}) self.log.setLevel(log_level) assert "No exception on bad task name" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad task name: %s", my(self), str(e)) # Send an invalid control to an known task log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.postmap('/manage/control', valuemap={'db_server': 'no_such_control'}) self.log.setLevel(log_level) assert "No exception on bad control name" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad control name: %s", my(self), str(e)) prior_ws_server_count = self.get_process_count( httpc, taskname, self.expected_ws_server_count) assert prior_ws_server_count == self.expected_ws_server_count # Change the count # new_count = 2 (count_code, content, content_type) = httpc.get('/manage/count?%s=%d' % (taskname, new_count)) self.log.info('%s count response info: %d %s "%s"', taskname, count_code, content_type, content.strip()) assert count_code < 300 ws_server_count = self.get_process_count(httpc, taskname, new_count) assert ws_server_count == new_count # Repeat the last change to test the no-change response (count_code, content, content_type) = httpc.get('/manage/count?%s=%d' % (taskname, new_count)) self.log.info('%s repeat-count response info: %d %s "%s"', taskname, off_code, content_type, content.strip()) assert off_code == 200 assert content.strip().endswith('no change') # Send a count to an unknown task log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.postmap('/manage/count', valuemap={'no_such_task': '1'}) self.log.setLevel(log_level) assert "No exception on bad task name for count" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info( "%s Expected exception on bad task name for count: %s", my(self), str(e)) # Send an invalid count log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.get('/manage/count?%s=nonumberhere' % (taskname, )) self.log.setLevel(log_level) self.log.error("%s Invalid bad count response: %s", my(self), str(resp)) assert "No exception on bad count" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on bad count value: %s", my(self), str(e)) # Send a zero count log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.post('/manage/count?%s=%d' % ( taskname, 0, )) self.log.setLevel(log_level) self.log.error("%s Invalid zero count response: %s", my(self), str(resp)) assert "No exception on zero count" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on zero count: %s", my(self), str(e)) # Send a negative count log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) resp = httpc.post('/manage/count', valuemap={taskname: '-42'}) self.log.setLevel(log_level) self.log.error("%s Invalid negative count response: %s", my(self), str(resp)) assert "No exception on negative count" is False except taskforce.http.HttpError as e: self.log.setLevel(log_level) self.log.info("%s Expected exception on negative count: %s", my(self), str(e)) # Reload config to put it back (reload_code, content, content_type) = httpc.get('/manage/reload') self.log.info('%s reload response info: %d %s "%s"', taskname, count_code, content_type, content.strip()) assert reload_code == 202 assert content.strip().endswith('reload initiated') ws_server_count = self.get_process_count(httpc, taskname, self.expected_ws_server_count) assert ws_server_count == self.expected_ws_server_count (reset_code, content, content_type) = httpc.get('/manage/reset') self.log.info('%s reset response info: %d %s "%s"', taskname, count_code, content_type, content.strip()) assert reset_code < 300 assert content.strip().endswith('reset initiated') time.sleep(2) # Reconnect to service and wait for the reset to complete then check that the version info is sane. # resp = None httpc = None for attempt in range(30): try: httpc = self.start_client(self.unx_address, use_ssl=False) resp = httpc.getmap('/status/version') break except taskforce.http.HttpError as e: self.log.error( "%s HTTP exception while waiting for reset to complete on attempt %d -- %s", my(self), attempt + 1, str(e)) break except Exception as e: self.log.info( "%s Error waiting or reset to complete on attempt %d -- %s", my(self), attempt + 1, str(e), exc_info=True) time.sleep(0.5) self.log.info("Version info: %s", str(resp)) assert 'taskforce' in resp try: (stop_code, content, content_type) = httpc.get('/manage/stop') self.log.info('%s stop response info: %d %s "%s"', taskname, count_code, content_type, content.strip()) assert stop_code < 300 assert content.strip().endswith('exit initiated') except (taskforce.http.BadStatusLine, taskforce.http.HttpError) as e: self.log.info('%s Expected possible error from stop manage -- %s', my(self), str(e)) except socket.error as e: if e.errno == errno.ECONNRESET: self.log.info( '%s Expected possible socket error from stop manage -- %s', my(self), str(e)) else: raise e support.check_procsim_errors(self.__module__, env, log=self.log) self.stop_tf()
def Test_L_pidclaim(self): args = list(sys.argv) args.pop(0) pidfile = './%s-%s.pid' % (utils.appname(), env.edition) # Run the test as a forked process so we can test for # pid file creation and removal. # start = time.time() pid = os.fork() if pid == 0: args = ['pidclaim'] self.set_path('PYTHONPATH', env.base_dir) if 'NOSE_WITH_COVERAGE' in os.environ: exe = 'coverage' args.append('run') else: exe = 'python' args.extend(['tests/scripts/pidclaim', pidfile]) self.log.info("%s child, running '%s' %s", my(self), exe, args) os.execvp(exe, args) else: time.sleep(1) self.log.info("Child PID is: %d", pid) with open(pidfile, 'r') as f: claim_pid = int(f.readline().strip()) self.log.info("PID read back as: %d", claim_pid) assert claim_pid == pid (wpid, status) = os.wait() self.log.info("Child ran %s", utils.deltafmt(time.time() - start, decimals=3)) self.log.info("Child %s", utils.statusfmt(status)) assert status == 0 assert not os.path.exists(pidfile) # Bad pid param # log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) utils.pidclaim(pid='abc') self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected bad pid error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred # Invalid pid param # log_level = self.log.getEffectiveLevel() try: # Mask the log message as we expect a failure self.log.setLevel(logging.CRITICAL) utils.pidclaim(pid=0) self.log.setLevel(log_level) expected_error_occurred = False except Exception as e: self.log.setLevel(log_level) self.log.info("%s Received expected invalid pid error -- %s", my(self), str(e)) expected_error_occurred = True assert expected_error_occurred
def Test_A_https_tcp_status(self): httpc = self.start_tf(self.tcp_address, use_ssl=False) # Check the version info is sane resp = httpc.getmap('/status/version') self.log.info("Version info: %s", str(resp)) assert 'taskforce' in resp assert 'platform' in resp # This is not a control path, so the os release and platform should be hidden assert 'release' not in resp['platform'] assert 'platform' not in resp['platform'] # Try a bogus format try: resp = httpc.getmap('/status/version?indent=4&fmt=xml') assert "No 'version' exception on bad 'fmt'" is False except taskforce.http.HttpError as e: self.log.info("%s Expected 'version' exception on bad format: %s", my(self), str(e)) give_up = time.time() + 30 toi = 'db_server' toi_started = None while time.time() < give_up: resp = httpc.getmap('/status/tasks') self.log.debug('Resp %s', json.dumps(resp, indent=4)) if toi in resp: if 'processes' in resp[toi] and len( resp[toi]['processes']) > 0: if 'started_t' in resp[toi]['processes'][0]: toi_started = resp[toi]['processes'][0]['started_t'] self.log.info( "%s Task of interest '%s' started %s ago", my(self), toi, deltafmt(time.time() - toi_started)) break else: self.log.info("%s Task of interest '%s' is has procs", my(self), toi) else: self.log.info("%s Task of interest '%s' is known", my(self), toi) time.sleep(9) # Try a bogus format try: resp = httpc.getmap('/status/tasks?indent=4&fmt=xml') assert "No 'tasks' exception on bad 'fmt'" is False except taskforce.http.HttpError as e: self.log.info("%s Expected 'tasks' exception on bad format: %s", my(self), str(e)) # Check the config info is sane resp = httpc.getmap('/status/config?pending=0') assert 'tasks' in resp # Try a bogus format try: resp = httpc.getmap('/status/config?indent=4&fmt=xml') assert "No 'config' exception on bad 'fmt'" is False except taskforce.http.HttpError as e: self.log.info("%s Expected 'config' exception on bad format: %s", my(self), str(e)) support.check_procsim_errors(self.__module__, env, log=self.log) self.stop_tf() assert toi_started is not None