Move ClientContext write behaviour into strategies

Author: igrr

libraries/ESP8266WebServer/src/ESP8266WebServer.h

@@ -125,7 +125,7 @@ template<typename T> size_t streamFile(T &file, const String& contentType){
     sendHeader("Content-Encoding", "gzip");
   }
   send(200, contentType, "");
-  return _currentClient.write(file, HTTP_DOWNLOAD_UNIT_SIZE);
+  return _currentClient.write(file);
 }
 
 protected:

libraries/ESP8266WiFi/src/WiFiClient.cpp

@@ -40,6 +40,7 @@ extern "C"
 #include "lwip/netif.h"
 #include "include/ClientContext.h"
 #include "c_types.h"
+#include "include/DataStrategyImpl.h"
 
 uint16_t WiFiClient::_localPort = 0;
 
@@ -172,35 +173,34 @@ size_t WiFiClient::write(const uint8_t *buf, size_t size)
     {
         return 0;
     }
+    BufferStrategy strategy(buf, size, _timeout);
+    return _client->write(strategy);
+}
 
-    return _client->write(reinterpret_cast<const char*>(buf), size);
+size_t WiFiClient::write(Stream& stream, size_t unused)
+{
+    return WiFiClient::write(stream);
 }
 
-size_t WiFiClient::write_P(PGM_P buf, size_t size)
+size_t WiFiClient::write(Stream& stream)
 {
-    if (!_client || !size)
+    if (!_client || !stream.available())
     {
         return 0;
     }
+    ChunkedStrategy<Stream> strategy(stream, stream.available(), _timeout);
+    return _client->write(strategy);
+}
 
