amps-python-client 5.3.4.2__zip → 5.3.4.3__zip

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/src/tcps.c

@@ -80,7 +80,62 @@ int amps_win_spin_lock(LPCRITICAL_SECTION x);
 #define AMPS_SPIN_LOCK_UNLIMITED(x) EnterCriticalSection(x)
 #define AMPS_UNLOCK(x) LeaveCriticalSection(x)
 #define AMPS_KILLLOCK(x) DeleteCriticalSection(x)
+#else
+#define GET_ERRNO (errno)
+#define SOCK_ERRORCODE(x) x
+#include <pthread.h>
+
+static pthread_mutexattr_t _mutexattr_recursive;
+#define AMPS_INITLOCK(x) { \
+    pthread_mutexattr_init(&_mutexattr_recursive); \
+    pthread_mutexattr_settype(&_mutexattr_recursive, PTHREAD_MUTEX_RECURSIVE);\
+    pthread_mutex_init(x, &_mutexattr_recursive); }
+#define AMPS_LOCK(x) pthread_mutex_lock(x)
+#define AMPS_SPIN_LOCK(x) amps_spin_lock_counted(x)
+#define AMPS_SPIN_LOCK_UNLIMITED(x) amps_spin_lock_unlimited(x)
+#define AMPS_UNLOCK(x) pthread_mutex_unlock(x)
+#define AMPS_KILLLOCK(x) pthread_mutex_destroy(x)
+#endif
+
+#ifdef AMPS_CPP_COUNT_THREADS
+#define AMPS_INC_THREAD_COUNT(x) AMPS_FETCH_ADD(x, 1)
+#else
+#define AMPS_INC_THREAD_COUNT(x)
+#endif
+
+#ifdef _WIN32
+INIT_ONCE ampsTcpsThreadKeyOnce = INIT_ONCE_STATIC_INIT;
+DWORD ampsTcpsThreadKey = TLS_OUT_OF_INDEXES;
+
+void amps_tcps_delete_key(void)
+{
+  TlsFree(ampsTcpsThreadKey);
+}
+
+BOOL CALLBACK amps_tcps_init_key(PINIT_ONCE pKeyOnce, PVOID unused, PVOID* unused2)
+{
+  if ((ampsTcpsThreadKey = TlsAlloc()) == TLS_OUT_OF_INDEXES)
+  {
+    return FALSE;
+  }
+  atexit(amps_tcps_delete_key);
+  return TRUE;
+}
+
+DWORD amps_tcps_get_thread_key(void)
+{
+  InitOnceExecuteOnce(&ampsTcpsThreadKeyOnce, amps_tcps_init_key, NULL, NULL);
+  return ampsTcpsThreadKey;
+}
+
+void amps_tcps_set_thread_key(void* pVal)
+{
+  InitOnceExecuteOnce(&ampsTcpsThreadKeyOnce, amps_tcps_init_key, NULL, NULL);
+  TlsSetValue(ampsTcpsThreadKey, pVal);
+}
+
 int tcpsThreadTimeoutMillis = 10000;
+
 #define AMPS_JOIN_DECLARE() \
   DWORD tid = (DWORD)0; \
   HANDLE tidH = (HANDLE)0
@@ -92,51 +147,90 @@ int tcpsThreadTimeoutMillis = 10000;
   { \
     if (tid != GetCurrentThreadId()) \
     { \
-      if(WAIT_TIMEOUT == WaitForSingleObject(tidH, tcpsThreadTimeoutMillis)) \
-      { \
-        TerminateThread(tidH, -1); \
-      } \
+      AMPS_INC_THREAD_COUNT(&amps_thread_join_count); \
+      WaitForSingleObject(tidH, tcpsThreadTimeoutMillis); \
+      CloseHandle(tidH); \
+    } \
+    else \
+    { \
+      amps_tcps_set_thread_key((void*)tidH); \
     } \
-    CloseHandle(tidH); \
   }
 #define AMPS_SLEEP(x) \
   Sleep(x)
 #define SHUT_RDWR SD_BOTH
 #else
