What is keep_alive_timeout_sec ?

[amitguptaRean]

Please refer to socket options that are used in mqttClient->NewConnection (Refer to code snippet below)
What does it do ?
How does it differs from keep_alive_interval ?

socketOptions.connect_timeout_ms = 3000;
socketOptions.domain = AWS_SOCKET_IPV4;
socketOptions.type = AWS_SOCKET_STREAM;
socketOptions.keep_alive_interval_sec = this->mqttConfiguration.keep_alive_interval_sec; //30
**socketOptions.keep_alive_timeout_sec = this->mqttConfiguration.keep_alive_interval_sec; //30**
socketOptions.keepalive = true;

///*
	// * Now create a connection object. Note: This type is move only
	// * and its underlying memory is managed by the client.
	// */
	mqttConnection = mqttClient->NewConnection(endpoint.c_str(), port, socketOptions, connectionOptions);

	if (!*mqttConnection)
	{
		fprintf(stderr, "MQTT Connection Creation failed with error %s\n", ErrorDebugString(mqttConnection->LastError()));
		return MQTT_CONNECTION_CREATION_FAILED;
	}

/*
	 * Connect -> Persistent session
	 When a client requests the server to hold session data, the client is responsible for storing the following information:
	 All messages in a QoS 1 or 2 flow, that are not yet confirmed by the broker.
	 All QoS 2 messages received from the broker that are not yet completely acknowledged.
	*/
	if (!mqttConnection->Connect(clientId.c_str(), false, mqttConfiguration.keep_alive_interval_sec))
	{
		fprintf(stderr, "MQTT Connection failed with error %s\n", ErrorDebugString(mqttConnection->LastError()));
		return FAILURE_CONNECT;
	}

[justinboswell]

The keep_alive_timeout_sec corresponds to the TCP_KEEPIDLE (see: http://man7.org/linux/man-pages/man7/tcp.7.html) socket option. It is the amount of time the socket must be idle before a keepalive packet will be sent, not to exceed the TCP_KEEPINTVL value (which is keep_alive_interval_sec). These are TCP socket options, not at all related to MQTT keepalive.

[ravichandhraRean]

Hi @justinboswell

   **tcp_keepalive_intvl** (integer; default: 75; since Linux 2.4)
          The number of seconds between TCP keep-alive probes.

   **tcp_keepalive_probes** (integer; default: 9; since Linux 2.2)
          The maximum number of TCP keep-alive probes to send before
          giving up and killing the connection if no response is
          obtained from the other end.

   **tcp_keepalive_time** (integer; default: 7200; since Linux 2.2)
          The number of seconds a connection needs to be idle before TCP
          begins sending out keep-alive probes.  Keep-alives are sent
          only when the SO_KEEPALIVE socket option is enabled.  The
          default value is 7200 seconds (2 hours).  An idle connection
          is terminated after approximately an additional 11 minutes (9
          probes an interval of 75 seconds apart) when keep-alive is
          enabled.

          Note that underlying connection tracking mechanisms and
          application timeouts may be much shorter.

are you saying?
keep_alive_interval_sec is corresponds to tcp_keepalive_intvl
keep_alive_timeout_sec is corresponds to tcp_keepalive_time

according to this document default value of tcp_keepalive_intvl is 72 sec and tcp_keepalive_time is 7200 sec .

But you are suggesting keep_alive_timeout_sec not to exceed the keep_alive_interval_sec ?

1. Can you please specify the details how to use this with example values.

socketOptions.connect_timeout_ms = 3000;
socketOptions.domain = AWS_SOCKET_IPV4;
socketOptions.type = AWS_SOCKET_STREAM;
socketOptions.keep_alive_interval_sec = 0;
**socketOptions.keep_alive_timeout_sec = 0;
socketOptions.keepalive = true;

2. Is there any difference between the keepAliveTime here below snippet and keep_alive_interval_sec in the socketOptions snippet above or both are same?
   bool Connect(const char *clientId, bool cleanSession, uint16_t keepAliveTime)

We are currently facing issues in mqtt connection.

Thank you.

Regards,
Ravichandhra Palla
Hitachi Vantara

[justinboswell]

You are correct, I misspoke, the interval should not exceed the timeout.

1. The code listed will use the system defaults for keepalive interval and timeout. From the documentation in aws_socket_options:

 /* Keepalive properties are TCP only.
  * Set keepalive true to periodically transmit messages for detecting a disconnected peer.
  * If interval or timeout are zero, then default values are used. */

2. The keepAlive time for MqttConnection is part of the MQTT protocol, it essentially acts as a timeout value sent to the service endpoint. If the service doesn't hear from a client within its keepAlive time, the client will be disconnected (this doesn't matter much, since the MqttConnection will immediately reconnect you). We do not currently automatically ping to prevent disconnect, but we are planning to add that in the near future, as it is a requested feature people like from Paho and similar libraries.