amps-python-client 5.3.4.2__zip → 5.3.4.4__zip

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.4}/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() \
@@ -348,7 +408,7 @@ amps_result amps_unix_connect(amps_handle transport, amps_char* address)
   {
     /* this is a reconnect */
     shutdown(fd, SHUT_RDWR);
-    closesocket(fd);
+    AMPS_CLOSESOCKET(fd);
     fd = AMPS_INVALID_SOCKET;
   }
   AMPS_JOIN(me->thread);
@@ -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);
@@ -442,9 +503,9 @@ error:
     if (fd != AMPS_INVALID_SOCKET)
     {
       shutdown(fd, SHUT_RDWR);
-      closesocket(fd);
+      AMPS_CLOSESOCKET(fd);
     }
-    me->thread = (pthread_t)0;
+    AMPS_JOIN(me->thread);
   }
   AMPS_UNLOCK(&me->lock);
   pthread_cleanup_pop(0);
@@ -488,7 +549,7 @@ void amps_unix_close(amps_handle transport)
   if (fd != AMPS_INVALID_SOCKET)
   {
     shutdown(fd, SHUT_RDWR);
-    closesocket(fd);
+    AMPS_CLOSESOCKET(fd);
   }
   AMPS_UNLOCK(&me->lock);
   pthread_cleanup_pop(0);
@@ -508,7 +569,7 @@ void amps_unix_destroy(amps_handle transport)
   if (fd != AMPS_INVALID_SOCKET)
   {
     shutdown(fd, SHUT_RDWR);
-    closesocket(fd);
+    AMPS_CLOSESOCKET(fd);
   }
 
   AMPS_UNLOCK(&me->lock);
@@ -535,7 +596,7 @@ amps_result amps_unix_handle_disconnect(
   if (fd != AMPS_INVALID_SOCKET)
   {
     shutdown(fd, SHUT_RDWR);
-    closesocket(fd);
+    AMPS_CLOSESOCKET(fd);
   }
 
   /* first let waiters know that we've failed. */
@@ -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.4}/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.4}/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_)
     {

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.4}/src/haclient.cpp

@@ -83,7 +83,7 @@ namespace ampspy
     std::string returnedStr(returnValue);
     if (returnedStr.find("tcps:") == 0)
     {
-      PyObject* initResult = ampspy::ssl_init_internal(NULL);
+      PyObject* initResult = ampspy::ampspy_ssl_init(NULL, NULL);
       if (initResult == NULL)
       {
         exc::throwError();

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.4}/src/haclient_docs.h

@@ -23,10 +23,24 @@
 //
 ////////////////////////////////////////////////////////////////////////////
 
-static const char* class_doc = R"docstring(
-AMPS HAClient Object used for highly-available client connections. Derives from :class:`Client`.
+static const char* class_doc = R"docstring(HAClient(name, publish_store=None, bookmark_store=None, no_store=False)
+AMPS ``HAClient`` Object used for highly-available client connections. Derives from :class:`Client`.
 
-Constructor arguments:
+An example of a Python client publishing a JSON message using the ``HAClient`` is listed below::
+
+    client = AMPS.HAClient("test_client")
+
+    chooser = AMPS.DefaultServerChooser()
+    chooser.add("tcp://127.0.0.1:9004/amps/json")
+    client.set_server_chooser(chooser)
+
+    try:
+      client.connect_and_logon()
+      client.publish("topic_name",'{"a":1,"b":"2"}')
+    finally:
+      client.close()
+
+**Constructor Arguments:**
 
 :param name: The unique name for this client. AMPS does not enforce
              specific restrictions on the character set used, however some protocols
@@ -40,14 +54,14 @@ Constructor arguments:
 
 
 static const char* connect_and_logon_doc = R"docstring(
-Connects and logs on using the ServerChooser you've supplied via :meth:`set_server_chooser`. Will continue
+Connects and logs on using the ``ServerChooser`` you've supplied via :meth:`set_server_chooser`. Will continue
 attempting to connect and logon to each URI returned by the ``ServerChooser`` until the connection succeeds or
 the ``ServerChooser`` returns an empty URI.
 )docstring";
 
 
 static const char* haclient_connect_doc = R"docstring(
-Not used in the HAClient; call :meth:`connect_and_logon` to connect and log on to AMPS once a server chooser is set.
+Not used in the ``HAClient``; call :meth:`connect_and_logon` to connect and log on to AMPS once a server chooser is set.
 )docstring";
 
 
@@ -91,7 +105,7 @@ Gets self's server chooser and returns it.
 static const char* set_logon_options_doc = R"docstring(set_logon_options(options)
 Sets a logon options on self.
 
-:param options: An options string to be passed to the server during logon, such as ``ack_conflation=100us``.
+:param options: An options string to be passed to the server during logon, such as ``ack_conflation=100ms``.
 :type options: string
 )docstring";
 
@@ -105,34 +119,34 @@ static const char* set_timeout_doc = R"docstring(set_timeout(timeout)
 Sets the timeout, in milliseconds, used when sending a logon command to the server.
 Default value is 10000 (10 seconds).
 
-:param timeout: The number of milliseconds to wait for a server response to logon. 0 indicates no timeout.
+:param timeout: The number of milliseconds to wait for a server response to logon. ``0`` indicates no timeout.
 )docstring";
 
 
-static const char* set_reconnect_delay_doc = R"docstring(set_reconnect_delay(reconnectDelay)
+static const char* set_reconnect_delay_doc = R"docstring(set_reconnect_delay(reconnect_delay)
 Sets the delay in milliseconds used when reconnecting, after a disconnect occurs. Calling this method
-creates and installs a new FixedDelayStrategy in this client.
+creates and installs a new :class:`FixedDelayStrategy` in this client.
 Default value is 200 (0.2 seconds).
 
-:param reconnectDelay: The number of milliseconds to wait before reconnecting, after a disconnect occurs.
+:param reconnect_delay: The number of milliseconds to wait before reconnecting, after a disconnect occurs.
 )docstring";
 
 
-static const char* set_reconnect_delay_strategy_doc = R"docstring(set_reconnect_delay_strategy(reconnectDelayStrategy)
+static const char* set_reconnect_delay_strategy_doc = R"docstring(set_reconnect_delay_strategy(reconnect_delay_strategy)
 Sets the reconnect delay strategy object used to control delay behavior
 when connecting and reconnecting to servers.
 
-:param strategy: The reconnect delay strategy object to use when connecting
-                 and reconnecting to AMPS instances. The object must have
-                 the following two methods defined:
+:param reconnect_delay_strategy: The reconnect delay strategy object to use when connecting
+                                 and reconnecting to AMPS instances. The object must have
+                                 the following two methods defined:
 
-                  get_connect_wait_duration(uri):
-                    *uri* - A string containing the next URI AMPS will connect with.
-                    *Returns* an integer representing the time in milliseconds to wait
-                    before connecting to that URI.
+                                    ``get_connect_wait_duration(uri)``:
+                                      *uri* - A string containing the next URI AMPS will connect with.
+                                      *Returns* an integer representing the time in milliseconds to wait
+                                      before connecting to that URI.
 
-                  reset():
-                    Resets the state of self after a successful connection.
+                                    ``reset()``:
+                                      Resets the state of self after a successful connection.
 )docstring";