-#define GET_ERRNO (errno)
-#define SOCK_ERRORCODE(x) x
-#include <pthread.h>
+pthread_once_t ampsTcpsThreadKeyOnce = PTHREAD_ONCE_INIT;
+pthread_key_t ampsTcpsThreadKey;
 
-static pthread_mutexattr_t _mutexattr_recursive;
-#define AMPS_INITLOCK(x) { \
-    pthread_mutexattr_init(&_mutexattr_recursive); \
-    pthread_mutexattr_settype(&_mutexattr_recursive, PTHREAD_MUTEX_RECURSIVE);\
-    pthread_mutex_init(x, &_mutexattr_recursive); }
-#define AMPS_LOCK(x) pthread_mutex_lock(x)
-#define AMPS_SPIN_LOCK(x) amps_spin_lock_counted(x)
-#define AMPS_SPIN_LOCK_UNLIMITED(x) amps_spin_lock_unlimited(x)
+void amps_tcps_detach_thread(void* vpSelf)
+{
+  pthread_detach((pthread_t)vpSelf);
+  AMPS_INC_THREAD_COUNT(&amps_thread_detach_count);
+}
+
+void amps_tcps_delete_thread_key(void)
+{
+  pthread_key_delete(ampsTcpsThreadKey);
+}
+
+void amps_tcps_init_thread_key()
+{
+  pthread_key_create(&ampsTcpsThreadKey, amps_tcps_detach_thread);
+  atexit(amps_tcps_delete_thread_key);
+}
+
+void amps_tcps_set_thread_key(void* pVal)
+{
+  (void) pthread_once(&ampsTcpsThreadKeyOnce, amps_tcps_init_thread_key);
+  pthread_setspecific(ampsTcpsThreadKey, pVal);
+}
 
-#define AMPS_UNLOCK(x) pthread_mutex_unlock(x)
-#define AMPS_KILLLOCK(x) pthread_mutex_destroy(x)
 #define AMPS_JOIN_DECLARE() \
   pthread_t tid = (pthread_t)0;
 
 #if __STDC_VERSION__ >= 201100
 #define AMPS_JOIN(x) \
   tid = atomic_exchange((&x), (pthread_t)0); \
-  if(tid!=(pthread_t)0 && tid!=pthread_self()) \
+  if(tid != (pthread_t)0) \
   { \
-    pthread_join(tid, NULL); \
+    if(tid != pthread_self()) \
+    { \
+      AMPS_INC_THREAD_COUNT(&amps_thread_join_count); \
+      pthread_join(tid, NULL); \
+    } \
+    else \
+    { \
+      amps_tcps_set_thread_key((void*)tid); \
+    } \
+  } \
+  else \
+  { \
+    /* Give recv thread a chance to exit in case it hasn't yet */ \
+    usleep(10); \
   }
 #else
 #define AMPS_JOIN(x) \
   tid = AMPS_FETCH_ADD(&x, (pthread_t)0); \
-  if(tid!=(pthread_t)0 && tid!=pthread_self()) \
+  if(tid != (pthread_t)0) \
   { \
-    if(__sync_bool_compare_and_swap(&x, tid, (pthread_t)0)) \
+    if(__sync_bool_compare_and_swap(&x, tid, 0)) \
     { \
-      pthread_join(tid, NULL); \
+      if(tid != pthread_self()) \
+      { \
+        AMPS_INC_THREAD_COUNT(&amps_thread_join_count); \
+        pthread_join(tid, NULL); \
+      } \
+      else \
+      { \
+        amps_tcps_set_thread_key((void*)tid); \
+      } \
     } \
+  } \
+  else \
+  { \
+    /* Give recv thread a chance to exit in case it hasn't yet */ \
+    usleep(10); \
   }
 #endif
 
@@ -904,6 +998,7 @@ amps_result amps_tcps_connect(amps_handle transport, const amps_char* address)
    * important to do it in two steps, since we use me->thread as a poor-man's cancellation mechanism */
   if (me->threadH)
   {
+    AMPS_INC_THREAD_COUNT(&amps_thread_create_count);
     ResumeThread(me->threadH);
   }
   else
