fixed some

dayu521 · dayu521 · commit 5fd616336303 · 2024-02-17T18:43:56.000+08:00
diff --git a/src/hmemory.h b/src/hmemory.h
@@ -24,7 +24,7 @@ namespace hcpp
     class memory
     {
     public:
-        virtual awaitable<bool> wait() = 0;
+        virtual awaitable<void> wait() {co_return;}
 
         // XXX读取最大max_n的数据,放到buff中.
         virtual awaitable<std::string_view> async_load_some(std::size_t max_n = 1024 * 4) { co_return ""; }
@@ -67,11 +67,6 @@ namespace hcpp
         static void expection_impl() { throw std::runtime_error("to implement"); }
 
     public:
-        virtual awaitable<bool> wait()
-        {
-            expection_impl();
-            co_return false;
-        }
 
         // XXX读取最大max_n的数据,放到buff中.
         virtual awaitable<std::string_view> async_load_some(std::size_t max_n = 1024 * 4)
diff --git a/src/http/http_svc_keeper.cpp b/src/http/http_svc_keeper.cpp
@@ -16,15 +16,35 @@
 
 namespace hcpp
 {
+    class failed_mem : public simple_mem
+    {
+        virtual bool ok()
+        {
+            return false;
+        }
+    };
+
     http_svc_keeper::http_svc_keeper(std::shared_ptr<svc_cache> cache, std::shared_ptr<slow_dns> dns) : slow_dns_(dns), endpoint_cache_(cache)
     {
     }
 
     awaitable<std::shared_ptr<memory>> http_svc_keeper::wait(std::string svc_host, std::string svc_service)
     {
-        auto svc_endpoint = co_await endpoint_cache_->get_endpoint(svc_host, svc_service, slow_dns_);
+        if (!m_)
+        {
+            if (auto o = co_await make_socket(svc_host, svc_service); o)
+            {
+                m_ = std::make_shared<socket_memory>(std::move(*o));
+            }
+            else
+            {
+                m_ = std::make_shared<failed_mem>();
+            }
+        }
+        co_return m_;
+        // auto svc_endpoint = co_await endpoint_cache_->get_endpoint(svc_host, svc_service, slow_dns_);
 
-        co_return std::make_shared<service_worker>(svc_endpoint, svc_host, svc_service, endpoint_cache_);
+        // co_return std::make_shared<service_worker>(svc_endpoint, svc_host, svc_service, endpoint_cache_);
     }
 
     awaitable<std::shared_ptr<tunnel>> http_svc_keeper::wait_tunnel(std::string svc_host, std::string svc_service)
@@ -65,14 +85,6 @@ namespace hcpp
         }
     };
 
-    class failed_mem : public simple_mem
-    {
-        virtual bool ok()
-        {
-            return false;
-        }
-    };
-
     awaitable<void>
     svc_cache::imp::get_endpoint(const std::string &host, const std::string &service, std::shared_ptr<hcpp::slow_dns> dns, std::shared_ptr<channel> c)
     {
@@ -242,7 +254,7 @@ namespace hcpp
         }
     }
 
-    awaitable<bool> service_worker::wait()
+    awaitable<void> service_worker::wait()
     {
         co_return co_await m_->wait();
     }
diff --git a/src/http/http_svc_keeper.h b/src/http/http_svc_keeper.h
@@ -53,7 +53,7 @@ namespace hcpp
         ~service_worker();
 
     public:
-        virtual awaitable<bool> wait() override;
+        virtual awaitable<void> wait() override;
 
         virtual awaitable<std::string_view> async_load_some(std::size_t max_n) override;
         virtual awaitable<std::size_t> async_write_some(std::string_view) override;
@@ -99,6 +99,7 @@ namespace hcpp
     private:
         std::shared_ptr<slow_dns> slow_dns_;
         std::shared_ptr<svc_cache> endpoint_cache_;
+        std::shared_ptr<memory> m_;
     };
 
     class svc_cache
