bloomberg · adamncasey · May 30, 2022 · May 26, 2022
diff --git a/amqpprox_ctl/client.m.cpp b/amqpprox_ctl/client.m.cpp
@@ -29,9 +29,9 @@ int main(int argc, char *argv[])
             return 1;
         }
 
-        boost::asio::io_service ioService;
+        boost::asio::io_context ioContext;
 
-        stream_protocol::socket clientSocket(ioService);
+        stream_protocol::socket clientSocket(ioContext);
         clientSocket.connect(stream_protocol::endpoint(argv[1]));
 
         std::string allArgs{argv[2]};

diff --git a/libamqpprox/amqpprox_authcontrolcommand.cpp b/libamqpprox/amqpprox_authcontrolcommand.cpp
@@ -74,7 +74,7 @@ void AuthControlCommand::handleCommand(const std::string & /* command */,
             }
 
             serverHandle->setAuthIntercept(std::make_shared<HttpAuthIntercept>(
-                serverHandle->ioService(),
+                serverHandle->ioContext(),
                 hostname,
                 std::to_string(port),
                 target,
@@ -85,7 +85,7 @@ void AuthControlCommand::handleCommand(const std::string & /* command */,
         else if (subcommand == "ALWAYS_ALLOW") {
             serverHandle->setAuthIntercept(
                 std::make_shared<DefaultAuthIntercept>(
-                    serverHandle->ioService()));
+                    serverHandle->ioContext()));
 
             serverHandle->getAuthIntercept()->print(output);
         }

diff --git a/libamqpprox/amqpprox_authinterceptinterface.cpp b/libamqpprox/amqpprox_authinterceptinterface.cpp
@@ -22,8 +22,8 @@ namespace Bloomberg {
 namespace amqpprox {
 
 AuthInterceptInterface::AuthInterceptInterface(
-    boost::asio::io_service &ioService)
-: d_ioService(ioService)
+    boost::asio::io_context &ioContext)
+: d_ioContext(ioContext)
 {
 }
 

diff --git a/libamqpprox/amqpprox_authinterceptinterface.h b/libamqpprox/amqpprox_authinterceptinterface.h
@@ -34,7 +34,7 @@ class AuthResponse;
  */
 class AuthInterceptInterface {
   protected:
-    boost::asio::io_service &d_ioService;
+    boost::asio::io_context &d_ioContext;
 
   public:
     /**
@@ -45,7 +45,7 @@ class AuthInterceptInterface {
         ReceiveResponseCb;
 
     // CREATORS
-    explicit AuthInterceptInterface(boost::asio::io_service &ioService);
+    explicit AuthInterceptInterface(boost::asio::io_context &ioContext);
 
     virtual ~AuthInterceptInterface() = default;
 

diff --git a/libamqpprox/amqpprox_backendcontrolcommand.cpp b/libamqpprox/amqpprox_backendcontrolcommand.cpp
@@ -77,8 +77,8 @@ void BackendControlCommand::handleCommand(const std::string & /* command */,
         if (!name.empty() && !datacenter.empty() && !host.empty() && port) {
             std::string ip;
             if (!isDns) {
-                auto &ioService = controlHandle->ioService();
-                boost::asio::ip::tcp::resolver        resolver(ioService);
+                auto &ioContext = controlHandle->ioContext();
+                boost::asio::ip::tcp::resolver        resolver(ioContext);
                 boost::asio::ip::tcp::resolver::query q(host, "");
                 boost::system::error_code             ec;
                 auto it = resolver.resolve(q, ec);

diff --git a/libamqpprox/amqpprox_control.cpp b/libamqpprox/amqpprox_control.cpp
@@ -161,9 +161,9 @@ Control::Control(Server            *server,
                  const std::string &udsPath)
 : d_server_p(server)
 , d_eventSource_p(source)
-, d_ioService()
-, d_acceptor(d_ioService, stream_protocol::endpoint(udsPath))
-, d_socket(d_ioService)
+, d_ioContext()
+, d_acceptor(d_ioContext, stream_protocol::endpoint(udsPath))
+, d_socket(d_ioContext)
 {
     boost::asio::socket_base::reuse_address option(true);
     d_acceptor.set_option(option);
@@ -174,7 +174,7 @@ Control::Control(Server            *server,
 void Control::run()
 {
     try {
-        d_ioService.run();
+        d_ioContext.run();
     }
     catch (std::exception &e) {
         LOG_FATAL << "Control Thread Exception: " << e.what();
@@ -183,7 +183,7 @@ void Control::run()
 
 void Control::stop()
 {
-    d_ioService.stop();
+    d_ioContext.stop();
 }
 
 void Control::scheduleRecurringEvent(
@@ -192,7 +192,7 @@ void Control::scheduleRecurringEvent(
     const std::function<bool(Control *, Server *)> &event)
 {
     auto duration = boost::posix_time::milliseconds(intervalMs);
-    auto timer    = std::make_shared<boost::asio::deadline_timer>(d_ioService);
+    auto timer    = std::make_shared<boost::asio::deadline_timer>(d_ioContext);
     timer->expires_from_now(duration);
     timer->async_wait([this, name, intervalMs, event, timer](
                           const boost::system::error_code &ec) {
@@ -248,9 +248,9 @@ void Control::doAccept()
     });
 }
 
-boost::asio::io_service &Control::ioService()
+boost::asio::io_context &Control::ioContext()
 {
-    return d_ioService;
+    return d_ioContext;
 }
 
 }

diff --git a/libamqpprox/amqpprox_control.h b/libamqpprox/amqpprox_control.h
@@ -35,7 +35,7 @@ class Server;
 class Control {
     Server                                                *d_server_p;
     EventSource                                           *d_eventSource_p;
-    boost::asio::io_service                                d_ioService;
+    boost::asio::io_context                                d_ioContext;
     boost::asio::local::stream_protocol::acceptor          d_acceptor;
     boost::asio::local::stream_protocol::socket            d_socket;
     std::map<std::string, std::unique_ptr<ControlCommand>> d_controlCommands;
@@ -91,7 +91,7 @@ class Control {
     /**
      * \return IO service for the control thread
      */
-    boost::asio::io_service &ioService();
+    boost::asio::io_context &ioContext();
 
   private:
     void doAccept();

diff --git a/libamqpprox/amqpprox_defaultauthintercept.cpp b/libamqpprox/amqpprox_defaultauthintercept.cpp
@@ -27,8 +27,8 @@
 namespace Bloomberg {
 namespace amqpprox {
 
-DefaultAuthIntercept::DefaultAuthIntercept(boost::asio::io_service &ioService)
-: AuthInterceptInterface(ioService)
+DefaultAuthIntercept::DefaultAuthIntercept(boost::asio::io_context &ioContext)
+: AuthInterceptInterface(ioContext)
 {
 }
 
@@ -41,7 +41,7 @@ void DefaultAuthIntercept::authenticate(const authproto::AuthRequest,
         authResponseData.set_reason("Default route auth used - always allow");
         responseCb(authResponseData);
     };
-    boost::asio::post(d_ioService, cb);
+    boost::asio::post(d_ioContext, cb);
 }
 
 void DefaultAuthIntercept::print(std::ostream &os) const

diff --git a/libamqpprox/amqpprox_defaultauthintercept.h b/libamqpprox/amqpprox_defaultauthintercept.h
@@ -36,7 +36,7 @@ class AuthRequest;
 class DefaultAuthIntercept : public AuthInterceptInterface {
   public:
     // CREATORS
-    explicit DefaultAuthIntercept(boost::asio::io_service &ioService);
+    explicit DefaultAuthIntercept(boost::asio::io_context &ioContext);
 
     virtual ~DefaultAuthIntercept() override = default;
 

diff --git a/libamqpprox/amqpprox_dnshostnamemapper.cpp b/libamqpprox/amqpprox_dnshostnamemapper.cpp
@@ -37,10 +37,10 @@ DNSHostnameMapper::DNSHostnameMapper()
 }
 
 void DNSHostnameMapper::prime(
-    boost::asio::io_service                              &ioService,
+    boost::asio::io_context                              &ioContext,
     std::initializer_list<boost::asio::ip::tcp::endpoint> endpoints)
 {
-    boost::asio::ip::tcp::resolver resolver(ioService);
+    boost::asio::ip::tcp::resolver resolver(ioContext);
     for (const auto &endpoint : endpoints) {
         auto address = boost::lexical_cast<std::string>(endpoint.address());
         boost::upgrade_lock<boost::shared_mutex> lock(d_lg);

diff --git a/libamqpprox/amqpprox_dnshostnamemapper.h b/libamqpprox/amqpprox_dnshostnamemapper.h
@@ -39,10 +39,10 @@ class DNSHostnameMapper : public HostnameMapper {
 
     /**
      * \brief prime the cache of hostnames with a list of endpoints
-     * \param ioService handle to the boost asio service
+     * \param ioContext handle to the boost asio service
      * \param endpoints list of endpoints to prime the cache with
      */
-    void prime(boost::asio::io_service                              &ioService,
+    void prime(boost::asio::io_context                              &ioContext,
                std::initializer_list<boost::asio::ip::tcp::endpoint> endpoints)
         override;
 

diff --git a/libamqpprox/amqpprox_dnsresolver.cpp b/libamqpprox/amqpprox_dnsresolver.cpp
@@ -29,10 +29,10 @@ namespace amqpprox {
 
 DNSResolver::OverrideFunction DNSResolver::s_override;
 
-DNSResolver::DNSResolver(boost::asio::io_service &ioService)
-: d_ioService(ioService)
-, d_resolver(d_ioService)
-, d_timer(d_ioService)
+DNSResolver::DNSResolver(boost::asio::io_context &ioContext)
+: d_ioContext(ioContext)
+, d_resolver(d_ioContext)
+, d_timer(d_ioContext)
 , d_cacheTimeout(1000)
 , d_cacheTimerRunning(false)
 {

diff --git a/libamqpprox/amqpprox_dnsresolver.h b/libamqpprox/amqpprox_dnsresolver.h
@@ -62,7 +62,7 @@ class DNSResolver {
                                                 const std::string &)>;
 
   private:
-    boost::asio::io_service       &d_ioService;
+    boost::asio::io_context       &d_ioContext;
     boost::asio::ip::tcp::resolver d_resolver;
     boost::asio::steady_timer      d_timer;
     std::atomic<uint32_t>          d_cacheTimeout;
@@ -74,11 +74,11 @@ class DNSResolver {
 
   public:
     /**
-     * \brief Construct a resolver using io_service
+     * \brief Construct a resolver using io_context
      *
-     * This resolver will then use the passed io_service as its event loop.
+     * This resolver will then use the passed io_context as its event loop.
      */
-    explicit DNSResolver(boost::asio::io_service &ioService);
+    explicit DNSResolver(boost::asio::io_context &ioContext);
 
     ~DNSResolver();
 
@@ -192,7 +192,7 @@ void DNSResolver::resolve(std::string_view       query_host,
             boost::system::error_code ec;
             std::vector<TcpEndpoint>  result = it->second;
             auto cb = [callback, ec, result] { callback(ec, result); };
-            d_ioService.post(cb);
+            d_ioContext.post(cb);
             return;
         }
     }
@@ -203,7 +203,7 @@ void DNSResolver::resolve(std::string_view       query_host,
         LOG_TRACE << "Returning " << vec.size()
                   << " overriden values with ec = " << ec;
         auto cb = [callback, ec, vec] { callback(ec, vec); };
-        d_ioService.post(cb);
+        d_ioContext.post(cb);
 
         if (!ec) {
             setCachedResolution(host, service, std::move(vec));

diff --git a/libamqpprox/amqpprox_hostnamemapper.h b/libamqpprox/amqpprox_hostnamemapper.h
@@ -30,11 +30,11 @@ class HostnameMapper {
 
     /**
      * \brief prime the cache of hostnames with a list of endpoints
-     * \param ioService handle to the boost asio service
+     * \param ioContext handle to the boost asio service
      * \param endpoints list of endpoints to prime the cache with
      */
     virtual void
-    prime(boost::asio::io_service                              &ioService,
+    prime(boost::asio::io_context                              &ioContext,
           std::initializer_list<boost::asio::ip::tcp::endpoint> endpoint) = 0;
 
     /**

diff --git a/libamqpprox/amqpprox_httpauthintercept.cpp b/libamqpprox/amqpprox_httpauthintercept.cpp
@@ -41,13 +41,13 @@ const int TIMEOUT_SECONDS = 30;
 int       HTTP_VERSION    = 11;  // HTTP/1.1 version
 }
 
-HttpAuthIntercept::HttpAuthIntercept(boost::asio::io_service &ioService,
+HttpAuthIntercept::HttpAuthIntercept(boost::asio::io_context &ioContext,
                                      const std::string       &hostname,
                                      const std::string       &port,
                                      const std::string       &target,
                                      DNSResolver             *dnsResolver)
-: AuthInterceptInterface(ioService)
-, d_ioService(ioService)
+: AuthInterceptInterface(ioContext)
+, d_ioContext(ioContext)
 , d_hostname(hostname)
 , d_port(port)
 , d_target(target)
@@ -115,7 +115,7 @@ void HttpAuthIntercept::onResolve(
 
     std::shared_ptr<beast::tcp_stream> stream =
         std::make_shared<beast::tcp_stream>(
-            boost::asio::make_strand(d_ioService));
+            boost::asio::make_strand(d_ioContext));
     // Set a timeout on the operation
     stream->expires_after(std::chrono::seconds(TIMEOUT_SECONDS));
 

diff --git a/libamqpprox/amqpprox_httpauthintercept.h b/libamqpprox/amqpprox_httpauthintercept.h
@@ -36,7 +36,7 @@ class HttpAuthIntercept
   public std::enable_shared_from_this<HttpAuthIntercept> {
     using tcp = boost::asio::ip::tcp;
 
-    boost::asio::io_service &d_ioService;
+    boost::asio::io_context &d_ioContext;
     std::string              d_hostname;
     std::string              d_port;
     std::string              d_target;
@@ -70,7 +70,7 @@ class HttpAuthIntercept
 
   public:
     // CREATORS
-    HttpAuthIntercept(boost::asio::io_service &ioService,
+    HttpAuthIntercept(boost::asio::io_context &ioContext,
                       const std::string       &hostname,
                       const std::string       &port,
                       const std::string       &target,

diff --git a/libamqpprox/amqpprox_maphostnamecontrolcommand.cpp b/libamqpprox/amqpprox_maphostnamecontrolcommand.cpp
@@ -62,7 +62,7 @@ void MapHostnameControlCommand::handleCommand(
     serverHandle->setHostnameMapper(m);
     serverHandle->visitSessions(
         [&m, controlHandle](const std::shared_ptr<Session> &s) {
-            s->state().setHostnameMapper(controlHandle->ioService(), m);
+            s->state().setHostnameMapper(controlHandle->ioContext(), m);
         });
 
     outputFunctor("Hostname mapper set for all current sessions.\n", true);

diff --git a/libamqpprox/amqpprox_maybesecuresocketadaptor.h b/libamqpprox/amqpprox_maybesecuresocketadaptor.h
@@ -41,7 +41,7 @@ class MaybeSecureSocketAdaptor {
     using endpoint    = boost::asio::ip::tcp::endpoint;
     using handshake_type = boost::asio::ssl::stream_base::handshake_type;
 
-    boost::asio::io_service                               &d_ioService;
+    boost::asio::io_context                               &d_ioService;
     std::optional<std::reference_wrapper<SocketIntercept>> d_intercept;
     std::unique_ptr<stream_type>                           d_socket;
     bool                                                   d_secured;
@@ -53,7 +53,7 @@ class MaybeSecureSocketAdaptor {
     typedef typename stream_type::executor_type executor_type;
 
 #ifdef SOCKET_TESTING
-    MaybeSecureSocketAdaptor(boost::asio::io_service &ioService,
+    MaybeSecureSocketAdaptor(boost::asio::io_context &ioService,
                              SocketIntercept         &intercept,
                              bool                     secured)
     : d_ioService(ioService)
@@ -67,7 +67,7 @@ class MaybeSecureSocketAdaptor {
     }
 #endif
 
-    MaybeSecureSocketAdaptor(boost::asio::io_service   &ioService,
+    MaybeSecureSocketAdaptor(boost::asio::io_context   &ioService,
                              boost::asio::ssl::context &context,
                              bool                       secured)
     : d_ioService(ioService)