@@ -926,6 +1021,7 @@ amps_result amps_tcps_connect(amps_handle transport, const amps_char* address)
     result = AMPS_E_MEMORY;
     goto error;
   }
+  AMPS_INC_THREAD_COUNT(&amps_thread_create_count);
 #endif
   for (i = 0; i < AMPS_THREAD_START_TIMEOUT && me->threadCreatedCallbackResult == -1; ++i)
   {
@@ -941,6 +1037,7 @@ amps_result amps_tcps_connect(amps_handle transport, const amps_char* address)
   {
     fd = AMPS_IEX_GET(&me->fd, AMPS_INVALID_SOCKET);
     ssl = (_amps_SSL*)AMPS_IEX_GET(&me->ssl, 0);
+    AMPS_JOIN(me->thread);
     amps_tcps_set_error(me, "Thread creation callback failed");
   }
 
@@ -1249,23 +1346,27 @@ amps_result amps_tcps_handle_disconnect(
     goto error;
   }
 
-#ifndef _WIN32
+#ifdef _WIN32
+  HANDLE tidH = (AMPS_CURRENT_THREAD() == me->thread) ? me->threadH : NULL;
+#else
   pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancelState);
+  void* vpTid = (void*)(pthread_self());
 #endif
   /* Call the disconect handler. */
   result = me->disconnectHandler(me, me->disconnectHandlerUserData);
-#ifndef _WIN32
-  pthread_setcancelstate(cancelState, &unusedCancelState);
-#endif
   if (result == AMPS_E_OK)
   {
-    result = AMPS_E_RETRY;
+#ifdef _WIN32
+    if (tidH)
+    {
+      amps_tcps_set_thread_key(tidH);
+    }
+#else
+    amps_tcps_set_thread_key(vpTid);
+#endif
   }
 
 error:
-#ifndef _WIN32
-  pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancelState);
-#endif
   AMPS_UNLOCK(&me->lock);
 #ifndef _WIN32
   pthread_cleanup_pop(0);
