Commit: 2a7cb64db6481cc02ffb97efbe3100b01faed698 - FlyingHttpServer (git)

C++ベースのLightweightなHTTPサーバー

Commit MetaInfo

• Revision: 2a7cb64db6481cc02ffb97efbe3100b01faed698 (tree)
• Time: 2013-01-20 10:51:35
• Author: Michio Hirai <smg_ykz@user...>
• Commiter: Michio Hirai

Log Message

[Function] New introduction of cm::VectorSocket class to realize gather-write operation.

Change Summary

• modified: cm/CMakeLists.txt
• modified: cm/cm_socket.cpp
• add: cm/cm_vector_socket.cpp
• modified: cm/test/cm_socket_server_client_test.cpp
• add: cm/test/cm_vector_socket_test.cpp
• add: inc/cm_io_vector.h
• modified: inc/cm_socket.h
• modified: inc/cm_socket_if.h
• modified: inc/cm_socket_mock.h
• add: inc/cm_vector_socket.h
• modified: inc/mt_auto_ptr.h
• add: inc/mt_member_detector.h
• modified: inc/mt_static_assert.h

Incremental Difference

--- a/cm/CMakeLists.txt
+++ b/cm/CMakeLists.txt
@@ -22,6 +22,7 @@ cxx_library_static(cm_socket ""
   cm_socket_server.cpp
   cm_socket_client.cpp
   cm_socket.cpp
+  cm_vector_socket.cpp
 )
 
 gmock_executable(cm_thread_test "cm_thread"
@@ -38,5 +39,9 @@ gmock_executable(cm_socket_server_test "cm_socket;cm_event"
   test/cm_socket_server_client_test.cpp
 )
 
+gmock_executable(cm_vector_socket_test "cm_socket;"
+  test/cm_vector_socket_test.cpp
+)
+
 enable_coverage()
 

--- a/cm/cm_socket.cpp
+++ b/cm/cm_socket.cpp
@@ -7,16 +7,16 @@
 namespace cm {
 
 Socket::Socket()
-    : fd_(-1), need_open_(true)
+    : fd_(-1)
 {}
 
 Socket::Socket(int fd)
-    : fd_(fd), need_open_(false)
+    : fd_(fd)
 {}
 
 Socket::~Socket()
 {
-    if ((!need_open_) && (fd_ >= 0)) {
+    if (fd_ >= 0) {
         close(fd_);
         fd_ = -1;
     }
@@ -71,6 +71,13 @@ int Socket::getFD() const
     return fd_;
 }
 
+int Socket::release()
+{
+    int fd_to_return =  fd_;
+    fd_ = -1;
+    return fd_to_return;
+}
+
 SocketIf* Socket::doClone(int fd) const
 {
     return new Socket(fd);

--- /dev/null
+++ b/cm/cm_vector_socket.cpp
@@ -0,0 +1,29 @@
+
+#include  <cassert>
+
+#include "mt_shim_clear_memory.h"
+#include "cm_vector_socket.h"
+
+namespace cm {
+
+VectorSocket::VectorSocket(int fd)
+    : fd_(fd)
+{}
+
+bool VectorSocket::writev(size_t& bytes_written, const IOVectorBase& vector, size_t skip_bytes)
+{
+    assert(fd_ >= 0);
+
+    struct iovec iovector[MAX_IOVEC_COUNT];
+
+    mt::clearMemory(iovector);
+
+    vector.setToVector(iovector);
+
+    bytes_written = ::writev(fd_, iovector, vector.getCount());
+
+    return true;
+}
+
+
+} // namespace cm

--- a/cm/test/cm_socket_server_client_test.cpp
+++ b/cm/test/cm_socket_server_client_test.cpp
@@ -71,6 +71,7 @@ public:
 
     MOCK_METHOD3(read, bool(size_t& bytes_read, void* buf, size_t size_to_read));
     MOCK_METHOD3(write, bool(size_t& bytes_read, const void* buf, size_t size_to_write));
+    MOCK_METHOD0(release, int());
 
     virtual int getFD() const
     {

--- /dev/null
+++ b/cm/test/cm_vector_socket_test.cpp
@@ -0,0 +1,79 @@
+
+#include <unistd.h>
+
+#include "gmock/gmock.h"
+
+#include "mt_typelist_algo_utility.h"
+#include "mt_shim_clear_memory.h"
+#include "cm_vector_socket.h"
+#include "cm_socket.h"
+
+namespace {
+
+#pragma GCC diagnostic ignored "-Weffc++"
+struct StringBufferMock
+{
+    MOCK_CONST_METHOD0(getString, const char*());
+};
+#pragma GCC diagnostic warning "-Weffc++"
+
+struct RFRelease
+{
+    RFRelease(StringBufferMock* mock_ptr)
+        : mock_ptr_(mock_ptr)
+    {}
+
+    void operator()()
+    {
+        delete mock_ptr_;
+    }
+
+    StringBufferMock* mock_ptr_;
+};
+
+static const char string1[] = "hello";
+static const char string2[] = " ";
+static const char string3[] = "world ";
+static const char string4[] = "!!!!";
+
+static const char string_for_mock[] = "[good by cruel world --]";
+
+TEST(CmVectorSocketTest, simple)
+{
+    StringBufferMock* mock = new StringBufferMock;
+
+    EXPECT_CALL(*mock, getString())
+        .WillOnce(::testing::Return(string_for_mock));
+
+    const cm::IOVectorBase& iov
+        = cm::IOVec()(string1, sizeof(string1) - 1)
+                     (string2, sizeof(string2) - 1)
+                     (string3, sizeof(string3) - 1)
+                     (string4, sizeof(string4) - 1)
+                     (mock->getString(), sizeof(string_for_mock) - 1, RFRelease(mock));
+
+    int pipe_fds[2];
+    int retval = pipe(pipe_fds);
+    EXPECT_EQ(retval, 0);
+
+    cm::VectorSocket write_socket(pipe_fds[1]);
+    cm::Socket read_socket(pipe_fds[0]);
+
+    size_t bytes_written = 0u;
+    bool ret = write_socket.writev(bytes_written, iov);
+
+    EXPECT_EQ(ret, true);
+
+    size_t total_bytes_written = sizeof(string1) - 1 + sizeof(string2) - 1 + sizeof(string3) - 1 + sizeof(string4) - 1 + sizeof(string_for_mock) - 1;
+    EXPECT_EQ(bytes_written, total_bytes_written);
+
+    size_t bytes_read = 0u;
+    char recv_buffer[1024];
+    mt::clearMemory(recv_buffer);
+    ret = read_socket.read(bytes_read, recv_buffer, sizeof(recv_buffer));
+
+    EXPECT_EQ(ret, true);
+    EXPECT_EQ(bytes_read, total_bytes_written);
+}
+
+} // namespace

--- /dev/null
+++ b/inc/cm_io_vector.h
@@ -0,0 +1,139 @@
+
+#ifndef INC_CM_IO_VECTOR_H_
+#define INC_CM_IO_VECTOR_H_
+
+#include "mt_static_assert.h"
+#include "mt_member_detector.h"
+#include "mt_typelist.h"
+#include "mt_typelist_algo_utility.h"
+
+namespace cm {
+
+struct IOVectorBase
+{
+    virtual ~IOVectorBase()
+    {}
+
+    virtual void setToVector(struct iovec*) const = 0;
+
+    virtual size_t getCount() const = 0;
+};
+
+template <typename TL, typename TLList>
+struct IOVectorChain : IOVectorBase
+{
+public:
+    typedef typename TL::Head T;
+    typedef typename TL::Tail RF;
+
+    static const size_t LAYERED_COUNT = IOVectorChain<typename TLList::Head, typename TLList::Tail>::LAYERED_COUNT + 1;
+
+    IOVectorChain(const IOVectorChain<TL, TLList>& rhs)
+        : ptr_(rhs.ptr_), size_(rhs.size_), release_functor_(rhs.release_functor_), tail_(rhs.tail_), should_release_(rhs.should_release_)
+    {
+        rhs.should_release_ = false;
+    }
+
+    IOVectorChain(const T* ptr, size_t size, RF release_functor, const IOVectorChain<typename TLList::Head, typename TLList::Tail>& obj)
+        : ptr_(ptr), size_(size), release_functor_(release_functor), tail_(obj), should_release_(true)
+    {}
+
+    template <typename Functor>
+    void performReleaseFunctor(Functor& func, typename mt::EnableIf<mt::HasFunctorOperator<Functor>::value>::Result* = 0)
+    {
+        release_functor_();
+    }
+
+    template <typename Functor>
+    void performReleaseFunctor(Functor&, typename mt::EnableIf<!mt::HasFunctorOperator<Functor>::value>::Result* = 0)
+    {
+    }
+
+    virtual ~IOVectorChain()
+    {
+        if (should_release_) {
+            performReleaseFunctor(release_functor_);
+        }
+    }
+
+    void setToVector(struct iovec* iovec_ptr) const
+    {
+        STATIC_ASSERT(LAYERED_COUNT >= 1);
+        const size_t offset = LAYERED_COUNT - 1;
+        iovec_ptr[offset].iov_base = const_cast<void*>(reinterpret_cast<const void*>(ptr_));
+        iovec_ptr[offset].iov_len = size_;
+        tail_.setToVector(iovec_ptr);
+    }
+
+    virtual size_t getCount() const
+    {
+        return LAYERED_COUNT;
+    }
+
+    template <typename X, typename XRF>
+    IOVectorChain< mt::Typelist<X, XRF>, mt::Typelist<TL, TLList> >
+    operator()(const X* ptr, size_t size, XRF x_release_functor)
+    {
+        return IOVectorChain< mt::Typelist<X, XRF>, mt::Typelist<TL, TLList> >(ptr, size, x_release_functor, *this);
+    }
+
+    template <typename X>
+    IOVectorChain< mt::Typelist<X, mt::NullType>, mt::Typelist<TL, TLList> > operator()(const X* ptr, size_t size)
+    {
+        return IOVectorChain< mt::Typelist<X, mt::NullType>, mt::Typelist<TL, TLList> >(ptr, size, mt::getNullType(), *this);
+    }
+
+private:
+    const T* ptr_;
+    size_t size_;
+    RF release_functor_;
+    const IOVectorChain<typename TLList::Head, typename TLList::Tail> tail_;
+    mutable bool should_release_;
+};
+
+template <>
+struct IOVectorChain<mt::NullType, mt::NullType>
+{
+public:
+    static const size_t LAYERED_COUNT = 0;
+
+    IOVectorChain()
+        : should_release_(true)
+    {}
+
+    IOVectorChain(const IOVectorChain<mt::NullType, mt::NullType>& rhs)
+        : should_release_(rhs.should_release_)
+    {
+        rhs.should_release_ = false;
+    }
+
+    virtual ~IOVectorChain()
+    {}
+
+    void setToVector(struct iovec*) const
+    {
+        return;
+    }
+
+    template <typename T, typename RF>
+    IOVectorChain< mt::Typelist<T, RF>, mt::Typelist<mt::NullType, mt::NullType> >
+    operator()(const T* ptr, size_t size, RF release_functor)
+    {
+        return IOVectorChain< mt::Typelist<T, RF>, mt::Typelist<mt::NullType, mt::NullType> >(ptr, size, release_functor, *this);
+    }
+
+    template <typename T>
+    IOVectorChain< mt::Typelist<T, mt::NullType>, mt::Typelist<mt::NullType, mt::NullType> >
+    operator()(const T* ptr, size_t size)
+    {
+        return IOVectorChain< mt::Typelist<T, mt::NullType>, mt::Typelist<mt::NullType, mt::NullType> >(ptr, size, mt::getNullType(), *this);
+    }
+
+    mutable bool should_release_;
+};
+
+typedef IOVectorChain<mt::NullType, mt::NullType> IOVec;
+
+
+} // namespace cm
+#endif // INC_CM_IO_VECTOR_H_

--- a/inc/cm_socket.h
+++ b/inc/cm_socket.h
@@ -3,6 +3,8 @@
 #define INC_CM_SOCKET_H_
 
 #include "cm_socket_if.h"
+#include "mt_mpl.h"
+#include "mt_member_detector.h"
 
 namespace cm {
 
@@ -12,6 +14,11 @@ public:
     Socket();
     Socket(int fd);
 
+    template <typename SocketType>
+    Socket(SocketType& socket, typename mt::EnableIf<mt::HasReleaseMethod<SocketType>::value>::Result* = 0)
+        : fd_(socket.release())
+    {}
+
     virtual ~Socket();
 
     virtual bool read(size_t& bytes_read, void* buf, size_t size_to_read);
@@ -19,11 +26,11 @@ public:
 
     virtual int getFD() const;
 
+    virtual int release();
 private:
     virtual SocketIf* doClone(int fd) const;
 
     int fd_;
-    bool need_open_;
 };
 
 } // namespace cm

--- a/inc/cm_socket_if.h
+++ b/inc/cm_socket_if.h
@@ -22,6 +22,8 @@ public:
         return mt::AutoPtr<SocketIf>(this->doClone(fd));
     }
 
+    virtual int release() = 0;
+
 protected:
     virtual SocketIf* doClone(int fd) const = 0;
     

--- a/inc/cm_socket_mock.h
+++ b/inc/cm_socket_mock.h
@@ -63,6 +63,8 @@ public:
         return false;
     }
 
+    MOCK_METHOD0(release, int());
+
     MOCK_METHOD3(write, bool(size_t& bytes_written, const void* buf, size_t size_to_write));
     MOCK_CONST_METHOD1(doClone, SocketIf*(int fd));
 

--- /dev/null
+++ b/inc/cm_vector_socket.h
@@ -0,0 +1,36 @@
+#ifndef INC_CM_VECTOR_SOCKET_H_
+#define INC_CM_VECTOR_SOCKET_H_
+
+#include <unistd.h>
+#include <sys/uio.h>
+#include <vector>
+#include <iostream>
+
+#include "mt_member_detector.h"
+#include "mt_mpl.h"
+#include "cm_io_vector.h"
+
+namespace cm {
+
+class VectorSocket
+{
+public:
+    VectorSocket(int fd);
+
+    template <typename SocketType>
+    VectorSocket(SocketType& socket, typename mt::EnableIf<mt::HasReleaseMethod<SocketType>::value>::Result* = 0)
+        : fd_(socket.release())
+    {}
+
+    static const int MAX_IOVEC_COUNT = 64;
+
+    bool writev(size_t& bytes_written, const IOVectorBase& vector, size_t skip_bytes = 0u);
+    // bool readv(size_t& bytes_read, IOVector<T>& vector);
+
+private:
+    int fd_;
+};
+
+} // namespace cm
+
+#endif // INC_CM_VECTOR_SOCKET_H_

--- a/inc/mt_auto_ptr.h
+++ b/inc/mt_auto_ptr.h
@@ -30,9 +30,8 @@ public:
     {}
 
     AutoPtr(AutoPtr<T>& rhs)
-        : raw_ptr_(rhs.get())
+        : raw_ptr_(rhs.release())
     {
-        rhs.release();
     }
 
     AutoPtr(AutoPtrRef<T> ref)
@@ -49,9 +48,7 @@ public:
 
     operator AutoPtrRef<T> ()
     {
-        T* ptr = this->get();
-        this->release();
-        return AutoPtrRef<T>(ptr);
+        return AutoPtrRef<T>(release());
     }
 
     ~AutoPtr()
@@ -59,9 +56,11 @@ public:
         reset();
     }
 
-    void release()
+    T* release()
     {
+        T* ptr_to_return = raw_ptr_;
         raw_ptr_ = 0;
+        return ptr_to_return;
     }
 
     void set(T* new_ptr)
@@ -117,9 +116,6 @@ public:
     }
 
 private:
-    // Won't allow conventional copy semantics from another const AutoPtr object.
-//  AutoPtr(const AutoPtr& rhs);
-//  AutoPtr& operator=(const AutoPtr& rhs);
 
     T* raw_ptr_;
 };

--- /dev/null
+++ b/inc/mt_member_detector.h
@@ -0,0 +1,37 @@
+
+#ifndef INC_MT_MEMBER_DETECTOR_H_
+#define INC_MT_MEMBER_DETECTOR_H_
+
+#include "mt_sfinae.h"
+
+namespace mt {
+
+// Meta function to detect whether parameterized type T has void operator() member function.
+template <typename T>
+struct HasFunctorOperator
+{
+    template <typename X>
+    static mt::YesTypeWithNonConstMemberMethodNoArg<X, void, &X::operator()> test(X*);
+
+    template <typename X>
+    static mt::NoType test(...);
+
+    static const bool value = sizeof(test<T>(0)) != sizeof(mt::NoType);
+};
+
+// Meta function to detect whether parameterized type T has int relase() member function
+template <typename T>
+struct HasReleaseMethod
+{
+    template <typename X>
+    static mt::YesTypeWithNonConstMemberMethodNoArg<X, int, &X::release> test(T*);
+
+    template <typename X>
+    static mt::NoType test(...);
+
+    static const bool value = sizeof(test<T>(0)) != sizeof(mt::NoType);
+};
+
+} // namespace mt
+
+#endif // INC_MT_MEMBER_DETECTOR_H_

--- a/inc/mt_static_assert.h
+++ b/inc/mt_static_assert.h
@@ -16,6 +16,6 @@ struct StaticAssert<true>
 
 } // namespace mt
 
-#define STATIC_ASSERT(cond) mt::unuseWithMessage(StaticAssert< (cond) >(), #cond)
+#define STATIC_ASSERT(cond) mt::unuseWithMessage(mt::StaticAssert< (cond) >(), #cond)
 
 #endif // INC_MT_STATIC_ASSERT_H_