Merge branch 'development' into feature/telemetryv2

Author: chillaq

splitio/client/factory.py

@@ -145,8 +145,7 @@ def _start_status_updater(self):
             self._status = Status.NOT_INITIALIZED
             # add a listener that updates the status to READY once the flag is set.
             ready_updater = threading.Thread(target=self._update_status_when_ready,
-                                             name='SDKReadyFlagUpdater')
-            ready_updater.setDaemon(True)
+                                             name='SDKReadyFlagUpdater', daemon=True)
             ready_updater.start()
         else:
             self._status = Status.READY
@@ -244,8 +243,7 @@ def _wait_for_tasks_to_stop():
                         self._sync_manager.stop(True)
                         destroyed_event.set()
 
-                    wait_thread = threading.Thread(target=_wait_for_tasks_to_stop)
-                    wait_thread.setDaemon(True)
+                    wait_thread = threading.Thread(target=_wait_for_tasks_to_stop, daemon=True)
                     wait_thread.start()
                 else:
                     self._sync_manager.stop(False)
@@ -291,8 +289,8 @@ def resume(self):
         initialization_thread = threading.Thread(
             target=self._sync_manager.start,
             name="SDKInitializer",
+            daemon=True
         )
-        initialization_thread.setDaemon(True)
         initialization_thread.start()
         self._preforked_initialization = False  # reset for status updater
         self._start_status_updater()
@@ -426,8 +424,7 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         return SplitFactory(api_key, storages, cfg['labelsEnabled'],
                             recorder, manager, None, telemetry_producer, telemetry_init_producer, telemetry_submitter, preforked_initialization=preforked_initialization)
 
-    initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer")
-    initialization_thread.setDaemon(True)
+    initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer", daemon=True)
     initialization_thread.start()
 
     return SplitFactory(api_key, storages, cfg['labelsEnabled'],
@@ -494,8 +491,7 @@ def _build_redis_factory(api_key, cfg):
     )
 
     manager = RedisManager(synchronizer)
-    initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer")
-    initialization_thread.setDaemon(True)
+    initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer", daemon=True)
     initialization_thread.start()
 
     telemetry_init_producer.record_config(cfg, {})

splitio/push/segmentworker.py

@@ -54,8 +54,7 @@ def start(self):
         self._running = True
 
         _LOGGER.debug('Starting Segment Worker')
-        self._worker = threading.Thread(target=self._run, name='PushSegmentWorker')
-        self._worker.setDaemon(True)
+        self._worker = threading.Thread(target=self._run, name='PushSegmentWorker', daemon=True)
         self._worker.start()
 
     def stop(self):

splitio/push/splitsse.py

@@ -134,8 +134,7 @@ def connect(url):
                 self._on_disconnected()
 
         url = self._build_url(token)
-        task = threading.Thread(target=connect, name='SSEConnection', args=(url,))
-        task.setDaemon(True)
+        task = threading.Thread(target=connect, name='SSEConnection', args=(url,), daemon=True)
         task.start()
         event_group.wait()
         return self._status == SplitSSEClient._Status.CONNECTED

splitio/push/splitworker.py

@@ -53,8 +53,7 @@ def start(self):
         self._running = True
 
         _LOGGER.debug('Starting Split Worker')
-        self._worker = threading.Thread(target=self._run, name='PushSplitWorker')
-        self._worker.setDaemon(True)
+        self._worker = threading.Thread(target=self._run, name='PushSplitWorker', daemon=True)
         self._worker.start()
 
     def stop(self):

splitio/sync/manager.py

@@ -55,8 +55,7 @@ def __init__(self, ready_flag, synchronizer, auth_api, streaming_enabled, sdk_me
             self._queue = Queue()
             self._push = PushManager(auth_api, synchronizer, self._queue, sdk_metadata, telemetry_runtime_producer, sse_url, client_key)
             self._push_status_handler = Thread(target=self._streaming_feedback_handler,
-                                               name='PushStatusHandler')
-            self._push_status_handler.setDaemon(True)
+                                               name='PushStatusHandler', daemon=True)
 
     def recreate(self):
         """Recreate poolers for forked processes."""

splitio/tasks/util/asynctask.py

@@ -128,8 +128,7 @@ def start(self):
 
         # Start execution
         self._thread = threading.Thread(target=self._execution_wrapper,
-                                        name='AsyncTask::' + getattr(self._main, '__name__', 'N/S'))
-        self._thread.setDaemon(True)
+                                        name='AsyncTask::' + getattr(self._main, '__name__', 'N/S'), daemon=True)
         try:
             self._thread.start()
 

splitio/tasks/util/workerpool.py

@@ -27,7 +27,7 @@ def __init__(self, worker_count, worker_func):
             for i in range(0, worker_count)
         ]
         for thread in self._threads:
-            thread.setDaemon(True)
+            thread.daemon = True
 
     def start(self):
         """Start the workers."""
@@ -116,8 +116,7 @@ def wait_for_completion(self):
 
     def stop(self, event=None):
         """Stop all worker nodes."""
-        async_stop = Thread(target=self._wait_workers_shutdown, args=(event,))
-        async_stop.setDaemon(True)
+        async_stop = Thread(target=self._wait_workers_shutdown, args=(event,), daemon=True)
         async_stop.start()
 
     def _wait_workers_shutdown(self, event):

splitio/version.py

@@ -1 +1 @@
-__version__ = '9.3.0-rc1'
+__version__ = '9.3.0-rc1'

tests/helpers/mockserver.py

@@ -23,8 +23,7 @@ def __init__(self, req_queue=None):
         self._queue = queue.Queue()
         self._server = HTTPServer(('localhost', 0),
                                   lambda *xs: SSEHandler(self._queue, *xs, req_queue=req_queue))
-        self._server_thread = threading.Thread(target=self._blocking_run)
-        self._server_thread.setDaemon(True)
+        self._server_thread = threading.Thread(target=self._blocking_run, daemon=True)
         self._done_event = threading.Event()
 
     def _blocking_run(self):
@@ -116,8 +115,7 @@ def __init__(self, split_changes=None, segment_changes=None, req_queue=None,
                                   lambda *xs: SDKHandler(split_changes, segment_changes, *xs,
                                                          req_queue=req_queue,
                                                          auth_response=auth_response))
-        self._server_thread = threading.Thread(target=self._blocking_run, name="SplitMockServer")
-        self._server_thread.setDaemon(True)
+        self._server_thread = threading.Thread(target=self._blocking_run, name="SplitMockServer", daemon=True)
         self._done_event = threading.Event()
 
     def _blocking_run(self):

tests/push/test_manager.py

@@ -43,8 +43,7 @@ def test_connection_success(self, mocker):
 
         def new_start(*args, **kwargs):  # pylint: disable=unused-argument
             """splitsse.start mock."""
-            thread = Thread(target=manager._handle_connection_ready)
-            thread.setDaemon(True)
+            thread = Thread(target=manager._handle_connection_ready, daemon=True)
             thread.start()
             return True
 
@@ -81,8 +80,7 @@ def test_connection_failure(self, mocker):
 
         def new_start(*args, **kwargs):  # pylint: disable=unused-argument
             """splitsse.start mock."""
-            thread = Thread(target=manager._handle_connection_end)
-            thread.setDaemon(True)
+            thread = Thread(target=manager._handle_connection_end, daemon=True)
             thread.start()
             return False