@@ -1503,12 +1604,12 @@ int amps_tcps_locked_read(amps_tcps_t* me_,
 #ifdef _WIN32
 DWORD amps_tcps_threaded_reader(void* userData)
 {
-  DWORD self = GetCurrentThreadId();
-  HANDLE selfH = GetCurrentThread();
+  AMPS_THREAD_ID tid = AMPS_CURRENT_THREAD();
+  HANDLE tidH = GetCurrentThread();
   amps_tcps_t* me = (amps_tcps_t*)userData;
   if (me->threadCreatedCallback)
   {
-    amps_result result = me->threadCreatedCallback(selfH,
+    amps_result result = me->threadCreatedCallback(tidH,
                                                    me->threadCreatedCallbackUserData);
     AMPS_IEX(&me->threadCreatedCallbackResult, (long)result);
     if (result != AMPS_E_OK)
@@ -1525,8 +1626,9 @@ void* amps_tcps_threaded_reader(void* userData)
 {
   int unusedCancelState = 0;
   amps_tcps_t* me = (amps_tcps_t*)userData;
+  AMPS_THREAD_ID tid = AMPS_CURRENT_THREAD();
   /* Wait for pthread_create to set me->thread */
-  while (me->thread != pthread_self()
+  while (me->thread != tid
          && !me->disconnecting
          && !me->destroying)
   {
@@ -1547,17 +1649,18 @@ void* amps_tcps_threaded_reader(void* userData)
     AMPS_IEX(&me->threadCreatedCallbackResult, (long)AMPS_E_OK);
   }
 #endif
-  unsigned char* buffer, *newBuffer, *end, *readPoint, *parsePoint;
+  unsigned char* buffer = 0, *newBuffer = 0, *end = 0, *readPoint = 0;
+  unsigned char* parsePoint = 0;
 
-  unsigned int msglenN;
-  unsigned long msglen, currentPosition, bytesRead = 0;
-  int received;
+  unsigned int msglenN = 0;
+  unsigned long msglen = 0, currentPosition = 0, bytesRead = 0;
+  int received = 0;
   int cancelState = 0;
   const size_t BUFFER_SIZE = 16 * 1024;
   const unsigned MAX_MESSAGE_SIZE = 1024 * 1024 * 1024;
   amps_uint64_t lastReadTime = 0;
   amps_uint64_t lastIdleTime = 0;
-  amps_handle   message;
+  amps_handle   message = 0;
 
   /* capture the connection version we are using now. */
   unsigned connectionVersion = me->connectionVersion;
@@ -1757,33 +1860,44 @@ cleanup:
 #endif
   amps_message_destroy(message);
   free(buffer);
-  if (me->destroying)
-  {
-    return 0;
-  }
   // If exiting as the reader thread, clear me->thread
   // Unless me-thread is 0, we're not getting joined, so detach
-  AMPS_THREAD_ID tid = AMPS_CURRENT_THREAD();
   if (me->threadExitCallback)
   {
     me->threadExitCallback(tid, me->threadExitCallbackUserData);
   }
 #if __STDC_VERSION__ >= 201100
-  if (atomic_compare_exchange_strong(&(me->thread), &tid, 0))
+  AMPS_THREAD_ID mytid = tid;
+  bool swapped = atomic_compare_exchange_strong(&(me->thread), &tid, 0);
+  if (swapped || me->thread != 0)
 #elif defined(_WIN32)
+  // This returns the initial value of me->thread
   if (InterlockedCompareExchange((volatile unsigned int*)(&(me->thread)),
-                                 (unsigned int)tid, (unsigned int)0))
+                                 (unsigned int)tid, (unsigned int)0) != 0)
 #else
+  AMPS_THREAD_ID mytid = tid;
   int swapped = (int)__sync_bool_compare_and_swap(&(me->thread), tid, 0);
   if (swapped || me->thread != 0)
 #endif
   {
+    AMPS_INC_THREAD_COUNT(&amps_thread_detach_count);
 #ifdef _WIN32
     CloseHandle((HANDLE)(AMPS_IEX(&(me->threadH), 0)));
 #else
-    pthread_detach(tid);
+    pthread_detach(mytid);
 #endif
+    amps_tcps_set_thread_key(NULL);
   }
+#ifdef _WIN32
+  else
+  {
+    tidH = TlsGetValue(amps_tcps_get_thread_key());
+    if (tidH != NULL)
+    {
+      CloseHandle(tidH);
+    }
+  }
+#endif
 
   return 0;
 }
@@ -1798,6 +1912,12 @@ amps_tcps_attempt_reconnect(amps_handle transport, unsigned version)
     version = me->connectionVersion;
   }
   res = amps_tcps_handle_disconnect(me, version);
+  if (res == AMPS_E_OK)
+  {
+    // We don't want non-receive threads detaching
+    amps_tcps_set_thread_key(NULL);
+    res = AMPS_E_RETRY;
+  }
   return res;
 }
 

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/src/unix.c

@@ -42,8 +42,42 @@ static pthread_mutexattr_t _mutexattr_recursive;
 
 #define AMPS_UNLOCK(x) pthread_mutex_unlock(x)
 #define AMPS_KILLLOCK(x) pthread_mutex_destroy(x)
+
+#ifdef AMPS_CPP_COUNT_THREADS
+#define AMPS_INC_THREAD_COUNT(x) AMPS_FETCH_ADD(x, 1)
+#else
+#define AMPS_INC_THREAD_COUNT(x)
+#endif
+
+pthread_once_t ampsUnixThreadKeyOnce = PTHREAD_ONCE_INIT;
+pthread_key_t ampsUnixThreadKey;
+
+void amps_unix_detach_thread(void* vpSelf)
+{
+  pthread_detach((pthread_t)vpSelf);
+  AMPS_INC_THREAD_COUNT(&amps_thread_detach_count);
+}
+
+void amps_unix_delete_thread_key(void)
+{
+  pthread_key_delete(ampsUnixThreadKey);
+}
+
+void amps_unix_init_thread_key()
+{
+  pthread_key_create(&ampsUnixThreadKey, amps_unix_detach_thread);
+  atexit(amps_unix_delete_thread_key);
+}
+
+void amps_unix_set_thread_key(void* pVal)
+{
+  (void) pthread_once(&ampsUnixThreadKeyOnce, amps_unix_init_thread_key);
+  pthread_setspecific(ampsUnixThreadKey, pVal);
+}
+
 #if __STDC_VERSION__ >= 201100
 #include <stdatomic.h>
+#include <stdbool.h>
 #define AMPS_IEX(ptr, value) atomic_exchange_explicit((ptr), (value), memory_order_acq_rel)
 #define AMPS_IEX_GET(ptr, value) atomic_exchange_explicit((ptr), (value), memory_order_acq_rel)
 #define AMPS_IEX_LONG(ptr, value) atomic_exchange_explicit((ptr), (value), memory_order_acq_rel)
@@ -51,9 +85,22 @@ static pthread_mutexattr_t _mutexattr_recursive;
 #define AMPS_FETCH_SUB(ptr, value) atomic_fetch_sub_explicit((ptr), (value), memory_order_acq_rel)
 #define AMPS_JOIN(x) \
   tid = atomic_exchange((&x), (pthread_t)0); \
-  if(tid!=(pthread_t)0 && tid!=pthread_self()) \
+  if(tid != (pthread_t)0) \
+  { \
+    if(tid != pthread_self()) \
+    { \
+      AMPS_INC_THREAD_COUNT(&amps_thread_join_count); \
+      pthread_join(tid, NULL); \
+    } \
+    else \
+    { \
+      amps_unix_set_thread_key((void*)tid); \
+    } \
+  } \
+  else \
   { \
-    pthread_join(tid, NULL); \
+    /* Give recv thread a chance to exit in case it hasn't yet */ \
+    usleep(10); \
   }
 #else
 #define AMPS_IEX(ptr, value) (void)__sync_lock_test_and_set((ptr), (value))
@@ -64,12 +111,25 @@ static pthread_mutexattr_t _mutexattr_recursive;
 
 #define AMPS_JOIN(x) \
   tid = AMPS_FETCH_ADD(&x, (pthread_t)0); \
-  if(tid!=(pthread_t)0 && tid!=pthread_self()) \
+  if(tid != (pthread_t)0) \
   { \
-    if(__sync_bool_compare_and_swap(&x, tid, (pthread_t)0)) \
+    if(__sync_bool_compare_and_swap(&x, tid, 0)) \
     { \
-      pthread_join(tid, NULL); \
+      if(tid != pthread_self()) \
+      { \
+        AMPS_INC_THREAD_COUNT(&amps_thread_join_count); \
+        pthread_join(tid, NULL); \
+      } \
+      else \
+      { \
+        amps_unix_set_thread_key((void*)tid); \
+      } \
     } \
+  } \
+  else \
+  { \
+    /* Give recv thread a chance to exit in case it hasn't yet */ \
+    usleep(10); \
   }
 #endif
 #define AMPS_JOIN_DECLARE() \
@@ -425,6 +485,7 @@ amps_result amps_unix_connect(amps_handle transport, amps_char* address)
     amps_unix_set_error(me, "Failed to create thread for receive");
     result = AMPS_E_MEMORY; goto error;
   }
