folly: AsyncSocketException: move implementation to .cpp, refactor

Reviewed By: yfeldblum

Differential Revision: D6042832

fbshipit-source-id: c716ee672c4acfa39cab9f10f3b3f88ca770cd20

diff --git a/folly/io/async/AsyncSSLSocket.cpp b/folly/io/async/AsyncSSLSocket.cpp
index a30cc7cabf895b1bc0fca9339d1337a825115c50..1f8cd7ddea3c00d8d8e9f4fe93267d08df975374 100644 (file)
--- a/folly/io/async/AsyncSSLSocket.cpp
+++ b/folly/io/async/AsyncSSLSocket.cpp
@@ -26,6 +26,7 @@
 #include <chrono>
 
 #include <folly/Bits.h>
+#include <folly/Format.h>
 #include <folly/SocketAddress.h>
 #include <folly/SpinLock.h>
 #include <folly/io/Cursor.h>

diff --git a/folly/io/async/AsyncSocket.cpp b/folly/io/async/AsyncSocket.cpp
index abbec9b995ff8854789b7927f768832d1d9e2b18..6d32ca61063d04dc456a2b296c1a410ddc3e2b5c 100644 (file)
--- a/folly/io/async/AsyncSocket.cpp
+++ b/folly/io/async/AsyncSocket.cpp
@@ -17,6 +17,7 @@
 #include <folly/io/async/AsyncSocket.h>
 
 #include <folly/ExceptionWrapper.h>
+#include <folly/Format.h>
 #include <folly/Portability.h>
 #include <folly/SocketAddress.h>
 #include <folly/io/Cursor.h>

diff --git a/folly/io/async/AsyncSocketException.cpp b/folly/io/async/AsyncSocketException.cpp
new file mode 100644 (file)
index 0000000..af8cd44
--- /dev/null
+++ b/folly/io/async/AsyncSocketException.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2017 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "folly/io/async/AsyncSocketException.h"
+
+#include <folly/Format.h>
+#include <folly/String.h>
+
+namespace folly {
+
+/* static */ StringPiece AsyncSocketException::getExceptionTypeString(
+    AsyncSocketExceptionType type) {
+  switch (type) {
+    case UNKNOWN:
+      return "Unknown async socket exception";
+    case NOT_OPEN:
+      return "Socket not open";
+    case ALREADY_OPEN:
+      return "Socket already open";
+    case TIMED_OUT:
+      return "Timed out";
+    case END_OF_FILE:
+      return "End of file";
+    case INTERRUPTED:
+      return "Interrupted";
+    case BAD_ARGS:
+      return "Invalid arguments";
+    case CORRUPTED_DATA:
+      return "Corrupted Data";
+    case INTERNAL_ERROR:
+      return "Internal error";
+    case NOT_SUPPORTED:
+      return "Not supported";
+    case INVALID_STATE:
+      return "Invalid state";
+    case SSL_ERROR:
+      return "SSL error";
+    case COULD_NOT_BIND:
+      return "Could not bind";
+    case SASL_HANDSHAKE_TIMEOUT:
+      return "SASL handshake timeout";
+    case NETWORK_ERROR:
+      return "Network error";
+    case EARLY_DATA_REJECTED:
+      return "Early data rejected";
+    default:
+      return "(Invalid exception type)";
+  }
+}
+
+/* static */ std::string AsyncSocketException::getMessage(
+    AsyncSocketExceptionType type,
+    const std::string& message,
+    int errnoCopy) {
+  if (errnoCopy != 0) {
+    return sformat(
+        "AsyncSocketException: {}, type = {}, errno = {} ({})",
+        message,
+        getExceptionTypeString(type),
+        errnoCopy,
+        errnoStr(errnoCopy));
+  } else {
+    return sformat(
+        "AsyncSocketException: {}, type = {}",
+        message,
+        getExceptionTypeString(type));
+  }
+}
+
+} // namespace folly

diff --git a/folly/io/async/AsyncSocketException.h b/folly/io/async/AsyncSocketException.h
index 19aecd2f4d52a9255b17d451f1fddae9c21ed892..83f95ee04aa7e07ad602ea86cd9074a33c48e0b2 100644 (file)
--- a/folly/io/async/AsyncSocketException.h
+++ b/folly/io/async/AsyncSocketException.h
@@ -17,9 +17,9 @@
 #pragma once
 
 #include <stdexcept>
+#include <string>
 