diff --git a/src/http/httpmsg.cpp b/src/http/httpmsg.cpp
@@ -144,7 +144,7 @@ namespace hcpp
         if (header.contains("content-length"))
         {
             std::string cl = header.at("content-length");
-            static std::regex digit(R"(0|[1-9]\d{0,10})");
+            static thread_local std::regex digit(R"(0|[1-9]\d{0,10})");
             std::smatch m;
             if (!std::regex_search(cl, m, digit))
             {
diff --git a/src/http/socket_wrap.cpp b/src/http/socket_wrap.cpp
@@ -21,10 +21,9 @@ namespace hcpp
     bool operator<(int lk, const socket_memory::mem_block &fk) { return lk < fk.begin_; }
     bool operator<(const socket_memory::mem_block &fk1, const socket_memory::mem_block &fk2) { return fk1.begin_ < fk2.begin_; }
 
-    awaitable<bool> socket_memory::wait()
+    awaitable<void> socket_memory::wait()
     {
         co_await sock_->async_wait(tcp_socket::wait_read);
-        co_return ok();
     }
 
     awaitable<std::string_view> hcpp::socket_memory::async_load_some(std::size_t max_n)
diff --git a/src/http/socket_wrap.h b/src/http/socket_wrap.h
@@ -18,7 +18,7 @@ namespace hcpp
     class socket_memory : public memory
     {
     public:
-        virtual awaitable<bool> wait() override;
+        virtual awaitable<void> wait() override;
         virtual awaitable<std::string_view> async_load_some(std::size_t max_n) override;
         virtual awaitable<std::size_t> async_write_some(std::string_view) override;
 
diff --git a/src/http/tunnel.cpp b/src/http/tunnel.cpp
@@ -31,7 +31,6 @@ namespace hcpp
         }
 
     public:
-        virtual awaitable<bool> wait();
 
         // XXX读取最大max_n的数据,放到buff中.
         virtual awaitable<std::string_view> async_load_some(std::size_t max_n = 1024 * 4 * 2);
@@ -42,14 +41,6 @@ namespace hcpp
         tcp_socket sock_;
     };
 
-    awaitable<bool> simple_tunnel_mem::wait()
-    {
-        // co_await sock_.async_wait(tcp_socket::wait_write);
-        // co_await sock_.async_wait(tcp_socket::wait_read);
-        // read_ok_ = write_ok_ = true;
-        co_return ok();
-    }
-
     awaitable<std::string_view> simple_tunnel_mem::async_load_some(std::size_t max_n)
     {
 
@@ -70,9 +61,8 @@ namespace hcpp
     awaitable<void> simple_tunnel_mem::async_write_all(std::string_view data)
     {
         auto [e, n] = co_await async_write(sock_, buffer(data), as_tuple(use_awaitable));
-        if (n == 0)
+        if (e)
         {
-            sock_.shutdown(tcp_socket::shutdown_send);
             write_ok_ = false;
         }
     }
diff --git a/src/https/ssl_socket_wrap.cpp b/src/https/ssl_socket_wrap.cpp
@@ -17,10 +17,6 @@ namespace hcpp
     bool operator<(int lk, const ssl_sock_mem::mem_block &fk) { return lk < fk.begin_; }
     bool operator<(const ssl_sock_mem::mem_block &fk1, const ssl_sock_mem::mem_block &fk2) { return fk1.begin_ < fk2.begin_; }
 
-    awaitable<bool> ssl_sock_mem::wait()
-    {
-        co_return ok();
-    }
     awaitable<std::string_view> ssl_sock_mem::async_load_some(std::size_t max_n)
     {
         std::size_t begin = write_index_;
diff --git a/src/https/ssl_socket_wrap.h b/src/https/ssl_socket_wrap.h
@@ -24,7 +24,6 @@ namespace hcpp
     class ssl_sock_mem : public memory
     {
     public:
-        virtual awaitable<bool> wait() override;
         virtual awaitable<std::string_view> async_load_some(std::size_t max_n) override;
         virtual awaitable<std::size_t> async_write_some(std::string_view) override;
 
diff --git a/src/httpserver.cpp b/src/httpserver.cpp
@@ -24,11 +24,11 @@ namespace hcpp
         {
             auto ss = client->get_memory();
             ss->reset();
-            if (!co_await ss->wait())
+            if (!ss->ok())
             {
                 break;
             }
-
+            co_await ss->wait();
             auto req = client->make_request();
             auto p1 = req.get_first_parser(ss);
 
@@ -45,7 +45,6 @@ namespace hcpp
                     else if (!req.host_.empty())
                     {
                         req.headers_.erase("proxy-connection");
-                        // req.headers_["connection"] = "Connection: keep-alive\r\n";
                         std::string req_line = req.method_str_ + " " + req.url_ + " " + req.version_ + "\r\n";
                         for (auto &&header : req.headers_)
                         {
@@ -56,6 +55,7 @@ namespace hcpp
                         auto w = co_await sk->wait(req.host_, req.port_);
 
                         log::info("http_do:请求开始\n{}{}", req.host_, req.url_);
+
                         auto start_point = std::chrono::high_resolution_clock::now();
                         co_await w->async_write_all(req_line);
                         if (req.chunk_coding_)
@@ -86,11 +86,11 @@ namespace hcpp
                                     {
                                         log::warn("不保活 {}", req.host_);
                                         w->close();
+                                        ss->close();
                                     }
                                 }
 
                                 std::string msg_header = rp.response_line_ + rp.response_header_str_;
-                                // log::error("{}响应头\n{}",req.host_,msg_header);
                                 co_await ss->async_write_all(msg_header);
                                 if (rp.chunk_coding_)
                                 {
@@ -125,11 +125,11 @@ namespace hcpp
                                 }
                                 else
                                 {
-                                    ;
+                                    log::debug("httpdo: 没有响应体");
                                 }
                                 auto end_point = std::chrono::high_resolution_clock::now();
                                 auto du = std::chrono::duration_cast<std::chrono::milliseconds>(end_point - start_point).count();
-                                log::info("http_do:请求结束\n{}{}\n间隔 {}ms ", req.host_, req.url_, du);
+                                log::error("http_do:请求结束\n{}{} 间隔 {}ms ", req.host_, req.url_, du);
                                 continue;
                             }
                         }
@@ -223,7 +223,7 @@ namespace hcpp
                     // TODO 抽象工厂方法
                     auto sk = std::make_shared<mitm_svc>();
 
-                    hsc->init_ = [&cr_ps_map,sk,cc,ca_subject](https_client &self)->awaitable<void>
+                    hsc->init_ = [&cr_ps_map, sk, cc, ca_subject](https_client &self) -> awaitable<void>
                     {
                         subject_identify si{};
                         if (auto i = cr_ps_map.find(self.host_); i != cr_ps_map.end())

Original file line number	Diff line number	Diff line change
`@@ -16,15 +16,35 @@`
`16`	`16`
`17`	`17`	`namespace hcpp`
`18`	`18`	`{`
	`19`	`+ class failed_mem : public simple_mem`
	`20`	`+ {`
	`21`	`+ virtual bool ok()`
	`22`	`+ {`
	`23`	`+ return false;`
	`24`	`+ }`
	`25`	`+ };`
	`26`	`+`
`19`	`27`	`http_svc_keeper::http_svc_keeper(std::shared_ptr<svc_cache> cache, std::shared_ptr<slow_dns> dns) : slow_dns_(dns), endpoint_cache_(cache)`
`20`	`28`	`{`
`21`	`29`	`}`
`22`	`30`
`23`	`31`	`awaitable<std::shared_ptr<memory>> http_svc_keeper::wait(std::string svc_host, std::string svc_service)`
`24`	`32`	`{`
`25`		`- auto svc_endpoint = co_await endpoint_cache_->get_endpoint(svc_host, svc_service, slow_dns_);`
	`33`	`+ if (!m_)`
	`34`	`+ {`
	`35`	`+ if (auto o = co_await make_socket(svc_host, svc_service); o)`
	`36`	`+ {`
	`37`	`+ m_ = std::make_shared<socket_memory>(std::move(*o));`
	`38`	`+ }`
	`39`	`+ else`
	`40`	`+ {`
	`41`	`+ m_ = std::make_shared<failed_mem>();`
	`42`	`+ }`
	`43`	`+ }`
	`44`	`+ co_return m_;`
	`45`	`+ // auto svc_endpoint = co_await endpoint_cache_->get_endpoint(svc_host, svc_service, slow_dns_);`
`26`	`46`
`27`		`- co_return std::make_shared<service_worker>(svc_endpoint, svc_host, svc_service, endpoint_cache_);`
	`47`	`+ // co_return std::make_shared<service_worker>(svc_endpoint, svc_host, svc_service, endpoint_cache_);`
`28`	`48`	`}`
`29`	`49`
`30`	`50`	`awaitable<std::shared_ptr<tunnel>> http_svc_keeper::wait_tunnel(std::string svc_host, std::string svc_service)`
`@@ -65,14 +85,6 @@ namespace hcpp`
`65`	`85`	`}`
`66`	`86`	`};`
`67`	`87`
`68`		`- class failed_mem : public simple_mem`
`69`		`- {`
`70`		`- virtual bool ok()`
`71`		`- {`
`72`		`- return false;`
`73`		`- }`
`74`		`- };`
`75`		`-`
`76`	`88`	`awaitable<void>`
`77`	`89`	`svc_cache::imp::get_endpoint(const std::string &host, const std::string &service, std::shared_ptr<hcpp::slow_dns> dns, std::shared_ptr<channel> c)`
`78`	`90`	`{`
`@@ -242,7 +254,7 @@ namespace hcpp`
`242`	`254`	`}`
`243`	`255`	`}`
`244`	`256`
`245`		`- awaitable<bool> service_worker::wait()`
	`257`	`+ awaitable<void> service_worker::wait()`
`246`	`258`	`{`
`247`	`259`	`co_return co_await m_->wait();`
`248`	`260`	`}`
Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ namespace hcpp`
`144`	`144`	`if (header.contains("content-length"))`
`145`	`145`	`{`
`146`	`146`	`std::string cl = header.at("content-length");`
`147`		`- static std::regex digit(R"(0\|[1-9]\d{0,10})");`
	`147`	`+ static thread_local std::regex digit(R"(0\|[1-9]\d{0,10})");`
`148`	`148`	`std::smatch m;`
`149`	`149`	`if (!std::regex_search(cl, m, digit))`
`150`	`150`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,10 +21,9 @@ namespace hcpp`
`21`	`21`	`bool operator<(int lk, const socket_memory::mem_block &fk) { return lk < fk.begin_; }`
`22`	`22`	`bool operator<(const socket_memory::mem_block &fk1, const socket_memory::mem_block &fk2) { return fk1.begin_ < fk2.begin_; }`
`23`	`23`
`24`		`- awaitable<bool> socket_memory::wait()`
	`24`	`+ awaitable<void> socket_memory::wait()`
`25`	`25`	`{`
`26`	`26`	`co_await sock_->async_wait(tcp_socket::wait_read);`
`27`		`- co_return ok();`
`28`	`27`	`}`
`29`	`28`
`30`	`29`	`awaitable<std::string_view> hcpp::socket_memory::async_load_some(std::size_t max_n)`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ namespace hcpp`
`18`	`18`	`class socket_memory : public memory`
`19`	`19`	`{`
`20`	`20`	`public:`
`21`		`- virtual awaitable<bool> wait() override;`
	`21`	`+ virtual awaitable<void> wait() override;`
`22`	`22`	`virtual awaitable<std::string_view> async_load_some(std::size_t max_n) override;`
`23`	`23`	`virtual awaitable<std::size_t> async_write_some(std::string_view) override;`
`24`	`24`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,6 @@ namespace hcpp`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public:`
`34`		`- virtual awaitable<bool> wait();`
`35`	`34`
`36`	`35`	`// XXX读取最大max_n的数据,放到buff中.`
`37`	`36`	`virtual awaitable<std::string_view> async_load_some(std::size_t max_n = 1024 * 4 * 2);`
`@@ -42,14 +41,6 @@ namespace hcpp`
`42`	`41`	`tcp_socket sock_;`
`43`	`42`	`};`
`44`	`43`
`45`		`- awaitable<bool> simple_tunnel_mem::wait()`
`46`		`- {`
`47`		`- // co_await sock_.async_wait(tcp_socket::wait_write);`
`48`		`- // co_await sock_.async_wait(tcp_socket::wait_read);`
`49`		`- // read_ok_ = write_ok_ = true;`
`50`		`- co_return ok();`
`51`		`- }`
`52`		`-`
`53`	`44`	`awaitable<std::string_view> simple_tunnel_mem::async_load_some(std::size_t max_n)`
`54`	`45`	`{`
`55`	`46`
`@@ -70,9 +61,8 @@ namespace hcpp`
`70`	`61`	`awaitable<void> simple_tunnel_mem::async_write_all(std::string_view data)`
`71`	`62`	`{`
`72`	`63`	`auto [e, n] = co_await async_write(sock_, buffer(data), as_tuple(use_awaitable));`
`73`		`- if (n == 0)`
	`64`	`+ if (e)`
`74`	`65`	`{`
`75`		`- sock_.shutdown(tcp_socket::shutdown_send);`
`76`	`66`	`write_ok_ = false;`
`77`	`67`	`}`
`78`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,6 @@ namespace hcpp`
`24`	`24`	`class ssl_sock_mem : public memory`
`25`	`25`	`{`
`26`	`26`	`public:`
`27`		`- virtual awaitable<bool> wait() override;`
`28`	`27`	`virtual awaitable<std::string_view> async_load_some(std::size_t max_n) override;`
`29`	`28`	`virtual awaitable<std::size_t> async_write_some(std::string_view) override;`
`30`	`29`
Original file line number	Diff line number	Diff line change
`@@ -24,11 +24,11 @@ namespace hcpp`
`24`	`24`	`{`
`25`	`25`	`auto ss = client->get_memory();`
`26`	`26`	`ss->reset();`
`27`		`- if (!co_await ss->wait())`
	`27`	`+ if (!ss->ok())`
`28`	`28`	`{`
`29`	`29`	`break;`
`30`	`30`	`}`
`31`		`-`
	`31`	`+ co_await ss->wait();`
`32`	`32`	`auto req = client->make_request();`
`33`	`33`	`auto p1 = req.get_first_parser(ss);`
`34`	`34`
`@@ -45,7 +45,6 @@ namespace hcpp`
`45`	`45`	`else if (!req.host_.empty())`
`46`	`46`	`{`
`47`	`47`	`req.headers_.erase("proxy-connection");`
`48`		`- // req.headers_["connection"] = "Connection: keep-alive\r\n";`
`49`	`48`	`std::string req_line = req.method_str_ + " " + req.url_ + " " + req.version_ + "\r\n";`
`50`	`49`	`for (auto &&header : req.headers_)`
`51`	`50`	`{`
`@@ -56,6 +55,7 @@ namespace hcpp`
`56`	`55`	`auto w = co_await sk->wait(req.host_, req.port_);`
`57`	`56`
`58`	`57`	`log::info("http_do:请求开始\n{}{}", req.host_, req.url_);`
	`58`	`+`
`59`	`59`	`auto start_point = std::chrono::high_resolution_clock::now();`
`60`	`60`	`co_await w->async_write_all(req_line);`
`61`	`61`	`if (req.chunk_coding_)`
`@@ -86,11 +86,11 @@ namespace hcpp`
`86`	`86`	`{`
`87`	`87`	`log::warn("不保活 {}", req.host_);`
`88`	`88`	`w->close();`
	`89`	`+ ss->close();`
`89`	`90`	`}`
`90`	`91`	`}`
`91`	`92`
`92`	`93`	`std::string msg_header = rp.response_line_ + rp.response_header_str_;`
`93`		`- // log::error("{}响应头\n{}",req.host_,msg_header);`
`94`	`94`	`co_await ss->async_write_all(msg_header);`
`95`	`95`	`if (rp.chunk_coding_)`
`96`	`96`	`{`
`@@ -125,11 +125,11 @@ namespace hcpp`
`125`	`125`	`}`
`126`	`126`	`else`
`127`	`127`	`{`
`128`		`- ;`
	`128`	`+ log::debug("httpdo: 没有响应体");`
`129`	`129`	`}`
`130`	`130`	`auto end_point = std::chrono::high_resolution_clock::now();`
`131`	`131`	`auto du = std::chrono::duration_cast<std::chrono::milliseconds>(end_point - start_point).count();`
`132`		`- log::info("http_do:请求结束\n{}{}\n间隔 {}ms ", req.host_, req.url_, du);`
	`132`	`+ log::error("http_do:请求结束\n{}{} 间隔 {}ms ", req.host_, req.url_, du);`
`133`	`133`	`continue;`
`134`	`134`	`}`
`135`	`135`	`}`
`@@ -223,7 +223,7 @@ namespace hcpp`
`223`	`223`	`// TODO 抽象工厂方法`
`224`	`224`	`auto sk = std::make_shared<mitm_svc>();`
`225`	`225`
`226`		`- hsc->init_ = [&cr_ps_map,sk,cc,ca_subject](https_client &self)->awaitable<void>`
	`226`	`+ hsc->init_ = [&cr_ps_map, sk, cc, ca_subject](https_client &self) -> awaitable<void>`
`227`	`227`	`{`
`228`	`228`	`subject_identify si{};`
`229`	`229`	`if (auto i = cr_ps_map.find(self.host_); i != cr_ps_map.end())`