+  AMPS_INC_THREAD_COUNT(&amps_thread_create_count);
   for (int i = 0; i < AMPS_THREAD_START_TIMEOUT && me->threadCreatedCallbackResult == -1; ++i)
   {
     AMPS_SLEEP(4);
@@ -444,7 +505,7 @@ error:
       shutdown(fd, SHUT_RDWR);
       closesocket(fd);
     }
-    me->thread = (pthread_t)0;
+    AMPS_JOIN(me->thread);
   }
   AMPS_UNLOCK(&me->lock);
   pthread_cleanup_pop(0);
@@ -570,12 +631,12 @@ amps_result amps_unix_handle_disconnect(
   }
 
   pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancelState);
-  /* Call the disconect handler. */
+  /* Call the disconnect handler. */
   result = me->disconnectHandler(me, me->disconnectHandlerUserData);
   pthread_setcancelstate(cancelState, &unusedCancelState);
   if (result == AMPS_E_OK)
   {
-    result = AMPS_E_RETRY;
+    amps_unix_set_thread_key((void*)pthread_self());
   }
 error:
   pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancelState);
@@ -692,24 +753,25 @@ void* amps_unix_threaded_reader(void* userData)
 {
   int unusedCancelState = 0;
   amps_unix_t* me = (amps_unix_t*)userData;
-  unsigned char* buffer, *newBuffer, *end, *readPoint, *parsePoint;
-  unsigned int msglenN;
-  unsigned long msglen, currentPosition, bytesRead = 0;
-  ssize_t received;
-  ssize_t recv_result;
+  pthread_t tid = pthread_self();
+  unsigned char* buffer = 0, *newBuffer = 0, *end = 0, *readPoint = 0, *parsePoint = 0;
+  unsigned int msglenN = 0;
+  unsigned long msglen = 0, currentPosition = 0, bytesRead = 0;
+  ssize_t received = 0;
+  ssize_t recv_result = 0;
   int cancelState = 0;
   const size_t BUFFER_SIZE = 16 * 1024;
   const unsigned MAX_MESSAGE_SIZE = 1024 * 1024 * 1024;
   amps_uint64_t lastReadTime = 0;
   amps_uint64_t lastIdleTime = 0;
-  amps_handle   message;
+  amps_handle   message = 0;
 
   /* capture the connection version we are using now. */
   unsigned connectionVersion = me->connectionVersion;
   AMPS_SOCKET fd = me->fd;
 
   /* Wait for pthread_create to set me->thread */
-  while (me->thread != pthread_self()
+  while (me->thread != tid
          && !me->disconnecting
          && !me->destroying)
   {
@@ -894,29 +956,23 @@ cleanup:
   pthread_cleanup_pop(0);
   amps_message_destroy(message);
   free(buffer);
-  if (me->destroying)
-  {
-    return 0;
-  }
   // If exiting as the reader thread, clear me->thread
   // Unless me-thread is 0, we're not getting joined, so detach
-  pthread_t tid = pthread_self();
   if (me->threadExitCallback)
   {
     me->threadExitCallback(tid, me->threadExitCallbackUserData);
   }
+  pthread_t mytid = tid;
 #if __STDC_VERSION__ >= 201100
-  if (atomic_compare_exchange_strong(&(me->thread), &tid, (pthread_t)0))
+  bool swapped = atomic_compare_exchange_strong(&(me->thread), &tid, 0);
 #else
   int swapped = (int)__sync_bool_compare_and_swap(&(me->thread), tid, 0);
-  if (swapped || me->thread != 0)
 #endif
+  if (swapped || me->thread != 0)
   {
-    pthread_detach(tid);
-  }
-  else if (me->thread != 0)
-  {
-    pthread_detach(tid);
+    AMPS_INC_THREAD_COUNT(&amps_thread_detach_count);
+    pthread_detach(mytid);
+    amps_unix_set_thread_key(NULL);
   }
   return 0;
 }
@@ -931,6 +987,11 @@ amps_unix_attempt_reconnect(amps_handle transport, unsigned version)
     version = me->connectionVersion;
   }
   res = amps_unix_handle_disconnect(transport, version);
+  if (res == AMPS_E_OK)
+  {
+    amps_unix_set_thread_key(NULL);
+    res = AMPS_E_RETRY;
+  }
   return res;
 }
 

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/exponentialdelaystrategy.cpp