-    char chunkUnit[WIFICLIENT_MAX_PACKET_SIZE + 1];
-    chunkUnit[WIFICLIENT_MAX_PACKET_SIZE] = '\0';
-    size_t remaining_size = size;
-
-    while (buf != NULL && remaining_size > 0) {
-        size_t chunkUnitLen = WIFICLIENT_MAX_PACKET_SIZE;
-
-        if (remaining_size < WIFICLIENT_MAX_PACKET_SIZE) chunkUnitLen = remaining_size;
-        // due to the memcpy signature, lots of casts are needed
-        memcpy_P((void*)chunkUnit, (PGM_VOID_P)buf, chunkUnitLen);
-
-        buf += chunkUnitLen;
-        remaining_size -= chunkUnitLen;
-
-        // write is so overloaded, had to use the cast to get it pick the right one
-        _client->write((const char*)chunkUnit, chunkUnitLen);
+size_t WiFiClient::write_P(PGM_P buf, size_t size)
+{
+    if (!_client || !size)
+    {
+        return 0;
     }
-    return size;
+    ProgmemSource ps(buf, size);
+    ChunkedStrategy<ProgmemSource> strategy(ps, size, _timeout);
+    return _client->write(strategy);
 }
 
 int WiFiClient::available()

libraries/ESP8266WiFi/src/WiFiClient.h

@@ -49,8 +49,10 @@ class WiFiClient : public Client, public SList<WiFiClient> {
   virtual size_t write(uint8_t);
   virtual size_t write(const uint8_t *buf, size_t size);
   size_t write_P(PGM_P buf, size_t size);
-  template <typename T>
-  size_t write(T& source, size_t unitSize);
+  size_t write(Stream& stream);
+
+  // This one is deprecated, use write(Stream& instead)
+  size_t write(Stream& stream, size_t unitSize) __attribute__ ((deprecated));
 
   virtual int available();
   virtual int read();
@@ -73,28 +75,6 @@ class WiFiClient : public Client, public SList<WiFiClient> {
   void setNoDelay(bool nodelay);
   static void setLocalPortStart(uint16_t port) { _localPort = port; }
 
-  template<typename T> size_t write(T &src){
-    uint8_t obuf[WIFICLIENT_MAX_PACKET_SIZE];
-    size_t doneLen = 0;
-    size_t sentLen;
-    int i;
-
-    while (src.available() > WIFICLIENT_MAX_PACKET_SIZE){
-      src.read(obuf, WIFICLIENT_MAX_PACKET_SIZE);
-      sentLen = write(obuf, WIFICLIENT_MAX_PACKET_SIZE);
-      doneLen = doneLen + sentLen;
-      if(sentLen != WIFICLIENT_MAX_PACKET_SIZE){
-        return doneLen;
-      }
-    }
-
-    uint16_t leftLen = src.available();
-    src.read(obuf, leftLen);
-    sentLen = write(obuf, leftLen);
-    doneLen = doneLen + sentLen;
-    return doneLen;
-  }
-
   friend class WiFiServer;
 
   using Print::write;
@@ -114,24 +94,4 @@ class WiFiClient : public Client, public SList<WiFiClient> {
   static uint16_t _localPort;
 };
 
-
-template <typename T>
-inline size_t WiFiClient::write(T& source, size_t unitSize) {
-  std::unique_ptr<uint8_t[]> buffer(new uint8_t[unitSize]);
-  size_t size_sent = 0;
-  while(true) {
-    size_t left = source.available();
-    if (!left)
-      break;
-    size_t will_send = (left < unitSize) ? left : unitSize;
-    source.read(buffer.get(), will_send);
-    size_t cb = write(buffer.get(), will_send);
-    size_sent += cb;
-    if (cb != will_send) {
-      break;
-    }
-  }
-  return size_sent;
-}
-
 #endif

libraries/ESP8266WiFi/src/WiFiClientSecure.cpp

@@ -39,6 +39,7 @@ extern "C"
 #include "lwip/netif.h"
 #include "include/ClientContext.h"
 #include "c_types.h"
+#include "include/DataStrategyImpl.h"
 
 #ifdef DEBUG_ESP_SSL
 #define DEBUG_SSL
@@ -468,7 +469,10 @@ extern "C" int ax_port_write(int fd, uint8_t* buffer, size_t count) {
         errno = EIO;
         return -1;
     }
-    size_t cb = _client->write((const char*) buffer, count);
+
+    // TODO: add a way to pass timeout here (e.g. through ClientContext?)
+    BufferStrategy strategy(buffer, count, 5000);
+    size_t cb = _client->write(strategy);
     if (cb != count) {
         errno = EAGAIN;
     }

libraries/ESP8266WiFi/src/include/ClientContext.h

@@ -29,15 +29,18 @@ typedef void (*discard_cb_t)(void*, ClientContext*);
 extern "C" void esp_yield();
 extern "C" void esp_schedule();
 
+#include "DataStrategy.h"
+
 class ClientContext {
     public:
         ClientContext(tcp_pcb* pcb, discard_cb_t discard_cb, void* discard_cb_arg) :
-                _pcb(pcb), _rx_buf(0), _rx_buf_offset(0), _discard_cb(discard_cb), _discard_cb_arg(discard_cb_arg), _refcnt(0), _next(0), _send_waiting(false) {
+                _pcb(pcb), _rx_buf(0), _rx_buf_offset(0), _discard_cb(discard_cb), _discard_cb_arg(discard_cb_arg), _refcnt(0), _next(0) {
             tcp_setprio(pcb, TCP_PRIO_MIN);
             tcp_arg(pcb, this);
             tcp_recv(pcb, (tcp_recv_fn) &_s_recv);
             tcp_sent(pcb, &_s_sent);
             tcp_err(pcb, &_s_error);
+            tcp_poll(pcb, &_s_poll, 1);
         }
 
         err_t abort(){
@@ -47,6 +50,7 @@ class ClientContext {
               tcp_sent(_pcb, NULL);
               tcp_recv(_pcb, NULL);
               tcp_err(_pcb, NULL);
+              tcp_poll(_pcb, NULL, 0);
               tcp_abort(_pcb);
               _pcb = 0;
           }
@@ -61,6 +65,7 @@ class ClientContext {
               tcp_sent(_pcb, NULL);
               tcp_recv(_pcb, NULL);
               tcp_err(_pcb, NULL);
+              tcp_poll(_pcb, NULL, 0);
               err = tcp_close(_pcb);
               if(err != ERR_OK) {
                   DEBUGV(":tc err %d\r\n", err);
@@ -211,40 +216,38 @@ class ClientContext {
             return _pcb->state;
         }
 
-        size_t write(const char* data, size_t size) {
-            if(!_pcb) {
-                DEBUGV(":wr !_pcb\r\n");
+        size_t getSendBufferSize()
+        {
+            if (!_pcb) {
                 return 0;
             }
+            return tcp_sndbuf(_pcb);
+        }
 
-            if(size == 0) {
-                return 0;
-            }
-
-            size_t room = tcp_sndbuf(_pcb);
-            size_t will_send = (room < size) ? room : size;
-            err_t err = tcp_write(_pcb, data, will_send, 0);
-            if(err != ERR_OK) {
-                DEBUGV(":wr !ERR_OK\r\n");
-                return 0;
+        bool write(const uint8_t* data, size_t size)
+        {
+            if (!_pcb) {
+                return false;
             }
+            err_t err = tcp_write(_pcb, data, size, 0);
+            tcp_output(_pcb);
+            return err == ERR_OK;
+        }
 
-            _size_sent = will_send;
-            DEBUGV(":wr\r\n");
-            tcp_output( _pcb );
-            _send_waiting = true;
-            delay(5000); // max send timeout
-            _send_waiting = false;
-            DEBUGV(":ww\r\n");
-            return will_send - _size_sent;
+        size_t write(DataStrategy& strategy) {
+            _strategy = &strategy;
+            auto ret = strategy.write(*this);
+            _strategy = nullptr;
+            return ret;
         }
 
     private:
 
         err_t _sent(tcp_pcb* pcb, uint16_t len) {
             DEBUGV(":sent %d\r\n", len);
-            _size_sent -= len;
-            if(_size_sent == 0 && _send_waiting) esp_schedule();
+            if (_strategy) {
+                _strategy->on_sent(*this, len);
+            }
             return ERR_OK;
         }
 
@@ -279,8 +282,6 @@ class ClientContext {
             }
 
             if(_rx_buf) {
-                // there is some unread data
-                // chain the new pbuf to the existing one
                 DEBUGV(":rch %d, %d\r\n", _rx_buf->tot_len, pb->tot_len);
                 pbuf_cat(_rx_buf, pb);
             } else {
@@ -292,18 +293,21 @@ class ClientContext {
         }
 
         void _error(err_t err) {
-            DEBUGV(":er %d %d %d\r\n", err, _size_sent, _send_waiting);
+            DEBUGV(":er %d %08x\r\n", err, (uint32_t) _strategy);
             tcp_arg(_pcb, NULL);
             tcp_sent(_pcb, NULL);
             tcp_recv(_pcb, NULL);
             tcp_err(_pcb, NULL);
             _pcb = NULL;
-            if(_size_sent && _send_waiting) {
-                esp_schedule();
+            if (_strategy) {
+                _strategy->on_error(*this);
             }
         }
 
         err_t _poll(tcp_pcb* pcb) {
+            if (_strategy) {
+                _strategy->on_poll(*this);
+            }
             return ERR_OK;
         }
 
@@ -335,8 +339,7 @@ class ClientContext {
         int _refcnt;
         ClientContext* _next;
 
-        size_t _size_sent;
-        bool _send_waiting;
+        DataStrategy* _strategy = nullptr;
 };
 
 #endif//CLIENTCONTEXT_H

libraries/ESP8266WiFi/src/include/DataStrategy.h

@@ -0,0 +1,25 @@
+/* DataStrategy.h - interface for writing data to ClientContext
+ * Copyright (c) 2016 Ivan Grokhotkov. All rights reserved.
+ * This file is distributed under MIT license.
+ */
+
+#ifndef DATASTRATEGY_H
+#define DATASTRATEGY_H
+
+
+#include "ClientContext.h"
+
+class DataStrategy
+{
+public:
+    virtual ~DataStrategy() {}
+    virtual size_t write(ClientContext& ctx) = 0;
+    virtual void on_sent(ClientContext& ctx, size_t size) = 0;
+    virtual void on_error(ClientContext& ctx) = 0;
+    virtual void on_poll(ClientContext& ctx) = 0;
+};
+
+/// in DataStrategyImpl.h
+
+
+#endif//DATASTRATEGY_H