-#include <folly/Format.h>
-#include <folly/io/async/DelayedDestruction.h>
+#include <folly/Range.h>
 
 namespace folly {
 
@@ -44,13 +44,13 @@ class AsyncSocketException : public std::runtime_error {
     EARLY_DATA_REJECTED = 16,
   };
 
-  AsyncSocketException(AsyncSocketExceptionType type,
-                       const std::string& message,
-                       int errno_copy = 0)
-      : std::runtime_error(
-            AsyncSocketException::getMessage(type, message, errno_copy)),
+  AsyncSocketException(
+      AsyncSocketExceptionType type,
+      const std::string& message,
+      int errnoCopy = 0)
+      : std::runtime_error(getMessage(type, message, errnoCopy)),
         type_(type),
-        errno_(errno_copy) {}
+        errno_(errnoCopy) {}
 
   /** Error code */
   AsyncSocketExceptionType type_;
@@ -58,73 +58,24 @@ class AsyncSocketException : public std::runtime_error {
   /** A copy of the errno. */
   int errno_;
 
-  AsyncSocketExceptionType getType() const noexcept { return type_; }
-  int getErrno() const noexcept { return errno_; }
+  AsyncSocketExceptionType getType() const noexcept {
+    return type_;
+  }
 
- protected:
-  /** Just like strerror_r but returns a C++ string object. */
-  static std::string strerror_s(int errno_copy) {
-    return folly::sformat("errno = {} ({})", errno_copy, strerror(errno_copy));
+  int getErrno() const noexcept {
+    return errno_;
   }
 
+ protected:
   /** get the string of exception type */
   static folly::StringPiece getExceptionTypeString(
-      AsyncSocketExceptionType type) {
-    switch (type) {
-      case UNKNOWN:
-        return "Unknown async socket exception";
-      case NOT_OPEN:
-        return "Socket not open";
-      case ALREADY_OPEN:
-        return "Socket already open";
-      case TIMED_OUT:
-        return "Timed out";
-      case END_OF_FILE:
-        return "End of file";
-      case INTERRUPTED:
-        return "Interrupted";
-      case BAD_ARGS:
-        return "Invalid arguments";
-      case CORRUPTED_DATA:
-        return "Corrupted Data";
-      case INTERNAL_ERROR:
-        return "Internal error";
-      case NOT_SUPPORTED:
-        return "Not supported";
-      case INVALID_STATE:
-        return "Invalid state";
-      case SSL_ERROR:
-        return "SSL error";
-      case COULD_NOT_BIND:
-        return "Could not bind";
-      case SASL_HANDSHAKE_TIMEOUT:
-        return "SASL handshake timeout";
-      case NETWORK_ERROR:
-        return "Network error";
-      case EARLY_DATA_REJECTED:
-        return "Early data rejected";
-      default:
-        return "(Invalid exception type)";
-    }
-  }
+      AsyncSocketExceptionType type);
 
   /** Return a message based on the input. */
-  static std::string getMessage(AsyncSocketExceptionType type,
-                                const std::string& message,
-                                int errno_copy) {
-    if (errno_copy != 0) {
-      return folly::sformat(
-          "AsyncSocketException: {}, type = {}, errno = {} ({})",
-          message,
-          AsyncSocketException::getExceptionTypeString(type),
-          errno_copy,
-          strerror(errno_copy));
-    } else {
-      return folly::sformat("AsyncSocketException: {}, type = {}",
-                            message,
-                            AsyncSocketException::getExceptionTypeString(type));
-    }
-  }
+  static std::string getMessage(
+      AsyncSocketExceptionType type,
+      const std::string& message,
+      int errnoCopy);
 };
 
 } // namespace folly

diff --git a/folly/io/async/test/AsyncUDPSocketTest.cpp b/folly/io/async/test/AsyncUDPSocketTest.cpp
index 372e4c37d8cfe5270d6e0ad3ce141d0a3d11b243..575b9ee455b9e636bf52d5b3c3b1a1c2a178aab4 100644 (file)
--- a/folly/io/async/test/AsyncUDPSocketTest.cpp
+++ b/folly/io/async/test/AsyncUDPSocketTest.cpp
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
+#include <thread>
+
+#include <folly/Conv.h>
 #include <folly/SocketAddress.h>
+#include <folly/io/IOBuf.h>
 #include <folly/io/async/AsyncTimeout.h>
 #include <folly/io/async/AsyncUDPServerSocket.h>
 #include <folly/io/async/AsyncUDPSocket.h>
 #include <folly/io/async/EventBase.h>
-
-#include <folly/io/IOBuf.h>
 #include <folly/portability/GMock.h>
 #include <folly/portability/GTest.h>
 
-#include <thread>
-
 using folly::AsyncUDPSocket;
 using folly::AsyncUDPServerSocket;
 using folly::AsyncTimeout;