@@ -84,35 +84,29 @@ namespace ampspy
       NONE;
     }
 
-    static const char* docstring =
-      "ExponentialDelayStrategy is an implementation that exponentially\n"
-      "backs off when reconnecting to the same server, with a maximum\n"
-      "time to retry before it gives up entirely.\n\n"
-      "By default, an ExponentialDelayStrategy has an initial delay of\n"
-      "200 ms, a maximum delay of  20 seconds, a backoff exponent of\n"
-      "2.0, and has no limit to the amount of time to retry the connection.\n"
-      "\n"
-      "Constructor parameters:\n\n"
-      ":param initial_delay:      The time (in milliseconds) to wait before\n"
-      "                           reconnecting to a server for the first\n"
-      "                           time after a failed connection.\n\n"
-      ":param maximum_delay:      The maximum time to wait for any reconnect\n"
-      "                           attempt (milliseconds). Exponential\n"
-      "                           backoff will not exceed this maximum.\n\n"
-      ":param backoff_exponent:   The exponent to use for calculating the\n"
-      "                           next delay time. For example, if the\n"
-      "                           initial time is 200ms and the exponent\n"
-      "                           is 2.0, the next delay will be 400ms,\n"
-      "                           then 800ms, etc.\n\n"
-      ":param maximum_retry_time: The maximum time (milliseconds) to allow\n"
-      "                           reconnect attempts to continue without\n"
-      "                           a successful connection, before \"giving\n"
-      "                           up\" and abandoning the connection attempt.\n\n"
-      ":param jitter:             The amount of 'jitter' to apply when\n"
-      "                           calculating a delay time, measured in multiples\n"
-      "                           of the initial delay. Jitter is used to reduce\n"
-      "                           the number of simultaneous reconnects that may\n"
-      "                           be issued from multiple clients.\n\n\n";
+    static const char* docstring = R"docstring(ExponentialDelayStrategy(initial_delay=200, maximum_delay=20000, backoff_exponent=2.0, maximum_retry_time=0, jitter=1.0)
+    ``ExponentialDelayStrategy`` is an implementation that exponentially backs off when reconnecting to 
+    the same server, with a maximum time to retry before it gives up entirely.
+  
+    By default, an ``ExponentialDelayStrategy`` has an initial delay of 200 ms, a maximum delay of 20 seconds, 
+    a backoff exponent of 2.0, and has no limit to the amount of time to retry the connection.
+
+    **Constructor Arguments:**
+
+    :param initial_delay: The time (in milliseconds) to wait before reconnecting to a server for the first
+                          time after a failed connection.
+    :param maximum_delay: The maximum time to wait for any reconnect attempt (milliseconds). 
+                          Exponential backoff will not exceed this maximum.
+    :param backoff_exponent: The exponent to use for calculating the next delay time. For example, if the
+                             initial time is 200ms and the exponent is 2.0, the next delay will be 400ms,
+                             then 800ms, etc.
+    :param maximum_retry_time: The maximum time (milliseconds) to allow reconnect attempts to continue 
+                               without a successful connection, before 'giving up' and abandoning the 
+                               connection attempt.
+    :param jitter: The amount of 'jitter' to apply when calculating a delay time, measured in multiples
+                   of the initial delay. Jitter is used to reduce the number of simultaneous reconnects 
+                   that may be issued from multiple clients.
+    )docstring";
 
     void add_types(PyObject* module_)
     {

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/fixeddelaystrategy.cpp

@@ -78,18 +78,19 @@ namespace ampspy
       NONE;
     }
 
