def __init__(self, file_name, max_queue_size=100):
"""Automatically starts the thread.
Args:
file_name: The name of the file.
max_queue_size: The max queries that will be queued.
"""
self.logger = get_logger(self.__class__.__qualname__)
threading.Thread.__init__(self)
self.daemon = True
self.sqlite3_conn = apsw.Connection(file_name)
# Configures the connection always to return a dictionary
# instead of a tuple
def row_factory(cursor, row):
return {
k[0]: row[i]
for i, k in enumerate(cursor.getdescription())
}
self.sqlite3_conn.setrowtrace(row_factory)
self.sqlite3_cursor = self.sqlite3_conn.cursor()
self.sql_queue = Queue.Queue(maxsize=max_queue_size)
self.results = {}
self.max_queue_size = max_queue_size
self.exit_set = False
# Token that is put into queue when close() is called.
self.exit_token = str(uuid.uuid4())
self.start()
self.thread_running = True
def __init__(self,
config,
target_function,
thread_name,
start_with_call=True):
"""
Builds an abstract thread object from the given input parameters.
"""
# No need to pass the target function as this point, as this
# class is abstract by design. Instead, save the reference internally
# to allow subclasses to invoke the target function when overriding
# the run() method
Thread.__init__(self, name=thread_name)
# Private attributes not to be accessed directly, but
# through their corresponding properties
self.__logger = get_logger(self.__class__.__qualname__)
self.__config = config
# Protected attributes to be accessed by child subclasses only
self._target_function = target_function
self._start_with_call = start_with_call
# Protected attributes to be accessed by child subclases and
# whose state can be probed by others (i.e., there is a corresponding
# property)
self._exec = False
def __init__(self,
wrappers_dir,
analyzer_name,
args,
storage_dir,
timeout_sec,
prefetch=True):
self.__logger = get_logger(self.__class__.__qualname__)
self.__analyzer_name = analyzer_name
self.__home = "{0}/{1}".format(wrappers_dir, analyzer_name)
self.__args = args
if not dir_exists(storage_dir):
os.makedirs(storage_dir)
self.__storage_dir = storage_dir
self.__timeout_sec = timeout_sec
metadata_script = "{0}/metadata".format(self.home)
run_script = "{0}/run".format(self.home)
pull_script = "{0}/pull_analyzer".format(self.home)
Wrapper.__check_for_executable_script(run_script)
Wrapper.__check_for_executable_script(metadata_script)
Wrapper.__check_for_executable_script(pull_script)
self.__metadata_script = metadata_script
self.__run_script = run_script
self.__pull_script = pull_script
# Prefetch the configured analyzer image. If the prefetching fails,
# an exception is thrown, the program exits and the auto-restart feature kicks in.
if prefetch:
self.__prefetch_image()
def test_configure_logging_no_stream(self):
# Since streaming is set to False, this will not invoke logger creating and will pass
streaming_provider_name = "Nonsense"
# The logger is not initialized proper
streaming_provider_args = {
'log_group': 'grp',
'log_stream': 'stream',
'send_interval_seconds': 10
}
config = {
'is_enabled': False,
'provider': streaming_provider_name,
'args': streaming_provider_args
}
log_streaming.initialize("test-account", config, force=True)
self.assertEqual(get_loggers(), {})
log_streaming.get_logger("test_get_logger")
# No configuration should happen
self.assertFalse("test_get_logger" in get_loggers())
def test_configure_logging_stream_provider(self):
streaming_provider_name = "CloudWatchProvider"
# The logger is not initialized proper
streaming_provider_args = {
'log_group': 'grp',
'log_stream': 'stream',
'send_interval_seconds': 10
}
config = {
'is_enabled': True,
'provider': streaming_provider_name,
'args': streaming_provider_args
}
log_streaming.initialize("test-account", config, force=True)
logger = log_streaming.get_logger("test_get_logger")
self.assertTrue(logger is log_streaming.get_logger("test_get_logger"))
self.assertTrue("test_get_logger" in get_loggers())
# Reset logging after this call
log_streaming.initialize("account", {'is_enabled': False}, force=True)
def __init__(self, config):
"""
Builds a QSPAuditNode object from the given input parameters.
"""
self.__exec = False
self.__config = config
self.__is_initialized = False
self.__logger = get_logger(self.__class__.__qualname__)
self.__internal_threads = [
ComputeGasPriceThread(config),
UpdateMinPriceThread(config),
ClaimRewardsThread(config),
PollRequestsThread(config),
PerformAuditThread(config),
SubmitReportThread(config),
MonitorSubmissionThread(config)
]
if config.metric_collection_is_enabled:
self.__internal_threads.append(CollectMetricsThread(config))
def __init__(self, node_version):
self.__logger = get_logger(self.__class__.__qualname__)
self.__node_version = node_version
####################################################################################################
# #
# (c) 2018, 2019 Quantstamp, Inc. This content and its use are governed by the license terms at #
# <https://s3.amazonaws.com/qsp-protocol-license/V2_LICENSE.txt> #
# #
####################################################################################################
import signal
import sys
from log_streaming import get_logger
logger = get_logger(__name__)
class Stop:
"""
A class providing a stop notification mechanism for all registered
stoppable objects (a stoppable object is one prodiving a stop
function), as well as an exiting mechanism for the executing process to
terminate altogether.
"""
__objects = []
@classmethod
def stop_all(cls):
"""
Stops all registered stoppable objects.
"""
for stoppable in Stop.__objects:
stoppable.stop()
def __init__(self, config):
self.__logger = get_logger(self.__class__.__qualname__)
self.__config = config
self.__process_identifier = "{0}-{1}".format(socket.gethostname(), os.getpid())
def __init__(self, wrapper):
"""
Builds an Analyzer object from a given arguments string.
"""
self.__wrapper = wrapper
self.__logger = get_logger(self.__class__.__qualname__)
def __init__(self):
self.__logger = get_logger(self.__class__.__qualname__)
self.__vulnerability_types, self.__vulnerability_types_inverted = \
ReportEncoder.__initialize_vulnerability_types()