-    static const char* docstring =
-      "FixedDelayStrategy is a reconnect delay strategy implementation that\n"
-      "waits a fixed amount of time before retrying a connection.\n"
-      "\n"
-      "By default, a FixedDelayStrategy waits for 200ms between connection attempts\n"
-      "and does not have a maximum timeout.\n\n"
-      "Constructor parameters:\n\n"
-      ":param initial_delay:      The time (in milliseconds) to wait before\n"
-      "                           reconnecting to a server for the first\n"
-      "                           time after a failed connection.\n\n"
-      ":param maximum:            The maximum time (in milliseconds) to keep\n"
-      "                           retrying before giving up.\n";
+    static const char* docstring = R"docstring(FixedDelayStrategy(initial_delay, maximum)
+    ``FixedDelayStrategy`` is a reconnect delay strategy implementation that waits a
+    fixed amount of time before retrying a connection.
+    
+    By default, a ``FixedDelayStrategy`` waits for 200ms between connection attempts
+    and does not have a maximum timeout.
+
+    **Constructor Arguments:**
+    
+    :param initial_delay: The time (in milliseconds) to wait before reconnecting to a 
+                          server for the first time after a failed connection.
+    :param maximum: The maximum time (in milliseconds) to keep retrying before giving up.
+    )docstring";
 
     void add_types(PyObject* module_)
     {