[ { "path": ".clang-tidy", "content": "---\n# Only run a few checks for now.\nChecks: 'performance-*'\nWarningsAsErrors: ''\nHeaderFilterRegex: ''\nAnalyzeTemporaryDtors: false\nFormatStyle: none\nUser: chenshuo\nCheckOptions:\n - key: google-runtime-references.WhiteListTypes\n value: 'muduo::MutexLock'\n - key: llvm-namespace-comment.ShortNamespaceLines\n value: '10'\n - key: llvm-namespace-comment.SpacesBeforeComments\n value: '2'\n - key: MuduoRootDirectory\n value: '/muduo-cpp11/'\nExtraArgs:\n - '-Wno-sign-conversion'\n...\n\n" }, { "path": ".github/ISSUE_TEMPLATE/bug_report.md", "content": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\nDELETE FROM HERE TO LINE 18 BEFORE OPEN AN ISSUE.\n\nGitHub issues are for tracking bugs, not for general discussing like a forum.\n\nIf you have a general question to ask, use GitHub discussions:\n\nhttps://github.com/chenshuo/muduo/discussions\n\nWhen filing an issue of muduo, please provide a [SSCCE](http://sscce.org):\nShort, Self Contained, Correct (Compilable), Example.\n\nIf you can't compile muduo, make sure you install `cmake` and `boost` from the\nofficial package repository, e.g. `apt` or `yum`, before opening a bug.\nDon't open a bug if you installed boost from a third-party source or\ndownloaded it by yourself, and couldn't compile muduo, thank you.\n\nAlso specify the exact environment where the issue occurs:\n\n## Linux distro and version? x86 or ARM? 32-bit or 64-bit?\n\n## Branch (cpp98/cpp11/cpp17) and version of muduo?\n\n## Version of cmake, gcc and boost? (If not from distro.)\n" }, { "path": ".github/issue_template.md", "content": "DELETE FROM HERE TO LINE 18 BEFORE OPEN AN ISSUE.\n\nGitHub issues are for tracking bugs, not for general discussing like a forum.\n\nIf you have a general question to ask, use GitHub discussions:\n\nhttps://github.com/chenshuo/muduo/discussions\n\nWhen filing an issue of muduo, please provide a [SSCCE](http://sscce.org):\nShort, Self Contained, Correct (Compilable), Example.\n\nIf you can't compile muduo, make sure you install `cmake` and `boost` from the\nofficial package repository, e.g. `apt` or `yum`, before opening a bug.\nDon't open a bug if you installed boost from a third-party source or\ndownloaded it by yourself, and couldn't compile muduo, thank you.\n\nAlso specify the exact environment where the issue occurs:\n\n## Linux distro and version? x86 or ARM? 32-bit or 64-bit?\n\n## Branch (cpp98/cpp11/cpp17) and version of muduo?\n\n## Version of cmake, gcc and boost? (If not from distro.)\n\n" }, { "path": ".gitignore", "content": "*.swp\nbazel-*\ncompile_commands.json\n" }, { "path": ".travis.yml", "content": "language: cpp\nsudo: required\ncompiler:\n - gcc\n - clang\nos:\n - linux\ninstall:\n - sudo apt-get install libboost-dev\n - sudo apt-get install libprotobuf-dev protobuf-compiler libprotoc-dev libgoogle-perftools-dev\n - sudo apt-get install libboost-test-dev libboost-program-options-dev libboost-system-dev\n - sudo apt-get install libc-ares-dev libcurl4-openssl-dev\n - sudo apt-get install zlib1g-dev libgd-dev\nenv:\n - BUILD_TYPE=debug\n - BUILD_TYPE=release\nscript:\n - ./build.sh\n" }, { "path": "BUILD.bazel", "content": "# See https://github.com/chenshuo/muduo-tutorial for how to use muduo in your project.\n" }, { "path": "CMakeLists.txt", "content": "cmake_minimum_required(VERSION 2.6)\n\nproject(muduo C CXX)\n\nenable_testing()\n\nif(NOT CMAKE_BUILD_TYPE)\n set(CMAKE_BUILD_TYPE \"Release\")\nendif()\n\n# only build examples if this is the main project\nif(CMAKE_PROJECT_NAME STREQUAL \"muduo\")\n option(MUDUO_BUILD_EXAMPLES \"Build Muduo examples\" ON)\nendif()\n\nset(CXX_FLAGS\n -g\n # -DVALGRIND\n -DCHECK_PTHREAD_RETURN_VALUE\n -D_FILE_OFFSET_BITS=64\n -Wall\n -Wextra\n -Werror\n -Wconversion\n -Wno-unused-parameter\n -Wold-style-cast\n -Woverloaded-virtual\n -Wpointer-arith\n -Wshadow\n -Wwrite-strings\n -march=native\n # -MMD\n -std=c++11\n -rdynamic\n )\nif(CMAKE_BUILD_BITS EQUAL 32)\n list(APPEND CXX_FLAGS \"-m32\")\nendif()\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"Clang\")\n list(APPEND CXX_FLAGS \"-Wno-null-dereference\")\n list(APPEND CXX_FLAGS \"-Wno-sign-conversion\")\n list(APPEND CXX_FLAGS \"-Wno-unused-local-typedef\")\n list(APPEND CXX_FLAGS \"-Wthread-safety\")\n list(REMOVE_ITEM CXX_FLAGS \"-rdynamic\")\nendif()\nstring(REPLACE \";\" \" \" CMAKE_CXX_FLAGS \"${CXX_FLAGS}\")\n\nset(CMAKE_CXX_FLAGS_DEBUG \"-O0\")\nset(CMAKE_CXX_FLAGS_RELEASE \"-O2 -DNDEBUG\")\nset(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)\nset(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)\n\nfind_package(Boost REQUIRED)\nfind_package(Protobuf)\nfind_package(CURL)\nfind_package(ZLIB)\nfind_path(CARES_INCLUDE_DIR ares.h)\nfind_library(CARES_LIBRARY NAMES cares)\nfind_path(MHD_INCLUDE_DIR microhttpd.h)\nfind_library(MHD_LIBRARY NAMES microhttpd)\nfind_library(BOOSTTEST_LIBRARY NAMES boost_unit_test_framework)\nfind_library(BOOSTPO_LIBRARY NAMES boost_program_options)\nfind_library(BOOSTSYSTEM_LIBRARY NAMES boost_system)\nfind_path(TCMALLOC_INCLUDE_DIR gperftools/heap-profiler.h)\nfind_library(TCMALLOC_LIBRARY NAMES tcmalloc_and_profiler)\nfind_path(HIREDIS_INCLUDE_DIR hiredis/hiredis.h)\nfind_library(HIREDIS_LIBRARY NAMES hiredis)\nfind_path(GD_INCLUDE_DIR gd.h)\nfind_library(GD_LIBRARY NAMES gd)\nfind_program(THRIFT_COMPILER thrift)\nfind_path(THRIFT_INCLUDE_DIR thrift)\nfind_library(THRIFT_LIBRARY NAMES thrift)\n\nif(CARES_INCLUDE_DIR AND CARES_LIBRARY)\n message(STATUS \"found cares\")\nendif()\nif(CURL_FOUND)\n message(STATUS \"found curl\")\nendif()\nif(PROTOBUF_FOUND)\n message(STATUS \"found protobuf\")\nendif()\nif(TCMALLOC_INCLUDE_DIR AND TCMALLOC_LIBRARY)\n message(STATUS \"found tcmalloc\")\nendif()\nif(ZLIB_FOUND)\n message(STATUS \"found zlib\")\nendif()\nif(HIREDIS_INCLUDE_DIR AND HIREDIS_LIBRARY)\n message(STATUS \"found hiredis\")\nendif()\nif(GD_INCLUDE_DIR AND GD_LIBRARY)\n message(STATUS \"found gd\")\nendif()\nif(THRIFT_COMPILER AND THRIFT_INCLUDE_DIR AND THRIFT_LIBRARY)\n message(STATUS \"found thrift\")\nendif()\n\ninclude_directories(${Boost_INCLUDE_DIRS})\n\ninclude_directories(${PROJECT_SOURCE_DIR})\n\nstring(TOUPPER ${CMAKE_BUILD_TYPE} BUILD_TYPE)\nmessage(STATUS \"CXX_FLAGS = \" ${CMAKE_CXX_FLAGS} \" \" ${CMAKE_CXX_FLAGS_${BUILD_TYPE}})\n\nadd_subdirectory(muduo/base)\nadd_subdirectory(muduo/net)\n\nif(MUDUO_BUILD_EXAMPLES)\n add_subdirectory(contrib)\n add_subdirectory(examples)\nelse()\n if(CARES_INCLUDE_DIR AND CARES_LIBRARY)\n add_subdirectory(examples/cdns)\n endif()\nendif()\n\n" }, { "path": "ChangeLog", "content": "2018-10-22 Shuo Chen \n * Last version in C++98/03, next version will use C++11\n * Enable Clang Thread Safety Analysis.\n * Fix \"off_t does not name a type\" for CentOS 7 (#316) by qiao hai-jun\n * Fix warnings for gcc 8.\n * Add ttcp asio examples\n * Implement Procmon::listFiles()\n\n2018-01-18 Shuo Chen \n * Fix race condition between Thread::tid() and Thread::start().\n * Change protorpc format, add back package name. (Go does this since 1.2)\n * examples/socks4a/tunnel.h stops reading if output buffer is full.\n * Fixes for GCC 6/7\n * Minor fixes by huntinux, liangshaocong, zhoudayang2, octocat_lee,\n jack.xsuperman, ligewei, yqsy.\n * Version 1.1.0\n\n2016-10-25 Shuo Chen \n * Add Travis CI\n * Add EvevtLoop::queueSize() by \n * Implement TcpClient::retry() by fdxuwei\n * Change Condition::waitForSeconds() parameter type from int to double by ChaoShu\n * Minor fixes by JackDrogon, YuCong, zieckey, wuzhaogai\n * Version 1.0.9\n\n2016-02-11 Shuo Chen \n * Preliminary support of IPv6.\n * Add stop/startRead in TcpConnection by \n * Version 1.0.8\n\n2015-11-09 Shuo Chen \n * Add stats to Sudoku examples.\n * Add example of PeriodicTimer class.\n * Add thrift examples by .\n * Move hiredis example by to contrib/.\n * Move HTTP parseRequest to HttpContext class by .\n * Other fixes from , , , .\n * Version 1.0.7\n\n2015-04-03 Shuo Chen \n * Fix ProcessInspector::threads().\n * Minor fixes and improvements from liyuan989 and zieckey.\n * More Sudoku examples.\n * Version 1.0.6\n\n2015-01-30 Shuo Chen \n * Add examples/procmon\n * EventLoop supports set/get context by \n * Fix bug #107\n * Version 1.0.5\n\n2014-10-05 Shuo Chen \n * Enrich interfaces of EventLoopThreadPool by \n * Buffer supports reading int64_t by \n * Add hiredis example by \n * Fix bug about TcpClient life time again.\n * Other minor fixes, including some from \n * Version 1.0.4\n\n2014-08-02 Shuo Chen \n * Singleton supports 'no_destroy'.\n * Get tcp_info in TcpConnection.\n * Add CurrentThread::tidStringLength().\n * Fix bug about TcpClient life time. More checks.\n * Version 1.0.3\n\n2014-06-30 Shuo Chen \n * Fix boundary check in Buffer::findEOL() by .\n * Fix typos in InetAddress.cc by .\n * Fix 32-bit integer overflow bug in time_client by .\n * Update comments in Buffer::readFd() by .\n * Add ThreadPool::setThreadInitCallback().\n * Rename GzipStream to ZlibStream.\n * Version 1.0.2\n\n2014-04-10 Shuo Chen \n * More ProcessInfo functions.\n * Add GzipFile (in C++11 only) and GzipOutputStream.\n * Add SystemInspector.\n * muduo::Threads now sets thread name with prctl().\n * Version 1.0.1\n\n2014-03-12 Shuo Chen \n * Add TCP and RPC balancer examples\n * Version 1.0.0\n\n2014-03-05 Shuo Chen \n * Introduce class StringArg for passing C-style string arguments.\n * Support localtime in logging.\n * Version 1.0.0-rc2\n\n2014-02-22 Shuo Chen \n * Default to release build.\n * Version 1.0.0-rc1\n\n2014-02-22 Shuo Chen \n * Add base/WeakCallback.h\n * Add TcpConnection::forceCloseWithDelay().\n * Add InetAddress::resolve for sync DNS resolving.\n * Add simple Protobuf codec for single message type.\n * Add ACE ttcp and logging examples.\n * Fix race conditoin in RpcChannel::CallMethod().\n * Version 0.9.8\n\n2014-01-11 Shuo Chen \n * Add TcpConnection::forceClose().\n * Add fastcgi nginx.conf example\n * Fix iterator invalidation in hub.cc.\n * Version 0.9.7\n\n2013-10-21 Shuo Chen \n * Minor fixes.\n * Version 0.9.6\n\n2013-08-31 Shuo Chen \n * Add C++11 rvalue overloads for boost::function parameters\n * Add PerformanceInspector, support remote profiling with gperftools\n * Add examples of memcached server and client\n * Version 0.9.5\n\n2013-07-28 Shuo Chen \n * Protobuf RPC wire protocol changed,\n package name removed in 'service' field.\n * Add roundtrip_udp as a UDP example\n * More inspect\n * Fix Connector::stop()\n * Fix for protobuf 2.5.0\n * Version 0.9.4\n\n2013-05-11 Shuo Chen \n * ThreadPool can be blocking\n * Support SO_REUSEPORT, added in kernel 3.9.0\n * Fix Mutex::isLockedByThisThread()\n * Version 0.9.3\n\n2013-03-22 Shuo Chen \n * Fix bugs\n * Add Sudoku client\n * Version 0.9.2\n\n2013-01-16 Shuo Chen \n * Fix bug introduced in dd26871\n * Version 0.9.1\n\n2013-01-09 Shuo Chen \n * Add single thread concurrent download example in examples/curl.\n * Add distributed word counting example.\n * Add simple FastCGI example.\n * Fix HttpRequest for empty header value, contributed by SeasonLee\n * Fix Connector destruction\n * Version 0.9.0\n\n2012-11-06 Shuo Chen \n * Version for the book\n * Fix Buffer::shrink()\n * Fix race condition of ThreadPool::stop()\n * Version 0.8.2\n\n2012-09-30 Shuo Chen \n * Add Channel::remove()\n * Logger::SourceFile supports char*\n * Fix for g++ 4.7\n * Version 0.8.1\n\n2012-09-06 Shuo Chen \n * More Buffer member functions, contributed by SeasonLee\n * Add unit tests for Buffer\n * Fix wait condition in AsyncLogging::threadFunc()\n * Rename fromHostPort to fromIpPort\n * Add hash_value for shared_ptr\n * Add TcpConnection::getMutableContext()\n * Remove unnecessary code, header\n * Add another example in idleconnection\n * Version 0.8.0\n\n2012-06-26 Shuo Chen \n\n * Add TimeZone class and unit tests.\n * Inline Buffer::appendInt32() and Buffer::peekInt32().\n * Catch exception in Thread::runInThread().\n Rethrow in catch(...) to make pthread_cancel() working.\n * Avoid deleting incomplete types.\n * Replace delete with boost::ptr_vector\n * Destructs ThreadLocalSingleton\n * Replace __thread object with ThreadLocalSingleton in examples/asio/chat/\n * Fix compile with g++ 4.6\n * With armlinux.diff, muduo compiles on Raspberry Pi with g++ 4.5.\n * Version 0.7.0\n\n2012-06-11 Shuo Chen \n\n * Put hostname as part of log file name.\n * Extract muduo/base/CurrentThread.h\n * Optimize logging for thread id and source filename.\n * Add BlockingQueue_bench, improve Thread_bench.\n * Add examples/zeromq, for round-trip latency tests.\n * Demonstrate HighWaterMark callback and weak callback in tcp tunnel.\n * Fix chat codec for invalid length.\n * Version 0.6.0\n\n2012-06-03 Shuo Chen \n\n * Replace std::ostream with LogStream.\n * Add LogFile and AsyncLogging.\n * Set SO_KEEPALIVE by default.\n * Add HighWaterMark callback to TcpConnection.\n * Add EventLoop::getEventLoopOfCurrentThread(),\n Add ThreadInitCallback to EventLoopThreadPool.\n * Add asio_chat_server_threaded_highperformance\n * Version 0.5.0\n\n2012-05-18 Shuo Chen \n\n * Add FileUtil.\n * Add new functions in ProcessInfo\n * Add example for curl.\n * Add add RPC meta service proto.\n * Add loadtest for asio chat.\n * Version 0.3.5\n\n2012-03-22 Shuo Chen \n\n * Add example for async rpc (resolver).\n * Install muduo_cdns\n * Version 0.3.4\n\n2012-03-16 Shuo Chen \n\n * Remove net/protorpc2\n moved to http://github.com/chenshuo/muduo-protorpc\n * Install EventLoopThreadPool.h, rpc.proto and rpc.pb.h\n * Version 0.3.3\n\n2012-03-11 Shuo Chen \n\n * Add asynchronous DNS stub resolver based on c-ares.\n See also https://github.com/chenshuo/muduo-udns\n * Replace string with StringPiece for function parameters.\n * Change default log level from DEBUG to INFO,\n set MUDUO_LOG_DEBUG=1 to revert.\n * Install Channel.h\n * Version 0.3.2\n\n2012-03-01 Shuo Chen \n\n * Support multi-threaded http server.\n * Do not install SocketsOps.h\n * Version 0.3.1\n\n2012-02-24 Shuo Chen \n\n * Support Keep-Alive for HTTP/1.0.\n * Check return value of pthread_create.\n * Minor fixes (set TcpNoDelay, stop() in ThreadPool::dtor)\n * Version 0.3.0\n\n2011-09-18 Shuo Chen \n\n * EventLoop now supports cancelling timer.\n * Add two examples of asio chat server, demo copy-on-write\n in multithreaded program.\n * Version 0.2.9\n\n2011-09-04 Shuo Chen \n\n * Refactored RPC implementation of version 1 and 2,\n programming interface differ, interoperable.\n version 2 is incomplete yet.\n * Find protobuf with cmake find_package().\n * Version 0.2.8\n\n2011-09-03 Shuo Chen \n\n * Add a proof of concept implementation of Protobuf RPC.\n * Version 0.2.7\n\n2011-06-27 Shuo Chen \n\n * Fix decoding of Sudoku request.\n * Backport to older Linux.\n * Add BoundedBlockingQueue\n * Version 0.2.6\n\n2011-06-15 Shuo Chen \n\n * Add examples/sudoku.\n * Add thread benchmark.\n * Version 0.2.5\n\n2011-06-02 Shuo Chen \n\n * Add examples/shorturl.\n * Version 0.2.4\n\n2011-05-24 Shuo Chen \n\n * Fix warnings on Arch Linux (GCC 4.6.0), thanks to ifreedom\n * Add CMake install instructions, thanks to ifreedom\n * Fix warnings on 32-bit Linux, thanks to highshow\n * Version 0.2.3\n\n2011-05-15 Shuo Chen \n\n * Changes from reactor tutorial\n * Version 0.2.2\n\n2011-05-07 Shuo Chen \n\n * Try making TcpClient destructable\n * Add demux in examples/multiplexer\n * Add examples/socks4a\n * Changes for reactor tutorial\n * Version 0.2.1\n\n2011-04-27 Shuo Chen \n\n * Add kick idle connection example in examples/idleconnection.\n * Add test harness to examples/multiplexer\n * Replace std::list with std::set in TimerQueue.\n * Version 0.2.0\n\n2011-04-11 Shuo Chen \n\n * Add Google Protobuf codec and dispatcher\n * Revert 'Add max connection limit to simple echo example.'\n * Add max connection limit example in examples/maxconnection.\n * Version 0.1.9\n\n2011-03-27 Shuo Chen \n\n * Add file transfer download examples.\n * Add max connection limit to simple echo example.\n * Make inputBuffer accessible in TcpConnection.\n * Const-ness correct in Buffer class.\n * Add Mutex test for benchmarking.\n * Replace anonymous namespace with muduo::detail in muduo/base.\n * Version 0.1.8\n\n2011-02-03 Shuo Chen \n\n * Fix LengthHeaderCodec::onMessage() in examples/asio/chat.\n * Version 0.1.7\n\n2011-02-01 Shuo Chen \n\n * Fix onConnection() in simple examples.\n * Reset t_cachedTid after fork().\n * Version 0.1.6\n\n2010-12-15 Shuo Chen \n\n * Add examples/multiplexer\n * Fix epoll kNoneEvent\n * Version 0.1.5\n\n2010-11-20 Shuo Chen \n\n * Fix retry logic\n * Version 0.1.4\n\n2010-09-26 Shuo Chen \n\n * Check SO_ERROR when connection is made.\n\n2010-09-11 Shuo Chen \n\n * Gracefully refuse clients when accept(2) returns EMFILE.\n * Version 0.1.3\n\n2010-09-07 Shuo Chen \n\n * Libevent benchmark for event handling.\n * Version 0.1.2\n\n2010-09-04 Shuo Chen \n\n * Ping-pong benchmark, version 0.1.1\n\n2010-08-30 Shuo Chen \n\n * First pre-alpha release, version 0.1.0\n\n2010-08-29 Shuo Chen \n\n * Sub works.\n\n2010-08-28 Shuo Chen \n\n * Add twisted finger examples.\n\n2010-08-27 Shuo Chen \n\n * Add simple chargen example.\n\n2010-08-07 Shuo Chen \n\n * Add Date.\n\n2010-05-15 Shuo Chen \n\n * Hub works.\n\n2010-05-14 Shuo Chen \n\n * Inspects opened files and threads.\n\n2010-05-11 Shuo Chen \n\n * Add inspector for process info.\n\n2010-05-04 Shuo Chen \n\n * Add simple http server and client.\n\n2010-04-25 Shuo Chen \n\n * Add examples.\n\n2010-04-11 Shuo Chen \n\n * TcpClient works.\n\n2010-04-03 Shuo Chen \n\n * TcpServer works.\n\n2010-03-15 Shuo Chen \n\n * TcpConnection at server side works.\n\n2010-03-14 Shuo Chen \n\n * Acceptor works.\n\n2010-03-13 Shuo Chen \n\n * TimerQueue works.\n\n2010-03-12 Shuo Chen \n\n * Starts working on Muduo.\n" }, { "path": "ChangeLog2", "content": "2018-10-24 Shuo Chen \n * First release of C++11 version of muduo.\n * Forked after v1.0.9, e6c04c43 is the base. changes in cpp98 branch are integrated\n * Replace boost::shared_ptr/boost::weak_ptr with std::shared_ptr/std::weak_ptr.\n * Replace boost::function/boost::bind with std::function/std::bind/lambda.\n * Replace boost::ptr_vector with std::vector>.\n * Replace boost::noncopyable with muduo::noncopyable.\n * Replace boost::scoped_ptr with std::unique_ptr.\n * Replace BOOST_STATIC_ASSERT with static_assert.\n * Replace boost type_traits with std type_traits.\n * Version 2.0.0\n\n" }, { "path": "License", "content": "// Muduo - A reactor-based C++ network library for Linux\n// Copyright (c) 2010, Shuo Chen. All rights reserved.\n// http://code.google.com/p/muduo/\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions\n// are met:\n//\n// * Redistributions of source code must retain the above copyright\n// notice, this list of conditions and the following disclaimer.\n// * Redistributions in binary form must reproduce the above copyright\n// notice, this list of conditions and the following disclaimer in the\n// documentation and/or other materials provided with the distribution.\n// * Neither the name of Shuo Chen nor the names of other contributors\n// may be used to endorse or promote products derived from this software\n// without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n// \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n" }, { "path": "README", "content": "Muduo is a multithreaded C++ network library based on\nthe reactor pattern.\n\nhttp://github.com/chenshuo/muduo\n\nCopyright (c) 2010, Shuo Chen. All rights reserved.\n\nUse of this source code is governed by a BSD-style\nlicense that can be found in the License file.\n\nRequires:\n Linux kernel version >= 2.6.28.\n GCC >= 4.7 or Clang >= 3.5\n Boost (for boost::any only.)\n\nTested on:\n Debian 7 and above\n Unbuntu 14.04 and above\n CentOS 7 and above\n\nInstall required packages:\n # Debian, Ubuntu, etc.\n $ sudo apt install g++ cmake make libboost-dev\n # CentOS\n $ sudo yum install gcc-c++ cmake make boost-devel\n\nSee .travis.yml for additional packages for building more examples.\n\nTo build, run:\n ./build.sh\n\nSee https://github.com/chenshuo/muduo-tutorial for\nhow to use muduo in your project.\n __ __ _\n | \\/ | | |\n | \\ / |_ _ __| |_ _ ___\n | |\\/| | | | |/ _` | | | |/ _ \\\n | | | | |_| | (_| | |_| | (_) |\n |_| |_|\\__,_|\\__,_|\\__,_|\\___/\n\n" }, { "path": "WORKSPACE", "content": "" }, { "path": "build.sh", "content": "#!/bin/sh\n\nset -x\n\nSOURCE_DIR=`pwd`\nBUILD_DIR=${BUILD_DIR:-../build}\nBUILD_TYPE=${BUILD_TYPE:-release}\nINSTALL_DIR=${INSTALL_DIR:-../${BUILD_TYPE}-install-cpp11}\nCXX=${CXX:-g++}\n\nln -sf $BUILD_DIR/$BUILD_TYPE-cpp11/compile_commands.json\n\nmkdir -p $BUILD_DIR/$BUILD_TYPE-cpp11 \\\n && cd $BUILD_DIR/$BUILD_TYPE-cpp11 \\\n && cmake \\\n -DCMAKE_BUILD_TYPE=$BUILD_TYPE \\\n -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR \\\n -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \\\n $SOURCE_DIR \\\n && make $*\n\n# Use the following command to run all the unit tests\n# at the dir $BUILD_DIR/$BUILD_TYPE :\n# CTEST_OUTPUT_ON_FAILURE=TRUE make test\n\n# cd $SOURCE_DIR && doxygen\n\n" }, { "path": "contrib/CMakeLists.txt", "content": "if(HIREDIS_INCLUDE_DIR AND HIREDIS_LIBRARY)\n add_subdirectory(hiredis)\nelse()\n add_subdirectory(hiredis EXCLUDE_FROM_ALL)\nendif()\n\nif(THRIFT_COMPILER AND THRIFT_INCLUDE_DIR AND THRIFT_LIBRARY)\n add_subdirectory(thrift)\nelse()\n add_subdirectory(thrift EXCLUDE_FROM_ALL)\nendif()\n" }, { "path": "contrib/hiredis/CMakeLists.txt", "content": "add_executable(mrediscli Hiredis.cc mrediscli.cc)\ntarget_link_libraries(mrediscli muduo_net hiredis)\n" }, { "path": "contrib/hiredis/Hiredis.cc", "content": "#include \"contrib/hiredis/Hiredis.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/Channel.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/SocketsOps.h\"\n\n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\nusing namespace hiredis;\n\nstatic void dummy(const std::shared_ptr&)\n{\n}\n\nHiredis::Hiredis(EventLoop* loop, const InetAddress& serverAddr)\n : loop_(loop),\n serverAddr_(serverAddr),\n context_(NULL)\n{\n}\n\nHiredis::~Hiredis()\n{\n LOG_DEBUG << this;\n assert(!channel_ || channel_->isNoneEvent());\n ::redisAsyncFree(context_);\n}\n\nbool Hiredis::connected() const\n{\n return channel_ && context_ && (context_->c.flags & REDIS_CONNECTED);\n}\n\nconst char* Hiredis::errstr() const\n{\n assert(context_ != NULL);\n return context_->errstr;\n}\n\nvoid Hiredis::connect()\n{\n assert(!context_);\n\n context_ = ::redisAsyncConnect(serverAddr_.toIp().c_str(), serverAddr_.port());\n\n context_->ev.addRead = addRead;\n context_->ev.delRead = delRead;\n context_->ev.addWrite = addWrite;\n context_->ev.delWrite = delWrite;\n context_->ev.cleanup = cleanup;\n context_->ev.data = this;\n\n setChannel();\n\n assert(context_->onConnect == NULL);\n assert(context_->onDisconnect == NULL);\n ::redisAsyncSetConnectCallback(context_, connectCallback);\n ::redisAsyncSetDisconnectCallback(context_, disconnectCallback);\n}\n\nvoid Hiredis::disconnect()\n{\n if (connected())\n {\n LOG_DEBUG << this;\n ::redisAsyncDisconnect(context_);\n }\n}\n\nint Hiredis::fd() const\n{\n assert(context_);\n return context_->c.fd;\n}\n\nvoid Hiredis::setChannel()\n{\n LOG_DEBUG << this;\n assert(!channel_);\n channel_.reset(new Channel(loop_, fd()));\n channel_->setReadCallback(std::bind(&Hiredis::handleRead, this, _1));\n channel_->setWriteCallback(std::bind(&Hiredis::handleWrite, this));\n}\n\nvoid Hiredis::removeChannel()\n{\n LOG_DEBUG << this;\n channel_->disableAll();\n channel_->remove();\n loop_->queueInLoop(std::bind(dummy, channel_));\n channel_.reset();\n}\n\nvoid Hiredis::handleRead(muduo::Timestamp receiveTime)\n{\n LOG_TRACE << \"receiveTime = \" << receiveTime.toString();\n ::redisAsyncHandleRead(context_);\n}\n\nvoid Hiredis::handleWrite()\n{\n if (!(context_->c.flags & REDIS_CONNECTED))\n {\n removeChannel();\n }\n ::redisAsyncHandleWrite(context_);\n}\n\n/* static */ Hiredis* Hiredis::getHiredis(const redisAsyncContext* ac)\n{\n Hiredis* hiredis = static_cast(ac->ev.data);\n assert(hiredis->context_ == ac);\n return hiredis;\n}\n\nvoid Hiredis::logConnection(bool up) const\n{\n InetAddress localAddr(sockets::getLocalAddr(fd()));\n InetAddress peerAddr(sockets::getPeerAddr(fd()));\n\n LOG_INFO << localAddr.toIpPort() << \" -> \"\n << peerAddr.toIpPort() << \" is \"\n << (up ? \"UP\" : \"DOWN\");\n}\n\n/* static */ void Hiredis::connectCallback(const redisAsyncContext* ac, int status)\n{\n LOG_TRACE;\n getHiredis(ac)->connectCallback(status);\n}\n\nvoid Hiredis::connectCallback(int status)\n{\n if (status != REDIS_OK)\n {\n LOG_ERROR << context_->errstr << \" failed to connect to \" << serverAddr_.toIpPort();\n }\n else\n {\n logConnection(true);\n setChannel();\n }\n\n if (connectCb_)\n {\n connectCb_(this, status);\n }\n}\n\n/* static */ void Hiredis::disconnectCallback(const redisAsyncContext* ac, int status)\n{\n LOG_TRACE;\n getHiredis(ac)->disconnectCallback(status);\n}\n\nvoid Hiredis::disconnectCallback(int status)\n{\n logConnection(false);\n removeChannel();\n\n if (disconnectCb_)\n {\n disconnectCb_(this, status);\n }\n}\n\nvoid Hiredis::addRead(void* privdata)\n{\n LOG_TRACE;\n Hiredis* hiredis = static_cast(privdata);\n hiredis->channel_->enableReading();\n}\n\nvoid Hiredis::delRead(void* privdata)\n{\n LOG_TRACE;\n Hiredis* hiredis = static_cast(privdata);\n hiredis->channel_->disableReading();\n}\n\nvoid Hiredis::addWrite(void* privdata)\n{\n LOG_TRACE;\n Hiredis* hiredis = static_cast(privdata);\n hiredis->channel_->enableWriting();\n}\n\nvoid Hiredis::delWrite(void* privdata)\n{\n LOG_TRACE;\n Hiredis* hiredis = static_cast(privdata);\n hiredis->channel_->disableWriting();\n}\n\nvoid Hiredis::cleanup(void* privdata)\n{\n Hiredis* hiredis = static_cast(privdata);\n LOG_DEBUG << hiredis;\n}\n\nint Hiredis::command(const CommandCallback& cb, muduo::StringArg cmd, ...)\n{\n if (!connected()) return REDIS_ERR;\n\n LOG_TRACE;\n CommandCallback* p = new CommandCallback(cb);\n va_list args;\n va_start(args, cmd);\n int ret = ::redisvAsyncCommand(context_, commandCallback, p, cmd.c_str(), args);\n va_end(args);\n return ret;\n}\n\n/* static */ void Hiredis::commandCallback(redisAsyncContext* ac, void* r, void* privdata)\n{\n redisReply* reply = static_cast(r);\n CommandCallback* cb = static_cast(privdata);\n getHiredis(ac)->commandCallback(reply, cb);\n}\n\nvoid Hiredis::commandCallback(redisReply* reply, CommandCallback* cb)\n{\n (*cb)(this, reply);\n delete cb;\n}\n\nint Hiredis::ping()\n{\n return command(std::bind(&Hiredis::pingCallback, this, _1, _2), \"PING\");\n}\n\nvoid Hiredis::pingCallback(Hiredis* me, redisReply* reply)\n{\n assert(this == me);\n LOG_DEBUG << reply->str;\n}\n" }, { "path": "contrib/hiredis/Hiredis.h", "content": "#ifndef MUDUO_CONTRIB_HIREDIS_HIREDIS_H\n#define MUDUO_CONTRIB_HIREDIS_HIREDIS_H\n\n#include \"muduo/base/noncopyable.h\"\n#include \"muduo/base/StringPiece.h\"\n#include \"muduo/base/Types.h\"\n#include \"muduo/net/Callbacks.h\"\n#include \"muduo/net/InetAddress.h\"\n\n#include \n\nstruct redisAsyncContext;\n\nnamespace muduo\n{\nnamespace net\n{\nclass Channel;\nclass EventLoop;\n}\n}\n\nnamespace hiredis\n{\n\nclass Hiredis : public std::enable_shared_from_this,\n muduo::noncopyable\n{\n public:\n typedef std::function ConnectCallback;\n typedef std::function DisconnectCallback;\n typedef std::function CommandCallback;\n\n Hiredis(muduo::net::EventLoop* loop, const muduo::net::InetAddress& serverAddr);\n ~Hiredis();\n\n const muduo::net::InetAddress& serverAddress() const { return serverAddr_; }\n // redisAsyncContext* context() { return context_; }\n bool connected() const;\n const char* errstr() const;\n\n void setConnectCallback(const ConnectCallback& cb) { connectCb_ = cb; }\n void setDisconnectCallback(const DisconnectCallback& cb) { disconnectCb_ = cb; }\n\n void connect();\n void disconnect(); // FIXME: implement this with redisAsyncDisconnect\n\n int command(const CommandCallback& cb, muduo::StringArg cmd, ...);\n\n int ping();\n\n private:\n void handleRead(muduo::Timestamp receiveTime);\n void handleWrite();\n\n int fd() const;\n void logConnection(bool up) const;\n void setChannel();\n void removeChannel();\n\n void connectCallback(int status);\n void disconnectCallback(int status);\n void commandCallback(redisReply* reply, CommandCallback* privdata);\n\n static Hiredis* getHiredis(const redisAsyncContext* ac);\n\n static void connectCallback(const redisAsyncContext* ac, int status);\n static void disconnectCallback(const redisAsyncContext* ac, int status);\n // command callback\n static void commandCallback(redisAsyncContext* ac, void*, void*);\n\n static void addRead(void* privdata);\n static void delRead(void* privdata);\n static void addWrite(void* privdata);\n static void delWrite(void* privdata);\n static void cleanup(void* privdata);\n\n void pingCallback(Hiredis* me, redisReply* reply);\n\n private:\n muduo::net::EventLoop* loop_;\n const muduo::net::InetAddress serverAddr_;\n redisAsyncContext* context_;\n std::shared_ptr channel_;\n ConnectCallback connectCb_;\n DisconnectCallback disconnectCb_;\n};\n\n} // namespace hiredis\n\n#endif // MUDUO_CONTRIB_HIREDIS_HIREDIS_H\n" }, { "path": "contrib/hiredis/README.md", "content": "# Hiredis\n\nThe version of hiredis must be 0.11.0 or greater\n\nSee also issue [#92](https://github.com/chenshuo/muduo/issues/92)\n" }, { "path": "contrib/hiredis/mrediscli.cc", "content": "#include \"contrib/hiredis/Hiredis.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n\n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nstring toString(long long value)\n{\n char buf[32];\n snprintf(buf, sizeof buf, \"%lld\", value);\n return buf;\n}\n\nstring redisReplyToString(const redisReply* reply)\n{\n static const char* const types[] = { \"\",\n \"REDIS_REPLY_STRING\", \"REDIS_REPLY_ARRAY\",\n \"REDIS_REPLY_INTEGER\", \"REDIS_REPLY_NIL\",\n \"REDIS_REPLY_STATUS\", \"REDIS_REPLY_ERROR\" };\n string str;\n if (!reply) return str;\n\n str += types[reply->type] + string(\"(\") + toString(reply->type) + \") \";\n\n str += \"{ \";\n if (reply->type == REDIS_REPLY_STRING ||\n reply->type == REDIS_REPLY_STATUS ||\n reply->type == REDIS_REPLY_ERROR)\n {\n str += '\"' + string(reply->str, reply->len) + '\"';\n }\n else if (reply->type == REDIS_REPLY_INTEGER)\n {\n str += toString(reply->integer);\n }\n else if (reply->type == REDIS_REPLY_ARRAY)\n {\n str += toString(reply->elements) + \" \";\n for (size_t i = 0; i < reply->elements; i++)\n {\n str += \" \" + redisReplyToString(reply->element[i]);\n }\n }\n str += \" }\";\n\n return str;\n}\n\nvoid connectCallback(hiredis::Hiredis* c, int status)\n{\n if (status != REDIS_OK)\n {\n LOG_ERROR << \"connectCallback Error:\" << c->errstr();\n }\n else\n {\n LOG_INFO << \"Connected...\";\n }\n}\n\nvoid disconnectCallback(hiredis::Hiredis* c, int status)\n{\n if (status != REDIS_OK)\n {\n LOG_ERROR << \"disconnectCallback Error:\" << c->errstr();\n }\n else\n {\n LOG_INFO << \"Disconnected...\";\n }\n}\n\nvoid timeCallback(hiredis::Hiredis* c, redisReply* reply)\n{\n LOG_INFO << \"time \" << redisReplyToString(reply);\n}\n\nvoid echoCallback(hiredis::Hiredis* c, redisReply* reply, string* echo)\n{\n LOG_INFO << *echo << \" \" << redisReplyToString(reply);\n c->disconnect();\n}\n\nvoid dbsizeCallback(hiredis::Hiredis* c, redisReply* reply)\n{\n LOG_INFO << \"dbsize \" << redisReplyToString(reply);\n}\n\nvoid selectCallback(hiredis::Hiredis* c, redisReply* reply, uint16_t* index)\n{\n LOG_INFO << \"select \" << *index << \" \" << redisReplyToString(reply);\n}\n\nvoid authCallback(hiredis::Hiredis* c, redisReply* reply, string* password)\n{\n LOG_INFO << \"auth \" << *password << \" \" << redisReplyToString(reply);\n}\n\nvoid echo(hiredis::Hiredis* c, string* s)\n{\n c->command(std::bind(echoCallback, _1, _2, s), \"echo %s\", s->c_str());\n}\n\nint main(int argc, char** argv)\n{\n Logger::setLogLevel(Logger::DEBUG);\n\n EventLoop loop;\n\n InetAddress serverAddr(\"127.0.0.1\", 6379);\n hiredis::Hiredis hiredis(&loop, serverAddr);\n\n hiredis.setConnectCallback(connectCallback);\n hiredis.setDisconnectCallback(disconnectCallback);\n hiredis.connect();\n\n //hiredis.ping();\n loop.runEvery(1.0, std::bind(&hiredis::Hiredis::ping, &hiredis));\n\n hiredis.command(timeCallback, \"time\");\n\n string hi = \"hi\";\n hiredis.command(std::bind(echoCallback, _1, _2, &hi), \"echo %s\", hi.c_str());\n loop.runEvery(2.0, std::bind(echo, &hiredis, &hi));\n\n hiredis.command(dbsizeCallback, \"dbsize\");\n\n uint16_t index = 8;\n hiredis.command(std::bind(selectCallback, _1, _2, &index), \"select %d\", index);\n\n string password = \"password\";\n hiredis.command(std::bind(authCallback, _1, _2, &password), \"auth %s\", password.c_str());\n\n loop.loop();\n\n return 0;\n}\n" }, { "path": "contrib/thrift/CMakeLists.txt", "content": "set(MUDUO_THRIFT_SRCS\n ThriftConnection.cc\n ThriftServer.cc\n )\nadd_library(muduo_thrift ${MUDUO_THRIFT_SRCS})\ntarget_link_libraries(muduo_thrift muduo_net thrift)\n\nif(THRIFT_COMPILER AND THRIFT_INCLUDE_DIR AND THRIFT_LIBRARY)\n include_directories(${CMAKE_CURRENT_SOURCE_DIR})\n add_subdirectory(tests)\nendif()\n" }, { "path": "contrib/thrift/ThriftConnection.cc", "content": "#include \"contrib/thrift/ThriftConnection.h\"\n\n#include \n\n#include \"muduo/base/Logging.h\"\n\n#include \n\n#include \"contrib/thrift/ThriftServer.h\"\n\nusing muduo::Timestamp;\nusing muduo::net::Buffer;\nusing muduo::net::TcpConnectionPtr;\nusing muduo::_1;\nusing muduo::_2;\nusing muduo::_3;\n\nThriftConnection::ThriftConnection(ThriftServer* server,\n const TcpConnectionPtr& conn)\n : server_(server),\n conn_(conn),\n state_(kExpectFrameSize),\n frameSize_(0)\n{\n conn_->setMessageCallback(std::bind(&ThriftConnection::onMessage,\n this, _1, _2, _3));\n nullTransport_.reset(new TNullTransport());\n inputTransport_.reset(new TMemoryBuffer(NULL, 0));\n outputTransport_.reset(new TMemoryBuffer());\n\n factoryInputTransport_ = server_->getInputTransportFactory()->getTransport(inputTransport_);\n factoryOutputTransport_ = server_->getOutputTransportFactory()->getTransport(outputTransport_);\n\n inputProtocol_ = server_->getInputProtocolFactory()->getProtocol(factoryInputTransport_);\n outputProtocol_ = server_->getOutputProtocolFactory()->getProtocol(factoryOutputTransport_);\n\n processor_ = server_->getProcessor(inputProtocol_, outputProtocol_, nullTransport_);\n}\n\nvoid ThriftConnection::onMessage(const TcpConnectionPtr& conn,\n Buffer* buffer,\n Timestamp receiveTime)\n{\n bool more = true;\n while (more)\n {\n if (state_ == kExpectFrameSize)\n {\n if (buffer->readableBytes() >= 4)\n {\n frameSize_ = static_cast(buffer->readInt32());\n state_ = kExpectFrame;\n }\n else\n {\n more = false;\n }\n }\n else if (state_ == kExpectFrame)\n {\n if (buffer->readableBytes() >= frameSize_)\n {\n uint8_t* buf = reinterpret_cast((const_cast(buffer->peek())));\n\n inputTransport_->resetBuffer(buf, frameSize_, TMemoryBuffer::COPY);\n outputTransport_->resetBuffer();\n outputTransport_->getWritePtr(4);\n outputTransport_->wroteBytes(4);\n\n if (server_->isWorkerThreadPoolProcessing())\n {\n server_->workerThreadPool().run(std::bind(&ThriftConnection::process, this));\n }\n else\n {\n process();\n }\n\n buffer->retrieve(frameSize_);\n state_ = kExpectFrameSize;\n }\n else\n {\n more = false;\n }\n }\n }\n}\n\nvoid ThriftConnection::process()\n{\n try\n {\n processor_->process(inputProtocol_, outputProtocol_, NULL);\n\n uint8_t* buf;\n uint32_t size;\n outputTransport_->getBuffer(&buf, &size);\n\n assert(size >= 4);\n uint32_t frameSize = static_cast(htonl(size - 4));\n memcpy(buf, &frameSize, 4);\n\n conn_->send(buf, size);\n } catch (const TTransportException& ex)\n {\n LOG_ERROR << \"ThriftServer TTransportException: \" << ex.what();\n close();\n } catch (const std::exception& ex)\n {\n LOG_ERROR << \"ThriftServer std::exception: \" << ex.what();\n close();\n } catch (...)\n {\n LOG_ERROR << \"ThriftServer unknown exception\";\n close();\n }\n}\n\nvoid ThriftConnection::close()\n{\n nullTransport_->close();\n factoryInputTransport_->close();\n factoryOutputTransport_->close();\n}\n" }, { "path": "contrib/thrift/ThriftConnection.h", "content": "#ifndef MUDUO_CONTRIB_THRIFT_THRIFTCONNECTION_H\n#define MUDUO_CONTRIB_THRIFT_THRIFTCONNECTION_H\n\n#include \n#include \n\n#include \"muduo/net/TcpConnection.h\"\n\n#include \n#include \n#include \n\nusing apache::thrift::TProcessor;\nusing apache::thrift::protocol::TProtocol;\nusing apache::thrift::transport::TMemoryBuffer;\nusing apache::thrift::transport::TNullTransport;\nusing apache::thrift::transport::TTransport;\nusing apache::thrift::transport::TTransportException;\n\nclass ThriftServer;\n\nclass ThriftConnection : boost::noncopyable,\n public boost::enable_shared_from_this\n{\n public:\n enum State\n {\n kExpectFrameSize,\n kExpectFrame\n };\n\n ThriftConnection(ThriftServer* server, const muduo::net::TcpConnectionPtr& conn);\n\n private:\n void onMessage(const muduo::net::TcpConnectionPtr& conn,\n muduo::net::Buffer* buffer,\n muduo::Timestamp receiveTime);\n\n void process();\n\n void close();\n\n private:\n ThriftServer* server_;\n muduo::net::TcpConnectionPtr conn_;\n\n boost::shared_ptr nullTransport_;\n\n boost::shared_ptr inputTransport_;\n boost::shared_ptr outputTransport_;\n\n boost::shared_ptr factoryInputTransport_;\n boost::shared_ptr factoryOutputTransport_;\n\n boost::shared_ptr inputProtocol_;\n boost::shared_ptr outputProtocol_;\n\n boost::shared_ptr processor_;\n\n enum State state_;\n uint32_t frameSize_;\n};\n\ntypedef boost::shared_ptr ThriftConnectionPtr;\n\n#endif // MUDUO_CONTRIB_THRIFT_THRIFTCONNECTION_H\n" }, { "path": "contrib/thrift/ThriftServer.cc", "content": "#include \"contrib/thrift/ThriftServer.h\"\n\n#include \n\n#include \"muduo/net/EventLoop.h\"\n\nusing muduo::MutexLockGuard;\nusing muduo::Timestamp;\nusing muduo::net::EventLoop;\nusing muduo::net::TcpConnectionPtr;\n\nThriftServer::~ThriftServer() = default;\n\nvoid ThriftServer::serve()\n{\n start();\n}\n\nvoid ThriftServer::start()\n{\n if (numWorkerThreads_ > 0)\n {\n workerThreadPool_.start(numWorkerThreads_);\n }\n server_.start();\n}\n\nvoid ThriftServer::stop()\n{\n if (numWorkerThreads_ > 0)\n {\n workerThreadPool_.stop();\n }\n server_.getLoop()->runAfter(3.0, std::bind(&EventLoop::quit,\n server_.getLoop()));\n}\n\nvoid ThriftServer::onConnection(const TcpConnectionPtr& conn)\n{\n if (conn->connected())\n {\n ThriftConnectionPtr ptr(new ThriftConnection(this, conn));\n MutexLockGuard lock(mutex_);\n assert(conns_.find(conn->name()) == conns_.end());\n conns_[conn->name()] = ptr;\n }\n else\n {\n MutexLockGuard lock(mutex_);\n assert(conns_.find(conn->name()) != conns_.end());\n conns_.erase(conn->name());\n }\n}\n" }, { "path": "contrib/thrift/ThriftServer.h", "content": "#ifndef MUDUO_CONTRIB_THRIFT_THRIFTSERVER_H\n#define MUDUO_CONTRIB_THRIFT_THRIFTSERVER_H\n\n#include \n#include \n\n#include \n\n#include \"muduo/base/ThreadPool.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n\n#include \"contrib/thrift/ThriftConnection.h\"\n\nusing apache::thrift::TProcessor;\nusing apache::thrift::TProcessorFactory;\nusing apache::thrift::protocol::TProtocolFactory;\nusing apache::thrift::server::TServer;\nusing apache::thrift::transport::TTransportFactory;\n\nclass ThriftServer : boost::noncopyable,\n public TServer\n{\n public:\n ThriftServer(const boost::shared_ptr& processorFactory,\n muduo::net::EventLoop* eventloop,\n const muduo::net::InetAddress& addr,\n const muduo::string& name)\n : TServer(processorFactory),\n server_(eventloop, addr, name),\n numWorkerThreads_(0),\n workerThreadPool_(name + muduo::string(\"WorkerThreadPool\"))\n {\n server_.setConnectionCallback(std::bind(&ThriftServer::onConnection,\n this, muduo::_1));\n }\n\n ThriftServer(const boost::shared_ptr& processor,\n muduo::net::EventLoop* eventloop,\n const muduo::net::InetAddress& addr,\n const muduo::string& name)\n : TServer(processor),\n server_(eventloop, addr, name),\n numWorkerThreads_(0),\n workerThreadPool_(name + muduo::string(\"WorkerThreadPool\"))\n {\n server_.setConnectionCallback(std::bind(&ThriftServer::onConnection,\n this, muduo::_1));\n }\n\n ThriftServer(const boost::shared_ptr& processorFactory,\n const boost::shared_ptr& protocolFactory,\n muduo::net::EventLoop* eventloop,\n const muduo::net::InetAddress& addr,\n const muduo::string& name)\n : TServer(processorFactory),\n server_(eventloop, addr, name),\n numWorkerThreads_(0),\n workerThreadPool_(name + muduo::string(\"WorkerThreadPool\"))\n {\n server_.setConnectionCallback(std::bind(&ThriftServer::onConnection,\n this, muduo::_1));\n setInputProtocolFactory(protocolFactory);\n setOutputProtocolFactory(protocolFactory);\n }\n\n ThriftServer(const boost::shared_ptr& processor,\n const boost::shared_ptr& protocolFactory,\n muduo::net::EventLoop* eventloop,\n const muduo::net::InetAddress& addr,\n const muduo::string& name)\n : TServer(processor),\n server_(eventloop, addr, name),\n numWorkerThreads_(0),\n workerThreadPool_(name + muduo::string(\"WorkerThreadPool\"))\n {\n server_.setConnectionCallback(std::bind(&ThriftServer::onConnection,\n this, muduo::_1));\n setInputProtocolFactory(protocolFactory);\n setOutputProtocolFactory(protocolFactory);\n }\n\n ThriftServer(const boost::shared_ptr& processorFactory,\n const boost::shared_ptr& transportFactory,\n const boost::shared_ptr& protocolFactory,\n muduo::net::EventLoop* eventloop,\n const muduo::net::InetAddress& addr,\n const muduo::string& name)\n : TServer(processorFactory),\n server_(eventloop, addr, name),\n numWorkerThreads_(0),\n workerThreadPool_(name + muduo::string(\"WorkerThreadPool\"))\n {\n server_.setConnectionCallback(std::bind(&ThriftServer::onConnection,\n this, muduo::_1));\n setInputTransportFactory(transportFactory);\n setOutputTransportFactory(transportFactory);\n setInputProtocolFactory(protocolFactory);\n setOutputProtocolFactory(protocolFactory);\n }\n\n ThriftServer(const boost::shared_ptr& processor,\n const boost::shared_ptr& transportFactory,\n const boost::shared_ptr& protocolFactory,\n muduo::net::EventLoop* eventloop,\n const muduo::net::InetAddress& addr,\n const muduo::string& name)\n : TServer(processor),\n server_(eventloop, addr, name),\n numWorkerThreads_(0),\n workerThreadPool_(name + muduo::string(\"WorkerThreadPool\"))\n {\n server_.setConnectionCallback(std::bind(&ThriftServer::onConnection,\n this, muduo::_1));\n setInputTransportFactory(transportFactory);\n setOutputTransportFactory(transportFactory);\n setInputProtocolFactory(protocolFactory);\n setOutputProtocolFactory(protocolFactory);\n }\n\n ThriftServer(const boost::shared_ptr& processorFactory,\n const boost::shared_ptr& inputTransportFactory,\n const boost::shared_ptr& outputTransportFactory,\n const boost::shared_ptr& inputProtocolFactory,\n const boost::shared_ptr& outputProtocolFactory,\n muduo::net::EventLoop* eventloop,\n const muduo::net::InetAddress& addr,\n const muduo::string& name)\n : TServer(processorFactory),\n server_(eventloop, addr, name),\n numWorkerThreads_(0),\n workerThreadPool_(name + muduo::string(\"WorkerThreadPool\"))\n {\n server_.setConnectionCallback(std::bind(&ThriftServer::onConnection,\n this, muduo::_1));\n setInputTransportFactory(inputTransportFactory);\n setOutputTransportFactory(outputTransportFactory);\n setInputProtocolFactory(inputProtocolFactory);\n setOutputProtocolFactory(outputProtocolFactory);\n }\n\n ThriftServer(const boost::shared_ptr& processor,\n const boost::shared_ptr& inputTransportFactory,\n const boost::shared_ptr& outputTransportFactory,\n const boost::shared_ptr& inputProtocolFactory,\n const boost::shared_ptr& outputProtocolFactory,\n muduo::net::EventLoop* eventloop,\n const muduo::net::InetAddress& addr,\n const muduo::string& name)\n : TServer(processor),\n server_(eventloop, addr, name),\n numWorkerThreads_(0),\n workerThreadPool_(name + muduo::string(\"WorkerThreadPool\"))\n {\n server_.setConnectionCallback(std::bind(&ThriftServer::onConnection,\n this, muduo::_1));\n setInputTransportFactory(inputTransportFactory);\n setOutputTransportFactory(outputTransportFactory);\n setInputProtocolFactory(inputProtocolFactory);\n setOutputProtocolFactory(outputProtocolFactory);\n }\n\n virtual ~ThriftServer();\n\n void serve();\n\n void start();\n\n void stop();\n\n muduo::ThreadPool& workerThreadPool()\n {\n return workerThreadPool_;\n }\n\n bool isWorkerThreadPoolProcessing() const\n {\n return numWorkerThreads_ != 0;\n }\n\n void setThreadNum(int numThreads)\n {\n server_.setThreadNum(numThreads);\n }\n\n void setWorkerThreadNum(int numWorkerThreads)\n {\n assert(numWorkerThreads > 0);\n numWorkerThreads_ = numWorkerThreads;\n }\n\n private:\n friend class ThriftConnection;\n\n void onConnection(const muduo::net::TcpConnectionPtr& conn);\n\n private:\n muduo::net::TcpServer server_;\n int numWorkerThreads_;\n muduo::ThreadPool workerThreadPool_;\n muduo::MutexLock mutex_;\n std::map conns_;\n};\n\n#endif // MUDUO_CONTRIB_THRIFT_THRIFTSERVER_H\n" }, { "path": "contrib/thrift/tests/.gitignore", "content": "gen-cpp\ngen-py\n" }, { "path": "contrib/thrift/tests/CMakeLists.txt", "content": "add_subdirectory(echo)\nadd_subdirectory(ping)\n" }, { "path": "contrib/thrift/tests/echo/CMakeLists.txt", "content": "include_directories(gen-cpp)\nset(ECHO_THRIFT echo.thrift)\nexecute_process(COMMAND ${THRIFT_COMPILER} --gen cpp ${ECHO_THRIFT}\n WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})\nexecute_process(COMMAND ${THRIFT_COMPILER} --gen py ${ECHO_THRIFT}\n WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})\nset(ECHO_THRIFT_SRCS\n gen-cpp/echo_constants.cpp\n gen-cpp/echo_types.cpp\n gen-cpp/Echo.cpp\n )\nset(ECHO_SRCS\n EchoServer.cc\n )\nadd_executable(muduo_thrift_echo ${ECHO_SRCS} ${ECHO_THRIFT_SRCS})\ntarget_link_libraries(muduo_thrift_echo muduo_thrift)\n" }, { "path": "contrib/thrift/tests/echo/EchoServer.cc", "content": "#include \n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n\n#include \"ThriftServer.h\"\n\n#include \"Echo.h\"\n\nusing namespace muduo;\nusing namespace muduo::net;\n\nusing namespace echo;\n\nclass EchoHandler : virtual public EchoIf\n{\n public:\n EchoHandler()\n {\n }\n\n void echo(std::string& str, const std::string& s)\n {\n LOG_INFO << \"EchoHandler::echo:\" << s;\n str = s;\n }\n\n};\n\nint NumCPU()\n{\n return static_cast(sysconf(_SC_NPROCESSORS_ONLN));\n}\n\nint main(int argc, char **argv)\n{\n EventLoop eventloop;\n InetAddress addr(\"127.0.0.1\", 9090);\n string name(\"EchoServer\");\n\n boost::shared_ptr handler(new EchoHandler());\n boost::shared_ptr processor(new EchoProcessor(handler));\n\n ThriftServer server(processor, &eventloop, addr, name);\n server.setWorkerThreadNum(NumCPU() * 2);\n server.start();\n eventloop.loop();\n\n return 0;\n}\n\n" }, { "path": "contrib/thrift/tests/echo/echo.thrift", "content": "namespace cpp echo\nnamespace py echo\n\nservice Echo\n{\n string echo(1: string arg);\n}\n\n" }, { "path": "contrib/thrift/tests/echo/echoclient.py", "content": "import sys\nsys.path.append('gen-py')\n\nfrom thrift.transport import TSocket\nfrom thrift.transport import TTransport\nfrom thrift.protocol import TBinaryProtocol\n\nfrom echo import Echo\n\n\ndef echo(s):\n transport = TSocket.TSocket('127.0.0.1', 9090)\n tranport = TTransport.TFramedTransport(transport)\n protocol = TBinaryProtocol.TBinaryProtocol(tranport)\n client = Echo.Client(protocol)\n tranport.open()\n s = client.echo(s)\n tranport.close()\n\n return s\n\n\ndef main():\n print(echo('42'))\n\n\nif __name__ == '__main__':\n main()\n" }, { "path": "contrib/thrift/tests/ping/CMakeLists.txt", "content": "include_directories(gen-cpp)\nset(PING_THRIFT ping.thrift)\nexecute_process(COMMAND ${THRIFT_COMPILER} --gen cpp ${PING_THRIFT}\n WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})\nexecute_process(COMMAND ${THRIFT_COMPILER} --gen py ${PING_THRIFT}\n WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})\nset(PING_THRIFT_SRCS\n gen-cpp/ping_constants.cpp\n gen-cpp/ping_types.cpp\n gen-cpp/Ping.cpp\n )\nset(PING_SRCS\n PingServer.cc\n )\nadd_executable(muduo_thrift_ping ${PING_SRCS} ${PING_THRIFT_SRCS})\ntarget_link_libraries(muduo_thrift_ping muduo_thrift)\n" }, { "path": "contrib/thrift/tests/ping/PingServer.cc", "content": "#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n\n#include \n\n#include \"ThriftServer.h\"\n\n#include \"Ping.h\"\n\nusing namespace muduo;\nusing namespace muduo::net;\n\nusing apache::thrift::protocol::TCompactProtocolFactory;\n\nusing namespace ping;\n\nclass PingHandler : virtual public PingIf\n{\n public:\n PingHandler()\n {\n }\n\n void ping()\n {\n LOG_INFO << \"ping\";\n }\n\n};\n\nint main(int argc, char **argv)\n{\n EventLoop eventloop;\n InetAddress addr(\"127.0.0.1\", 9090);\n string name(\"PingServer\");\n\n boost::shared_ptr handler(new PingHandler());\n boost::shared_ptr processor(new PingProcessor(handler));\n boost::shared_ptr protcolFactory(new TCompactProtocolFactory());\n\n ThriftServer server(processor, protcolFactory, &eventloop, addr, name);\n server.start();\n eventloop.loop();\n\n return 0;\n}\n\n" }, { "path": "contrib/thrift/tests/ping/ping.thrift", "content": "namespace cpp ping\nnamespace py ping\n\nservice Ping\n{\n void ping();\n}\n\n" }, { "path": "contrib/thrift/tests/ping/pingclient.py", "content": "import sys\nsys.path.append('gen-py')\n\nfrom thrift.transport import TSocket\nfrom thrift.transport import TTransport\nfrom thrift.protocol import TCompactProtocol\n\nfrom ping import Ping\n\n\ndef ping():\n transport = TSocket.TSocket('127.0.0.1', 9090)\n tranport = TTransport.TFramedTransport(transport)\n protocol = TCompactProtocol.TCompactProtocol(tranport)\n client = Ping.Client(protocol)\n tranport.open()\n client.ping()\n tranport.close()\n\n\ndef main():\n ping()\n\n\nif __name__ == '__main__':\n main()\n" }, { "path": "examples/CMakeLists.txt", "content": "add_subdirectory(ace/ttcp)\nadd_subdirectory(asio/chat)\nadd_subdirectory(asio/tutorial)\nadd_subdirectory(fastcgi)\nadd_subdirectory(filetransfer)\nadd_subdirectory(hub)\nadd_subdirectory(idleconnection)\nadd_subdirectory(maxconnection)\nadd_subdirectory(memcached/client)\nadd_subdirectory(memcached/server)\nadd_subdirectory(multiplexer)\nadd_subdirectory(netty/discard)\nadd_subdirectory(netty/echo)\nadd_subdirectory(netty/uptime)\nadd_subdirectory(pingpong)\nadd_subdirectory(roundtrip)\nadd_subdirectory(shorturl)\nadd_subdirectory(simple)\nadd_subdirectory(socks4a)\nadd_subdirectory(sudoku)\nadd_subdirectory(twisted/finger)\nadd_subdirectory(wordcount)\nadd_subdirectory(zeromq)\n\nif(CARES_INCLUDE_DIR AND CARES_LIBRARY)\n add_subdirectory(cdns)\nelse()\n add_subdirectory(cdns EXCLUDE_FROM_ALL)\nendif()\n\nif(CURL_FOUND)\n add_subdirectory(curl)\nelse()\n add_subdirectory(curl EXCLUDE_FROM_ALL)\nendif()\n\nif(PROTOBUF_FOUND)\n add_subdirectory(ace/logging)\n add_subdirectory(protobuf)\nelse()\n add_subdirectory(ace/logging EXCLUDE_FROM_ALL)\n add_subdirectory(protobuf EXCLUDE_FROM_ALL)\nendif()\n\nif(GD_INCLUDE_DIR AND GD_LIBRARY)\n add_subdirectory(procmon)\nelse()\n add_subdirectory(procmon EXCLUDE_FROM_ALL)\nendif()\n" }, { "path": "examples/ace/logging/CMakeLists.txt", "content": "add_custom_command(OUTPUT logrecord.pb.cc logrecord.pb.h\n COMMAND protoc\n ARGS --cpp_out . ${CMAKE_CURRENT_SOURCE_DIR}/logrecord.proto -I${CMAKE_CURRENT_SOURCE_DIR}\n DEPENDS logrecord.proto\n VERBATIM )\n\nset_source_files_properties(logrecord.pb.cc PROPERTIES COMPILE_FLAGS \"-Wno-conversion -Wno-shadow\")\ninclude_directories(${PROJECT_BINARY_DIR})\n\nadd_library(ace_logging_proto logrecord.pb.cc)\ntarget_link_libraries(ace_logging_proto protobuf pthread)\n\nadd_executable(ace_logging_client client.cc)\nset_target_properties(ace_logging_client PROPERTIES COMPILE_FLAGS \"-Wno-error=shadow\")\ntarget_link_libraries(ace_logging_client muduo_protobuf_codec ace_logging_proto)\n\nadd_executable(ace_logging_server server.cc)\nset_target_properties(ace_logging_server PROPERTIES COMPILE_FLAGS \"-Wno-error=shadow\")\ntarget_link_libraries(ace_logging_server muduo_protobuf_codec ace_logging_proto)\n" }, { "path": "examples/ace/logging/client.cc", "content": "#include \"examples/ace/logging/logrecord.pb.h\"\n\n#include \"muduo/base/Mutex.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/ProcessInfo.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/EventLoopThread.h\"\n#include \"muduo/net/TcpClient.h\"\n#include \"muduo/net/protobuf/ProtobufCodecLite.h\"\n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\n// just to verify the protocol, not for practical usage.\n\nnamespace logging\n{\nextern const char logtag[] = \"LOG0\";\ntypedef ProtobufCodecLiteT Codec;\n\n// same as asio/char/client.cc\nclass LogClient : noncopyable\n{\n public:\n LogClient(EventLoop* loop, const InetAddress& serverAddr)\n : client_(loop, serverAddr, \"LogClient\"),\n codec_(std::bind(&LogClient::onMessage, this, _1, _2, _3))\n {\n client_.setConnectionCallback(\n std::bind(&LogClient::onConnection, this, _1));\n client_.setMessageCallback(\n std::bind(&Codec::onMessage, &codec_, _1, _2, _3));\n client_.enableRetry();\n }\n\n void connect()\n {\n client_.connect();\n }\n\n void disconnect()\n {\n client_.disconnect();\n }\n\n void write(const StringPiece& message)\n {\n MutexLockGuard lock(mutex_);\n updateLogRecord(message);\n if (connection_)\n {\n codec_.send(connection_, logRecord_);\n }\n else\n {\n LOG_WARN << \"NOT CONNECTED\";\n }\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_INFO << conn->localAddress().toIpPort() << \" -> \"\n << conn->peerAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n MutexLockGuard lock(mutex_);\n if (conn->connected())\n {\n connection_ = conn;\n LogRecord_Heartbeat* hb = logRecord_.mutable_heartbeat();\n hb->set_hostname(ProcessInfo::hostname().c_str());\n hb->set_process_name(ProcessInfo::procname().c_str());\n hb->set_process_id(ProcessInfo::pid());\n hb->set_process_start_time(ProcessInfo::startTime().microSecondsSinceEpoch());\n hb->set_username(ProcessInfo::username().c_str());\n updateLogRecord(\"Heartbeat\");\n codec_.send(connection_, logRecord_);\n logRecord_.clear_heartbeat();\n LOG_INFO << \"Type message below:\";\n }\n else\n {\n connection_.reset();\n }\n }\n\n void onMessage(const TcpConnectionPtr&,\n const MessagePtr& message,\n Timestamp)\n {\n // SHOULD NOT HAPPEN\n LogRecord* logRecord = muduo::down_cast(message.get());\n LOG_WARN << logRecord->DebugString();\n }\n\n void updateLogRecord(const StringPiece& message) REQUIRES(mutex_)\n {\n mutex_.assertLocked();\n logRecord_.set_level(1);\n logRecord_.set_thread_id(CurrentThread::tid());\n logRecord_.set_timestamp(Timestamp::now().microSecondsSinceEpoch());\n logRecord_.set_message(message.data(), message.size());\n }\n\n TcpClient client_;\n Codec codec_;\n MutexLock mutex_;\n LogRecord logRecord_ GUARDED_BY(mutex_);\n TcpConnectionPtr connection_ GUARDED_BY(mutex_);\n};\n\n} // namespace logging\n\nint main(int argc, char* argv[])\n{\n if (argc < 3)\n {\n printf(\"usage: %s server_ip server_port\\n\", argv[0]);\n }\n else\n {\n EventLoopThread loopThread;\n uint16_t port = static_cast(atoi(argv[2]));\n InetAddress serverAddr(argv[1], port);\n\n logging::LogClient client(loopThread.startLoop(), serverAddr);\n client.connect();\n std::string line;\n while (std::getline(std::cin, line))\n {\n client.write(line);\n }\n client.disconnect();\n CurrentThread::sleepUsec(1000*1000); // wait for disconnect, then safe to destruct LogClient (esp. TcpClient). Otherwise mutex_ is used after dtor.\n }\n google::protobuf::ShutdownProtobufLibrary();\n}\n" }, { "path": "examples/ace/logging/logrecord.proto", "content": "package logging;\n\nmessage LogRecord {\n // must present in first message\n message Heartbeat {\n required string hostname = 1;\n required string process_name = 2;\n required int32 process_id = 3;\n required int64 process_start_time = 4; // microseconds sinch epoch\n required string username = 5;\n }\n\n optional Heartbeat heartbeat = 1;\n // muduo/base/Logging.h\n // enum LogLevel\n // {\n // TRACE, // 0\n // DEBUG, // 1\n // INFO, // 2\n // WARN, // 3\n // ERROR, // 4\n // FATAL, // 5\n // };\n required int32 level = 2;\n required int32 thread_id = 3;\n required int64 timestamp = 4; // microseconds sinch epoch\n required string message = 5;\n // optional: source file, source line, function name\n}\n" }, { "path": "examples/ace/logging/server.cc", "content": "#include \"examples/ace/logging/logrecord.pb.h\"\n\n#include \"muduo/base/Atomic.h\"\n#include \"muduo/base/FileUtil.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n#include \"muduo/net/protobuf/ProtobufCodecLite.h\"\n\n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nnamespace logging\n{\nextern const char logtag[] = \"LOG0\";\ntypedef ProtobufCodecLiteT Codec;\n\nclass Session : noncopyable\n{\n public:\n explicit Session(const TcpConnectionPtr& conn)\n : codec_(std::bind(&Session::onMessage, this, _1, _2, _3)),\n file_(getFileName(conn))\n {\n conn->setMessageCallback(\n std::bind(&Codec::onMessage, &codec_, _1, _2, _3));\n }\n\n private:\n\n // FIXME: duplicate code LogFile\n // or use LogFile instead\n string getFileName(const TcpConnectionPtr& conn)\n {\n string filename;\n filename += conn->peerAddress().toIp();\n\n char timebuf[32];\n struct tm tm;\n time_t now = time(NULL);\n gmtime_r(&now, &tm); // FIXME: localtime_r ?\n strftime(timebuf, sizeof timebuf, \".%Y%m%d-%H%M%S.\", &tm);\n filename += timebuf;\n\n char buf[32];\n snprintf(buf, sizeof buf, \"%d\", globalCount_.incrementAndGet());\n filename += buf;\n\n filename += \".log\";\n LOG_INFO << \"Session of \" << conn->name() << \" file \" << filename;\n return filename;\n }\n\n void onMessage(const TcpConnectionPtr& conn,\n const MessagePtr& message,\n Timestamp time)\n {\n LogRecord* logRecord = muduo::down_cast(message.get());\n if (logRecord->has_heartbeat())\n {\n // FIXME ?\n }\n const char* sep = \"==========\\n\";\n std::string str = logRecord->DebugString();\n file_.append(str.c_str(), str.size());\n file_.append(sep, strlen(sep));\n LOG_DEBUG << str;\n }\n\n Codec codec_;\n FileUtil::AppendFile file_;\n static AtomicInt32 globalCount_;\n};\ntypedef std::shared_ptr SessionPtr;\n\nAtomicInt32 Session::globalCount_;\n\nclass LogServer : noncopyable\n{\n public:\n LogServer(EventLoop* loop, const InetAddress& listenAddr, int numThreads)\n : loop_(loop),\n server_(loop_, listenAddr, \"AceLoggingServer\")\n {\n server_.setConnectionCallback(\n std::bind(&LogServer::onConnection, this, _1));\n if (numThreads > 1)\n {\n server_.setThreadNum(numThreads);\n }\n }\n\n void start()\n {\n server_.start();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n if (conn->connected())\n {\n SessionPtr session(new Session(conn));\n conn->setContext(session);\n }\n else\n {\n conn->setContext(SessionPtr());\n }\n }\n\n EventLoop* loop_;\n TcpServer server_;\n};\n\n} // namespace logging\n\nint main(int argc, char* argv[])\n{\n EventLoop loop;\n int port = argc > 1 ? atoi(argv[1]) : 50000;\n LOG_INFO << \"Listen on port \" << port;\n InetAddress listenAddr(static_cast(port));\n int numThreads = argc > 2 ? atoi(argv[2]) : 1;\n logging::LogServer server(&loop, listenAddr, numThreads);\n server.start();\n loop.loop();\n\n}\n" }, { "path": "examples/ace/ttcp/CMakeLists.txt", "content": "if(BOOSTPO_LIBRARY)\n add_executable(ttcp_blocking ttcp_blocking.cc common.cc main.cc)\n target_link_libraries(ttcp_blocking muduo_base boost_program_options)\n set_target_properties(ttcp_blocking PROPERTIES COMPILE_FLAGS \"-Wno-error=old-style-cast -Wno-error=conversion\")\n\n add_executable(ttcp_muduo ttcp.cc common.cc main.cc)\n target_link_libraries(ttcp_muduo muduo_net boost_program_options)\n\n if(BOOSTSYSTEM_LIBRARY)\n add_executable(ttcp_asio_sync ttcp_asio_sync.cc common.cc main.cc)\n target_link_libraries(ttcp_asio_sync muduo_base boost_program_options boost_system)\n\n add_executable(ttcp_asio_async ttcp_asio_async.cc common.cc main.cc)\n target_link_libraries(ttcp_asio_async muduo_base boost_program_options boost_system)\n endif()\nendif()\n\n" }, { "path": "examples/ace/ttcp/common.cc", "content": "#include \"examples/ace/ttcp/common.h\"\n#include \"muduo/base/Types.h\"\n\n#include \n\n#include \n\n#include \n#include \n\nnamespace po = boost::program_options;\n\nbool parseCommandLine(int argc, char* argv[], Options* opt)\n{\n po::options_description desc(\"Allowed options\");\n desc.add_options()\n (\"help,h\", \"Help\")\n (\"port,p\", po::value(&opt->port)->default_value(5001), \"TCP port\")\n (\"length,l\", po::value(&opt->length)->default_value(65536), \"Buffer length\")\n (\"number,n\", po::value(&opt->number)->default_value(8192), \"Number of buffers\")\n (\"trans,t\", po::value(&opt->host), \"Transmit\")\n (\"recv,r\", \"Receive\")\n (\"nodelay,D\", \"set TCP_NODELAY\")\n ;\n\n po::variables_map vm;\n po::store(po::parse_command_line(argc, argv, desc), vm);\n po::notify(vm);\n\n opt->transmit = vm.count(\"trans\");\n opt->receive = vm.count(\"recv\");\n opt->nodelay = vm.count(\"nodelay\");\n if (vm.count(\"help\"))\n {\n std::cout << desc << std::endl;\n return false;\n }\n\n if (opt->transmit == opt->receive)\n {\n printf(\"either -t or -r must be specified.\\n\");\n return false;\n }\n\n printf(\"port = %d\\n\", opt->port);\n if (opt->transmit)\n {\n printf(\"buffer length = %d\\n\", opt->length);\n printf(\"number of buffers = %d\\n\", opt->number);\n }\n else\n {\n printf(\"accepting...\\n\");\n }\n return true;\n}\n\n#pragma GCC diagnostic ignored \"-Wold-style-cast\"\n\nstruct sockaddr_in resolveOrDie(const char* host, uint16_t port)\n{\n struct hostent* he = ::gethostbyname(host);\n if (!he)\n {\n perror(\"gethostbyname\");\n exit(1);\n }\n assert(he->h_addrtype == AF_INET && he->h_length == sizeof(uint32_t));\n struct sockaddr_in addr;\n muduo::memZero(&addr, sizeof(addr));\n addr.sin_family = AF_INET;\n addr.sin_port = htons(port);\n addr.sin_addr = *reinterpret_cast(he->h_addr);\n return addr;\n}\n\n" }, { "path": "examples/ace/ttcp/common.h", "content": "#pragma once\n\n#include \n#include \n\nstruct Options\n{\n uint16_t port;\n int length;\n int number;\n bool transmit, receive, nodelay;\n std::string host;\n Options()\n : port(0), length(0), number(0),\n transmit(false), receive(false), nodelay(false)\n {\n }\n};\n\nbool parseCommandLine(int argc, char* argv[], Options* opt);\nstruct sockaddr_in resolveOrDie(const char* host, uint16_t port);\n\nstruct SessionMessage\n{\n int32_t number;\n int32_t length;\n} __attribute__ ((__packed__));\n\nstruct PayloadMessage\n{\n int32_t length;\n char data[0];\n};\n\nvoid transmit(const Options& opt);\n\nvoid receive(const Options& opt);\n" }, { "path": "examples/ace/ttcp/main.cc", "content": "#include \"examples/ace/ttcp/common.h\"\n\n#include \n\nint main(int argc, char* argv[])\n{\n Options options;\n if (parseCommandLine(argc, argv, &options))\n {\n if (options.transmit)\n {\n transmit(options);\n }\n else if (options.receive)\n {\n receive(options);\n }\n else\n {\n assert(0);\n }\n }\n}\n\n" }, { "path": "examples/ace/ttcp/ttcp.cc", "content": "#include \"examples/ace/ttcp/common.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpClient.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nEventLoop* g_loop;\n\nstruct Context\n{\n int count;\n int64_t bytes;\n SessionMessage session;\n Buffer output;\n\n Context()\n : count(0),\n bytes(0)\n {\n session.number = 0;\n session.length = 0;\n }\n};\n\n/////////////////////////////////////////////////////////////////////\n// T R A N S M I T\n/////////////////////////////////////////////////////////////////////\n\nnamespace trans\n{\n\nvoid onConnection(const Options& opt, const TcpConnectionPtr& conn)\n{\n if (conn->connected())\n {\n printf(\"connected\\n\");\n Context context;\n context.count = 1;\n context.bytes = opt.length;\n context.session.number = opt.number;\n context.session.length = opt.length;\n context.output.appendInt32(opt.length);\n context.output.ensureWritableBytes(opt.length);\n for (int i = 0; i < opt.length; ++i)\n {\n context.output.beginWrite()[i] = \"0123456789ABCDEF\"[i % 16];\n }\n context.output.hasWritten(opt.length);\n conn->setContext(context);\n\n SessionMessage sessionMessage = { 0, 0 };\n sessionMessage.number = htonl(opt.number);\n sessionMessage.length = htonl(opt.length);\n conn->send(&sessionMessage, sizeof(sessionMessage));\n\n conn->send(context.output.toStringPiece());\n }\n else\n {\n const Context& context = boost::any_cast(conn->getContext());\n LOG_INFO << \"payload bytes \" << context.bytes;\n conn->getLoop()->quit();\n }\n}\n\nvoid onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp time)\n{\n Context* context = boost::any_cast(conn->getMutableContext());\n while (buf->readableBytes() >= sizeof(int32_t))\n {\n int32_t length = buf->readInt32();\n if (length == context->session.length)\n {\n if (context->count < context->session.number)\n {\n conn->send(context->output.toStringPiece());\n ++context->count;\n context->bytes += length;\n }\n else\n {\n conn->shutdown();\n break;\n }\n }\n else\n {\n conn->shutdown();\n break;\n }\n }\n}\n\n} // namespace trans\n\nvoid transmit(const Options& opt)\n{\n InetAddress addr(opt.port);\n if (!InetAddress::resolve(opt.host, &addr))\n {\n LOG_FATAL << \"Unable to resolve \" << opt.host;\n }\n muduo::Timestamp start(muduo::Timestamp::now());\n EventLoop loop;\n g_loop = &loop;\n TcpClient client(&loop, addr, \"TtcpClient\");\n client.setConnectionCallback(\n std::bind(&trans::onConnection, opt, _1));\n client.setMessageCallback(\n std::bind(&trans::onMessage, _1, _2, _3));\n client.connect();\n loop.loop();\n double elapsed = timeDifference(muduo::Timestamp::now(), start);\n double total_mb = 1.0 * opt.length * opt.number / 1024 / 1024;\n printf(\"%.3f MiB transferred\\n%.3f MiB/s\\n\", total_mb, total_mb / elapsed);\n}\n\n/////////////////////////////////////////////////////////////////////\n// R E C E I V E\n/////////////////////////////////////////////////////////////////////\n\nnamespace receiving\n{\n\nvoid onConnection(const TcpConnectionPtr& conn)\n{\n if (conn->connected())\n {\n Context context;\n conn->setContext(context);\n }\n else\n {\n const Context& context = boost::any_cast(conn->getContext());\n LOG_INFO << \"payload bytes \" << context.bytes;\n conn->getLoop()->quit();\n }\n}\n\nvoid onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp time)\n{\n while (buf->readableBytes() >= sizeof(int32_t))\n {\n Context* context = boost::any_cast(conn->getMutableContext());\n SessionMessage& session = context->session;\n if (session.number == 0 && session.length == 0)\n {\n if (buf->readableBytes() >= sizeof(SessionMessage))\n {\n session.number = buf->readInt32();\n session.length = buf->readInt32();\n context->output.appendInt32(session.length);\n printf(\"receive number = %d\\nreceive length = %d\\n\",\n session.number, session.length);\n }\n else\n {\n break;\n }\n }\n else\n {\n const unsigned total_len = session.length + static_cast(sizeof(int32_t));\n const int32_t length = buf->peekInt32();\n if (length == session.length)\n {\n if (buf->readableBytes() >= total_len)\n {\n buf->retrieve(total_len);\n conn->send(context->output.toStringPiece());\n ++context->count;\n context->bytes += length;\n if (context->count >= session.number)\n {\n conn->shutdown();\n break;\n }\n }\n else\n {\n break;\n }\n }\n else\n {\n printf(\"wrong length %d\\n\", length);\n conn->shutdown();\n break;\n }\n }\n }\n}\n\n} // namespace receiving\n\nvoid receive(const Options& opt)\n{\n EventLoop loop;\n g_loop = &loop;\n InetAddress listenAddr(opt.port);\n TcpServer server(&loop, listenAddr, \"TtcpReceive\");\n server.setConnectionCallback(\n std::bind(&receiving::onConnection, _1));\n server.setMessageCallback(\n std::bind(&receiving::onMessage, _1, _2, _3));\n server.start();\n loop.loop();\n}\n" }, { "path": "examples/ace/ttcp/ttcp_asio_async.cc", "content": "#include \"examples/ace/ttcp/common.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \n#include \n\nusing boost::asio::ip::tcp;\n\nvoid transmit(const Options& opt)\n{\n try\n {\n }\n catch (std::exception& e)\n {\n LOG_ERROR << e.what();\n }\n}\n\nclass TtcpServerConnection : public std::enable_shared_from_this,\n muduo::noncopyable\n{\n public:\n#if BOOST_VERSION < 107000L\n TtcpServerConnection(boost::asio::io_service& io_service)\n : socket_(io_service), count_(0), payload_(NULL), ack_(0)\n#else\n TtcpServerConnection(const tcp::socket::executor_type& executor)\n : socket_(executor), count_(0), payload_(NULL), ack_(0)\n#endif\n {\n sessionMessage_.number = 0;\n sessionMessage_.length = 0;\n }\n\n ~TtcpServerConnection()\n {\n ::free(payload_);\n }\n\n tcp::socket& socket() { return socket_; }\n\n void start()\n {\n std::ostringstream oss;\n oss << socket_.remote_endpoint();\n LOG_INFO << \"Got connection from \" << oss.str();\n doReadSession();\n }\n\n private:\n void doReadSession()\n {\n auto self(shared_from_this());\n boost::asio::async_read(\n socket_, boost::asio::buffer(&sessionMessage_, sizeof(sessionMessage_)),\n [this, self](const boost::system::error_code& error, size_t len)\n {\n if (!error && len == sizeof sessionMessage_)\n {\n sessionMessage_.number = ntohl(sessionMessage_.number);\n sessionMessage_.length = ntohl(sessionMessage_.length);\n printf(\"receive number = %d\\nreceive length = %d\\n\",\n sessionMessage_.number, sessionMessage_.length);\n const int total_len = static_cast(sizeof(int32_t) + sessionMessage_.length);\n payload_ = static_cast(::malloc(total_len));\n doReadLength();\n }\n else\n {\n LOG_ERROR << \"read session message: \" << error.message();\n }\n });\n }\n\n void doReadLength()\n {\n auto self(shared_from_this());\n payload_->length = 0;\n boost::asio::async_read(\n socket_, boost::asio::buffer(&payload_->length, sizeof payload_->length),\n [this, self](const boost::system::error_code& error, size_t len)\n {\n if (!error && len == sizeof payload_->length)\n {\n payload_->length = ntohl(payload_->length);\n doReadPayload();\n }\n else\n {\n LOG_ERROR << \"read length: \" << error.message();\n }\n });\n }\n\n void doReadPayload()\n {\n assert(payload_->length == sessionMessage_.length);\n auto self(shared_from_this());\n boost::asio::async_read(\n socket_, boost::asio::buffer(&payload_->data, payload_->length),\n [this, self](const boost::system::error_code& error, size_t len)\n {\n if (!error && len == static_cast(payload_->length))\n {\n doWriteAck();\n }\n else\n {\n LOG_ERROR << \"read payload data: \" << error.message();\n }\n });\n }\n\n void doWriteAck()\n {\n auto self(shared_from_this());\n ack_ = htonl(payload_->length);\n boost::asio::async_write(\n socket_, boost::asio::buffer(&ack_, sizeof ack_),\n [this, self](const boost::system::error_code& error, size_t len)\n {\n if (!error && len == sizeof ack_)\n {\n if (++count_ < sessionMessage_.number)\n {\n doReadLength();\n }\n else\n {\n LOG_INFO << \"Done\";\n }\n }\n else\n {\n LOG_ERROR << \"write ack: \" << error.message();\n }\n });\n }\n\n tcp::socket socket_;\n int count_;\n struct SessionMessage sessionMessage_;\n struct PayloadMessage* payload_;\n int32_t ack_;\n};\ntypedef std::shared_ptr TtcpServerConnectionPtr;\n\nvoid doAccept(tcp::acceptor& acceptor)\n{\n#if BOOST_VERSION < 107000L\n // no need to pre-create new_connection if we use asio 1.12 or boost 1.66+\n TtcpServerConnectionPtr new_connection(new TtcpServerConnection(acceptor.get_io_service()));\n#else\n TtcpServerConnectionPtr new_connection(new TtcpServerConnection(acceptor.get_executor()));\n#endif\n acceptor.async_accept(\n new_connection->socket(),\n [&acceptor, new_connection](boost::system::error_code error) // move new_connection in C++14\n {\n if (!error)\n {\n new_connection->start();\n }\n doAccept(acceptor);\n });\n}\n\nvoid receive(const Options& opt)\n{\n try\n {\n boost::asio::io_service io_service;\n tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), opt.port));\n doAccept(acceptor);\n io_service.run();\n }\n catch (std::exception& e)\n {\n LOG_ERROR << e.what();\n }\n}\n\n" }, { "path": "examples/ace/ttcp/ttcp_asio_sync.cc", "content": "#include \"examples/ace/ttcp/common.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \n#include \n\nusing boost::asio::ip::tcp;\n\nvoid transmit(const Options& opt)\n{\n try\n {\n }\n catch (std::exception& e)\n {\n LOG_ERROR << e.what();\n }\n}\n\nvoid receive(const Options& opt)\n{\n try\n {\n boost::asio::io_service io_service;\n tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), opt.port));\n tcp::socket socket(io_service);\n acceptor.accept(socket);\n\n struct SessionMessage sessionMessage = { 0, 0 };\n boost::system::error_code error;\n size_t nr = boost::asio::read(socket, boost::asio::buffer(&sessionMessage, sizeof sessionMessage),\n#if BOOST_VERSION < 104700L\n boost::asio::transfer_all(),\n#endif\n error);\n if (nr != sizeof sessionMessage)\n {\n LOG_ERROR << \"read session message: \" << error.message();\n exit(1);\n }\n\n sessionMessage.number = ntohl(sessionMessage.number);\n sessionMessage.length = ntohl(sessionMessage.length);\n printf(\"receive number = %d\\nreceive length = %d\\n\",\n sessionMessage.number, sessionMessage.length);\n const int total_len = static_cast(sizeof(int32_t) + sessionMessage.length);\n PayloadMessage* payload = static_cast(::malloc(total_len));\n std::unique_ptr freeIt(payload, ::free);\n assert(payload);\n\n for (int i = 0; i < sessionMessage.number; ++i)\n {\n payload->length = 0;\n if (boost::asio::read(socket, boost::asio::buffer(&payload->length, sizeof(payload->length)),\n#if BOOST_VERSION < 104700L\n boost::asio::transfer_all(),\n#endif\n error) != sizeof(payload->length))\n {\n LOG_ERROR << \"read length: \" << error.message();\n exit(1);\n }\n payload->length = ntohl(payload->length);\n assert(payload->length == sessionMessage.length);\n if (boost::asio::read(socket, boost::asio::buffer(payload->data, payload->length),\n#if BOOST_VERSION < 104700L\n boost::asio::transfer_all(),\n#endif\n error) != static_cast(payload->length))\n {\n LOG_ERROR << \"read payload data: \" << error.message();\n exit(1);\n }\n int32_t ack = htonl(payload->length);\n if (boost::asio::write(socket, boost::asio::buffer(&ack, sizeof(ack))) != sizeof(ack))\n {\n LOG_ERROR << \"write ack: \" << error.message();\n exit(1);\n }\n }\n }\n catch (std::exception& e)\n {\n LOG_ERROR << e.what();\n }\n}\n" }, { "path": "examples/ace/ttcp/ttcp_blocking.cc", "content": "#include \"examples/ace/ttcp/common.h\"\n#include \"muduo/base/Timestamp.h\"\n#include \"muduo/base/Types.h\"\n\n#undef NDEBUG\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\nstatic int acceptOrDie(uint16_t port)\n{\n int listenfd = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);\n assert(listenfd >= 0);\n\n int yes = 1;\n if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)))\n {\n perror(\"setsockopt\");\n exit(1);\n }\n\n struct sockaddr_in addr;\n muduo::memZero(&addr, sizeof(addr));\n addr.sin_family = AF_INET;\n addr.sin_port = htons(port);\n addr.sin_addr.s_addr = INADDR_ANY;\n if (bind(listenfd, reinterpret_cast(&addr), sizeof(addr)))\n {\n perror(\"bind\");\n exit(1);\n }\n\n if (listen(listenfd, 5))\n {\n perror(\"listen\");\n exit(1);\n }\n\n struct sockaddr_in peer_addr;\n muduo::memZero(&peer_addr, sizeof(peer_addr));\n socklen_t addrlen = 0;\n int sockfd = ::accept(listenfd, reinterpret_cast(&peer_addr), &addrlen);\n if (sockfd < 0)\n {\n perror(\"accept\");\n exit(1);\n }\n ::close(listenfd);\n return sockfd;\n}\n\nstatic int write_n(int sockfd, const void* buf, int length)\n{\n int written = 0;\n while (written < length)\n {\n ssize_t nw = ::write(sockfd, static_cast(buf) + written, length - written);\n if (nw > 0)\n {\n written += static_cast(nw);\n }\n else if (nw == 0)\n {\n break; // EOF\n }\n else if (errno != EINTR)\n {\n perror(\"write\");\n break;\n }\n }\n return written;\n}\n\nstatic int read_n(int sockfd, void* buf, int length)\n{\n int nread = 0;\n while (nread < length)\n {\n ssize_t nr = ::read(sockfd, static_cast(buf) + nread, length - nread);\n if (nr > 0)\n {\n nread += static_cast(nr);\n }\n else if (nr == 0)\n {\n break; // EOF\n }\n else if (errno != EINTR)\n {\n perror(\"read\");\n break;\n }\n }\n return nread;\n}\n\nvoid transmit(const Options& opt)\n{\n struct sockaddr_in addr = resolveOrDie(opt.host.c_str(), opt.port);\n printf(\"connecting to %s:%d\\n\", inet_ntoa(addr.sin_addr), opt.port);\n\n int sockfd = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);\n assert(sockfd >= 0);\n int ret = ::connect(sockfd, reinterpret_cast(&addr), sizeof(addr));\n if (ret)\n {\n perror(\"connect\");\n printf(\"Unable to connect %s\\n\", opt.host.c_str());\n ::close(sockfd);\n return;\n }\n\n printf(\"connected\\n\");\n muduo::Timestamp start(muduo::Timestamp::now());\n struct SessionMessage sessionMessage = { 0, 0 };\n sessionMessage.number = htonl(opt.number);\n sessionMessage.length = htonl(opt.length);\n if (write_n(sockfd, &sessionMessage, sizeof(sessionMessage)) != sizeof(sessionMessage))\n {\n perror(\"write SessionMessage\");\n exit(1);\n }\n\n const int total_len = static_cast(sizeof(int32_t) + opt.length);\n PayloadMessage* payload = static_cast(::malloc(total_len));\n assert(payload);\n payload->length = htonl(opt.length);\n for (int i = 0; i < opt.length; ++i)\n {\n payload->data[i] = \"0123456789ABCDEF\"[i % 16];\n }\n\n double total_mb = 1.0 * opt.length * opt.number / 1024 / 1024;\n printf(\"%.3f MiB in total\\n\", total_mb);\n\n for (int i = 0; i < opt.number; ++i)\n {\n int nw = write_n(sockfd, payload, total_len);\n assert(nw == total_len);\n\n int ack = 0;\n int nr = read_n(sockfd, &ack, sizeof(ack));\n assert(nr == sizeof(ack));\n ack = ntohl(ack);\n assert(ack == opt.length);\n }\n\n ::free(payload);\n ::close(sockfd);\n double elapsed = timeDifference(muduo::Timestamp::now(), start);\n printf(\"%.3f seconds\\n%.3f MiB/s\\n\", elapsed, total_mb / elapsed);\n}\n\nvoid receive(const Options& opt)\n{\n int sockfd = acceptOrDie(opt.port);\n\n struct SessionMessage sessionMessage = { 0, 0 };\n if (read_n(sockfd, &sessionMessage, sizeof(sessionMessage)) != sizeof(sessionMessage))\n {\n perror(\"read SessionMessage\");\n exit(1);\n }\n\n sessionMessage.number = ntohl(sessionMessage.number);\n sessionMessage.length = ntohl(sessionMessage.length);\n printf(\"receive number = %d\\nreceive length = %d\\n\",\n sessionMessage.number, sessionMessage.length);\n const int total_len = static_cast(sizeof(int32_t) + sessionMessage.length);\n PayloadMessage* payload = static_cast(::malloc(total_len));\n assert(payload);\n\n for (int i = 0; i < sessionMessage.number; ++i)\n {\n payload->length = 0;\n if (read_n(sockfd, &payload->length, sizeof(payload->length)) != sizeof(payload->length))\n {\n perror(\"read length\");\n exit(1);\n }\n payload->length = ntohl(payload->length);\n assert(payload->length == sessionMessage.length);\n if (read_n(sockfd, payload->data, payload->length) != payload->length)\n {\n perror(\"read payload data\");\n exit(1);\n }\n int32_t ack = htonl(payload->length);\n if (write_n(sockfd, &ack, sizeof(ack)) != sizeof(ack))\n {\n perror(\"write ack\");\n exit(1);\n }\n }\n ::free(payload);\n ::close(sockfd);\n}\n\n" }, { "path": "examples/asio/chat/CMakeLists.txt", "content": "add_executable(asio_chat_client client.cc)\ntarget_link_libraries(asio_chat_client muduo_net)\n\nadd_executable(asio_chat_loadtest loadtest.cc)\ntarget_link_libraries(asio_chat_loadtest muduo_net)\n\nadd_executable(asio_chat_server server.cc)\ntarget_link_libraries(asio_chat_server muduo_net)\n\nadd_executable(asio_chat_server_threaded server_threaded.cc)\ntarget_link_libraries(asio_chat_server_threaded muduo_net)\n\nadd_executable(asio_chat_server_threaded_efficient server_threaded_efficient.cc)\ntarget_link_libraries(asio_chat_server_threaded_efficient muduo_net)\n\nadd_executable(asio_chat_server_threaded_highperformance server_threaded_highperformance.cc)\ntarget_link_libraries(asio_chat_server_threaded_highperformance muduo_net)\n\n" }, { "path": "examples/asio/chat/client.cc", "content": "#include \"examples/asio/chat/codec.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Mutex.h\"\n#include \"muduo/net/EventLoopThread.h\"\n#include \"muduo/net/TcpClient.h\"\n\n#include \n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nclass ChatClient : noncopyable\n{\n public:\n ChatClient(EventLoop* loop, const InetAddress& serverAddr)\n : client_(loop, serverAddr, \"ChatClient\"),\n codec_(std::bind(&ChatClient::onStringMessage, this, _1, _2, _3))\n {\n client_.setConnectionCallback(\n std::bind(&ChatClient::onConnection, this, _1));\n client_.setMessageCallback(\n std::bind(&LengthHeaderCodec::onMessage, &codec_, _1, _2, _3));\n client_.enableRetry();\n }\n\n void connect()\n {\n client_.connect();\n }\n\n void disconnect()\n {\n client_.disconnect();\n }\n\n void write(const StringPiece& message)\n {\n MutexLockGuard lock(mutex_);\n if (connection_)\n {\n codec_.send(get_pointer(connection_), message);\n }\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_INFO << conn->localAddress().toIpPort() << \" -> \"\n << conn->peerAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n MutexLockGuard lock(mutex_);\n if (conn->connected())\n {\n connection_ = conn;\n }\n else\n {\n connection_.reset();\n }\n }\n\n void onStringMessage(const TcpConnectionPtr&,\n const string& message,\n Timestamp)\n {\n printf(\"<<< %s\\n\", message.c_str());\n }\n\n TcpClient client_;\n LengthHeaderCodec codec_;\n MutexLock mutex_;\n TcpConnectionPtr connection_ GUARDED_BY(mutex_);\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n if (argc > 2)\n {\n EventLoopThread loopThread;\n uint16_t port = static_cast(atoi(argv[2]));\n InetAddress serverAddr(argv[1], port);\n\n ChatClient client(loopThread.startLoop(), serverAddr);\n client.connect();\n std::string line;\n while (std::getline(std::cin, line))\n {\n client.write(line);\n }\n client.disconnect();\n CurrentThread::sleepUsec(1000*1000); // wait for disconnect, see ace/logging/client.cc\n }\n else\n {\n printf(\"Usage: %s host_ip port\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/asio/chat/codec.h", "content": "#ifndef MUDUO_EXAMPLES_ASIO_CHAT_CODEC_H\n#define MUDUO_EXAMPLES_ASIO_CHAT_CODEC_H\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/Buffer.h\"\n#include \"muduo/net/Endian.h\"\n#include \"muduo/net/TcpConnection.h\"\n\nclass LengthHeaderCodec : muduo::noncopyable\n{\n public:\n typedef std::function StringMessageCallback;\n\n explicit LengthHeaderCodec(const StringMessageCallback& cb)\n : messageCallback_(cb)\n {\n }\n\n void onMessage(const muduo::net::TcpConnectionPtr& conn,\n muduo::net::Buffer* buf,\n muduo::Timestamp receiveTime)\n {\n while (buf->readableBytes() >= kHeaderLen) // kHeaderLen == 4\n {\n // FIXME: use Buffer::peekInt32()\n const void* data = buf->peek();\n int32_t be32 = *static_cast(data); // SIGBUS\n const int32_t len = muduo::net::sockets::networkToHost32(be32);\n if (len > 65536 || len < 0)\n {\n LOG_ERROR << \"Invalid length \" << len;\n conn->shutdown(); // FIXME: disable reading\n break;\n }\n else if (buf->readableBytes() >= len + kHeaderLen)\n {\n buf->retrieve(kHeaderLen);\n muduo::string message(buf->peek(), len);\n messageCallback_(conn, message, receiveTime);\n buf->retrieve(len);\n }\n else\n {\n break;\n }\n }\n }\n\n // FIXME: TcpConnectionPtr\n void send(muduo::net::TcpConnection* conn,\n const muduo::StringPiece& message)\n {\n muduo::net::Buffer buf;\n buf.append(message.data(), message.size());\n int32_t len = static_cast(message.size());\n int32_t be32 = muduo::net::sockets::hostToNetwork32(len);\n buf.prepend(&be32, sizeof be32);\n conn->send(&buf);\n }\n\n private:\n StringMessageCallback messageCallback_;\n const static size_t kHeaderLen = sizeof(int32_t);\n};\n\n#endif // MUDUO_EXAMPLES_ASIO_CHAT_CODEC_H\n" }, { "path": "examples/asio/chat/loadtest.cc", "content": "#include \"examples/asio/chat/codec.h\"\n\n#include \"muduo/base/Atomic.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Mutex.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/EventLoopThreadPool.h\"\n#include \"muduo/net/TcpClient.h\"\n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nint g_connections = 0;\nAtomicInt32 g_aliveConnections;\nAtomicInt32 g_messagesReceived;\nTimestamp g_startTime;\nstd::vector g_receiveTime;\nEventLoop* g_loop;\nstd::function g_statistic;\n\nclass ChatClient : noncopyable\n{\n public:\n ChatClient(EventLoop* loop, const InetAddress& serverAddr)\n : loop_(loop),\n client_(loop, serverAddr, \"LoadTestClient\"),\n codec_(std::bind(&ChatClient::onStringMessage, this, _1, _2, _3))\n {\n client_.setConnectionCallback(\n std::bind(&ChatClient::onConnection, this, _1));\n client_.setMessageCallback(\n std::bind(&LengthHeaderCodec::onMessage, &codec_, _1, _2, _3));\n //client_.enableRetry();\n }\n\n void connect()\n {\n client_.connect();\n }\n\n void disconnect()\n {\n // client_.disconnect();\n }\n\n Timestamp receiveTime() const { return receiveTime_; }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_INFO << conn->localAddress().toIpPort() << \" -> \"\n << conn->peerAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n if (conn->connected())\n {\n connection_ = conn;\n if (g_aliveConnections.incrementAndGet() == g_connections)\n {\n LOG_INFO << \"all connected\";\n loop_->runAfter(10.0, std::bind(&ChatClient::send, this));\n }\n }\n else\n {\n connection_.reset();\n }\n }\n\n void onStringMessage(const TcpConnectionPtr&,\n const string& message,\n Timestamp)\n {\n // printf(\"<<< %s\\n\", message.c_str());\n receiveTime_ = loop_->pollReturnTime();\n int received = g_messagesReceived.incrementAndGet();\n if (received == g_connections)\n {\n Timestamp endTime = Timestamp::now();\n LOG_INFO << \"all received \" << g_connections << \" in \"\n << timeDifference(endTime, g_startTime);\n g_loop->queueInLoop(g_statistic);\n }\n else if (received % 1000 == 0)\n {\n LOG_DEBUG << received;\n }\n }\n\n void send()\n {\n g_startTime = Timestamp::now();\n codec_.send(get_pointer(connection_), \"hello\");\n LOG_DEBUG << \"sent\";\n }\n\n EventLoop* loop_;\n TcpClient client_;\n LengthHeaderCodec codec_;\n TcpConnectionPtr connection_;\n Timestamp receiveTime_;\n};\n\nvoid statistic(const std::vector>& clients)\n{\n LOG_INFO << \"statistic \" << clients.size();\n std::vector seconds(clients.size());\n for (size_t i = 0; i < clients.size(); ++i)\n {\n seconds[i] = timeDifference(clients[i]->receiveTime(), g_startTime);\n }\n\n std::sort(seconds.begin(), seconds.end());\n for (size_t i = 0; i < clients.size(); i += std::max(static_cast(1), clients.size()/20))\n {\n printf(\"%6zd%% %.6f\\n\", i*100/clients.size(), seconds[i]);\n }\n if (clients.size() >= 100)\n {\n printf(\"%6d%% %.6f\\n\", 99, seconds[clients.size() - clients.size()/100]);\n }\n printf(\"%6d%% %.6f\\n\", 100, seconds.back());\n}\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n if (argc > 3)\n {\n uint16_t port = static_cast(atoi(argv[2]));\n InetAddress serverAddr(argv[1], port);\n g_connections = atoi(argv[3]);\n int threads = 0;\n if (argc > 4)\n {\n threads = atoi(argv[4]);\n }\n\n EventLoop loop;\n g_loop = &loop;\n EventLoopThreadPool loopPool(&loop, \"chat-loadtest\");\n loopPool.setThreadNum(threads);\n loopPool.start();\n\n g_receiveTime.reserve(g_connections);\n std::vector> clients(g_connections);\n g_statistic = std::bind(statistic, std::ref(clients));\n\n for (int i = 0; i < g_connections; ++i)\n {\n clients[i].reset(new ChatClient(loopPool.getNextLoop(), serverAddr));\n clients[i]->connect();\n usleep(200);\n }\n\n loop.loop();\n // client.disconnect();\n }\n else\n {\n printf(\"Usage: %s host_ip port connections [threads]\\n\", argv[0]);\n }\n}\n\n\n" }, { "path": "examples/asio/chat/server.cc", "content": "#include \"examples/asio/chat/codec.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Mutex.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nclass ChatServer : noncopyable\n{\n public:\n ChatServer(EventLoop* loop,\n const InetAddress& listenAddr)\n : server_(loop, listenAddr, \"ChatServer\"),\n codec_(std::bind(&ChatServer::onStringMessage, this, _1, _2, _3))\n {\n server_.setConnectionCallback(\n std::bind(&ChatServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&LengthHeaderCodec::onMessage, &codec_, _1, _2, _3));\n }\n\n void start()\n {\n server_.start();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_INFO << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n if (conn->connected())\n {\n connections_.insert(conn);\n }\n else\n {\n connections_.erase(conn);\n }\n }\n\n void onStringMessage(const TcpConnectionPtr&,\n const string& message,\n Timestamp)\n {\n for (ConnectionList::iterator it = connections_.begin();\n it != connections_.end();\n ++it)\n {\n codec_.send(get_pointer(*it), message);\n }\n }\n\n typedef std::set ConnectionList;\n TcpServer server_;\n LengthHeaderCodec codec_;\n ConnectionList connections_;\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n if (argc > 1)\n {\n EventLoop loop;\n uint16_t port = static_cast(atoi(argv[1]));\n InetAddress serverAddr(port);\n ChatServer server(&loop, serverAddr);\n server.start();\n loop.loop();\n }\n else\n {\n printf(\"Usage: %s port\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/asio/chat/server_threaded.cc", "content": "#include \"examples/asio/chat/codec.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Mutex.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nclass ChatServer : noncopyable\n{\n public:\n ChatServer(EventLoop* loop,\n const InetAddress& listenAddr)\n : server_(loop, listenAddr, \"ChatServer\"),\n codec_(std::bind(&ChatServer::onStringMessage, this, _1, _2, _3))\n {\n server_.setConnectionCallback(\n std::bind(&ChatServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&LengthHeaderCodec::onMessage, &codec_, _1, _2, _3));\n }\n\n void setThreadNum(int numThreads)\n {\n server_.setThreadNum(numThreads);\n }\n\n void start()\n {\n server_.start();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_INFO << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n MutexLockGuard lock(mutex_);\n if (conn->connected())\n {\n connections_.insert(conn);\n }\n else\n {\n connections_.erase(conn);\n }\n }\n\n void onStringMessage(const TcpConnectionPtr&,\n const string& message,\n Timestamp)\n {\n MutexLockGuard lock(mutex_);\n for (ConnectionList::iterator it = connections_.begin();\n it != connections_.end();\n ++it)\n {\n codec_.send(get_pointer(*it), message);\n }\n }\n\n typedef std::set ConnectionList;\n TcpServer server_;\n LengthHeaderCodec codec_;\n MutexLock mutex_;\n ConnectionList connections_ GUARDED_BY(mutex_);\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n if (argc > 1)\n {\n EventLoop loop;\n uint16_t port = static_cast(atoi(argv[1]));\n InetAddress serverAddr(port);\n ChatServer server(&loop, serverAddr);\n if (argc > 2)\n {\n server.setThreadNum(atoi(argv[2]));\n }\n server.start();\n loop.loop();\n }\n else\n {\n printf(\"Usage: %s port [thread_num]\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/asio/chat/server_threaded_efficient.cc", "content": "#include \"examples/asio/chat/codec.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Mutex.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nclass ChatServer : noncopyable\n{\n public:\n ChatServer(EventLoop* loop,\n const InetAddress& listenAddr)\n : server_(loop, listenAddr, \"ChatServer\"),\n codec_(std::bind(&ChatServer::onStringMessage, this, _1, _2, _3)),\n connections_(new ConnectionList)\n {\n server_.setConnectionCallback(\n std::bind(&ChatServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&LengthHeaderCodec::onMessage, &codec_, _1, _2, _3));\n }\n\n void setThreadNum(int numThreads)\n {\n server_.setThreadNum(numThreads);\n }\n\n void start()\n {\n server_.start();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_INFO << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n MutexLockGuard lock(mutex_);\n if (!connections_.unique())\n {\n connections_.reset(new ConnectionList(*connections_));\n }\n assert(connections_.unique());\n\n if (conn->connected())\n {\n connections_->insert(conn);\n }\n else\n {\n connections_->erase(conn);\n }\n }\n\n typedef std::set ConnectionList;\n typedef std::shared_ptr ConnectionListPtr;\n\n void onStringMessage(const TcpConnectionPtr&,\n const string& message,\n Timestamp)\n {\n ConnectionListPtr connections = getConnectionList();\n for (ConnectionList::iterator it = connections->begin();\n it != connections->end();\n ++it)\n {\n codec_.send(get_pointer(*it), message);\n }\n }\n\n ConnectionListPtr getConnectionList()\n {\n MutexLockGuard lock(mutex_);\n return connections_;\n }\n\n TcpServer server_;\n LengthHeaderCodec codec_;\n MutexLock mutex_;\n ConnectionListPtr connections_ GUARDED_BY(mutex_);\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n if (argc > 1)\n {\n EventLoop loop;\n uint16_t port = static_cast(atoi(argv[1]));\n InetAddress serverAddr(port);\n ChatServer server(&loop, serverAddr);\n if (argc > 2)\n {\n server.setThreadNum(atoi(argv[2]));\n }\n server.start();\n loop.loop();\n }\n else\n {\n printf(\"Usage: %s port [thread_num]\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/asio/chat/server_threaded_highperformance.cc", "content": "#include \"examples/asio/chat/codec.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Mutex.h\"\n#include \"muduo/base/ThreadLocalSingleton.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nclass ChatServer : noncopyable\n{\n public:\n ChatServer(EventLoop* loop,\n const InetAddress& listenAddr)\n : server_(loop, listenAddr, \"ChatServer\"),\n codec_(std::bind(&ChatServer::onStringMessage, this, _1, _2, _3))\n {\n server_.setConnectionCallback(\n std::bind(&ChatServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&LengthHeaderCodec::onMessage, &codec_, _1, _2, _3));\n }\n\n void setThreadNum(int numThreads)\n {\n server_.setThreadNum(numThreads);\n }\n\n void start()\n {\n server_.setThreadInitCallback(std::bind(&ChatServer::threadInit, this, _1));\n server_.start();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_INFO << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n if (conn->connected())\n {\n LocalConnections::instance().insert(conn);\n }\n else\n {\n LocalConnections::instance().erase(conn);\n }\n }\n\n void onStringMessage(const TcpConnectionPtr&,\n const string& message,\n Timestamp)\n {\n EventLoop::Functor f = std::bind(&ChatServer::distributeMessage, this, message);\n LOG_DEBUG;\n\n MutexLockGuard lock(mutex_);\n for (std::set::iterator it = loops_.begin();\n it != loops_.end();\n ++it)\n {\n (*it)->queueInLoop(f);\n }\n LOG_DEBUG;\n }\n\n typedef std::set ConnectionList;\n\n void distributeMessage(const string& message)\n {\n LOG_DEBUG << \"begin\";\n for (ConnectionList::iterator it = LocalConnections::instance().begin();\n it != LocalConnections::instance().end();\n ++it)\n {\n codec_.send(get_pointer(*it), message);\n }\n LOG_DEBUG << \"end\";\n }\n\n void threadInit(EventLoop* loop)\n {\n assert(LocalConnections::pointer() == NULL);\n LocalConnections::instance();\n assert(LocalConnections::pointer() != NULL);\n MutexLockGuard lock(mutex_);\n loops_.insert(loop);\n }\n\n TcpServer server_;\n LengthHeaderCodec codec_;\n typedef ThreadLocalSingleton LocalConnections;\n\n MutexLock mutex_;\n std::set loops_ GUARDED_BY(mutex_);\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n if (argc > 1)\n {\n EventLoop loop;\n uint16_t port = static_cast(atoi(argv[1]));\n InetAddress serverAddr(port);\n ChatServer server(&loop, serverAddr);\n if (argc > 2)\n {\n server.setThreadNum(atoi(argv[2]));\n }\n server.start();\n loop.loop();\n }\n else\n {\n printf(\"Usage: %s port [thread_num]\\n\", argv[0]);\n }\n}\n\n\n" }, { "path": "examples/asio/echo_see_simple", "content": "" }, { "path": "examples/asio/tutorial/CMakeLists.txt", "content": "add_executable(asio_tutorial_timer2 timer2/timer.cc)\ntarget_link_libraries(asio_tutorial_timer2 muduo_net)\n\nadd_executable(asio_tutorial_timer3 timer3/timer.cc)\ntarget_link_libraries(asio_tutorial_timer3 muduo_net)\n\nadd_executable(asio_tutorial_timer4 timer4/timer.cc)\ntarget_link_libraries(asio_tutorial_timer4 muduo_net)\n\nadd_executable(asio_tutorial_timer5 timer5/timer.cc)\ntarget_link_libraries(asio_tutorial_timer5 muduo_net)\n\nadd_executable(asio_tutorial_timer6 timer6/timer.cc)\ntarget_link_libraries(asio_tutorial_timer6 muduo_net)\n\n" }, { "path": "examples/asio/tutorial/daytime_see_simple", "content": "" }, { "path": "examples/asio/tutorial/there_is_no_timer1", "content": "" }, { "path": "examples/asio/tutorial/timer2/timer.cc", "content": "#include \"muduo/net/EventLoop.h\"\n\n#include \n\nvoid print()\n{\n std::cout << \"Hello, world!\\n\";\n}\n\nint main()\n{\n muduo::net::EventLoop loop;\n loop.runAfter(5, print);\n loop.loop();\n}\n\n" }, { "path": "examples/asio/tutorial/timer3/timer.cc", "content": "#include \"muduo/net/EventLoop.h\"\n\n#include \n\nvoid print(muduo::net::EventLoop* loop, int* count)\n{\n if (*count < 5)\n {\n std::cout << *count << \"\\n\";\n ++(*count);\n\n loop->runAfter(1, std::bind(print, loop, count));\n }\n else\n {\n loop->quit();\n }\n}\n\nint main()\n{\n muduo::net::EventLoop loop;\n int count = 0;\n // Note: loop.runEvery() is better for this use case.\n loop.runAfter(1, std::bind(print, &loop, &count));\n loop.loop();\n std::cout << \"Final count is \" << count << \"\\n\";\n}\n\n" }, { "path": "examples/asio/tutorial/timer4/timer.cc", "content": "#include \"muduo/net/EventLoop.h\"\n\n#include \n\nclass Printer : muduo::noncopyable\n{\n public:\n Printer(muduo::net::EventLoop* loop)\n : loop_(loop),\n count_(0)\n {\n // Note: loop.runEvery() is better for this use case.\n loop_->runAfter(1, std::bind(&Printer::print, this));\n }\n\n ~Printer()\n {\n std::cout << \"Final count is \" << count_ << \"\\n\";\n }\n\n void print()\n {\n if (count_ < 5)\n {\n std::cout << count_ << \"\\n\";\n ++count_;\n\n loop_->runAfter(1, std::bind(&Printer::print, this));\n }\n else\n {\n loop_->quit();\n }\n }\n\nprivate:\n muduo::net::EventLoop* loop_;\n int count_;\n};\n\nint main()\n{\n muduo::net::EventLoop loop;\n Printer printer(&loop);\n loop.loop();\n}\n\n" }, { "path": "examples/asio/tutorial/timer5/timer.cc", "content": "#include \"muduo/base/Mutex.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/EventLoopThread.h\"\n\n#include \n\nclass Printer : muduo::noncopyable\n{\n public:\n Printer(muduo::net::EventLoop* loop1, muduo::net::EventLoop* loop2)\n : loop1_(loop1),\n loop2_(loop2),\n count_(0)\n {\n loop1_->runAfter(1, std::bind(&Printer::print1, this));\n loop2_->runAfter(1, std::bind(&Printer::print2, this));\n }\n\n ~Printer()\n {\n std::cout << \"Final count is \" << count_ << \"\\n\";\n }\n\n void print1()\n {\n muduo::MutexLockGuard lock(mutex_);\n if (count_ < 10)\n {\n std::cout << \"Timer 1: \" << count_ << \"\\n\";\n ++count_;\n\n loop1_->runAfter(1, std::bind(&Printer::print1, this));\n }\n else\n {\n loop1_->quit();\n }\n }\n\n void print2()\n {\n muduo::MutexLockGuard lock(mutex_);\n if (count_ < 10)\n {\n std::cout << \"Timer 2: \" << count_ << \"\\n\";\n ++count_;\n\n loop2_->runAfter(1, std::bind(&Printer::print2, this));\n }\n else\n {\n loop2_->quit();\n }\n }\n\nprivate:\n\n muduo::MutexLock mutex_;\n muduo::net::EventLoop* loop1_ PT_GUARDED_BY(mutex_);\n muduo::net::EventLoop* loop2_ PT_GUARDED_BY(mutex_);\n int count_ GUARDED_BY(mutex_);\n};\n\nint main()\n{\n std::unique_ptr printer; // make sure printer lives longer than loops, to avoid\n // race condition of calling print2() on destructed object.\n muduo::net::EventLoop loop;\n muduo::net::EventLoopThread loopThread;\n muduo::net::EventLoop* loopInAnotherThread = loopThread.startLoop();\n printer.reset(new Printer(&loop, loopInAnotherThread));\n loop.loop();\n}\n\n" }, { "path": "examples/asio/tutorial/timer6/timer.cc", "content": "#include \"muduo/base/Mutex.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/EventLoopThread.h\"\n\n#include \n\n//\n// Minimize locking\n//\n\nclass Printer : muduo::noncopyable\n{\n public:\n Printer(muduo::net::EventLoop* loop1, muduo::net::EventLoop* loop2)\n : loop1_(loop1),\n loop2_(loop2),\n count_(0)\n {\n loop1_->runAfter(1, std::bind(&Printer::print1, this));\n loop2_->runAfter(1, std::bind(&Printer::print2, this));\n }\n\n ~Printer()\n {\n // cout is not thread safe\n //std::cout << \"Final count is \" << count_ << \"\\n\";\n printf(\"Final count is %d\\n\", count_);\n }\n\n void print1()\n {\n bool shouldQuit = false;\n int count = 0;\n\n {\n muduo::MutexLockGuard lock(mutex_);\n if (count_ < 10)\n {\n count = count_;\n ++count_;\n }\n else\n {\n shouldQuit = true;\n }\n }\n\n // out of lock\n if (shouldQuit)\n {\n // printf(\"loop1_->quit()\\n\");\n loop1_->quit();\n }\n else\n {\n // cout is not thread safe\n //std::cout << \"Timer 1: \" << count << \"\\n\";\n printf(\"Timer 1: %d\\n\", count);\n loop1_->runAfter(1, std::bind(&Printer::print1, this));\n }\n }\n\n void print2()\n {\n bool shouldQuit = false;\n int count = 0;\n\n {\n muduo::MutexLockGuard lock(mutex_);\n if (count_ < 10)\n {\n count = count_;\n ++count_;\n }\n else\n {\n shouldQuit = true;\n }\n }\n\n // out of lock\n if (shouldQuit)\n {\n // printf(\"loop2_->quit()\\n\");\n loop2_->quit();\n }\n else\n {\n // cout is not thread safe\n //std::cout << \"Timer 2: \" << count << \"\\n\";\n printf(\"Timer 2: %d\\n\", count);\n loop2_->runAfter(1, std::bind(&Printer::print2, this));\n }\n }\n\nprivate:\n\n muduo::MutexLock mutex_;\n muduo::net::EventLoop* loop1_;\n muduo::net::EventLoop* loop2_;\n int count_ GUARDED_BY(mutex_);\n};\n\nint main()\n{\n std::unique_ptr printer; // make sure printer lives longer than loops, to avoid\n // race condition of calling print2() on destructed object.\n muduo::net::EventLoop loop;\n muduo::net::EventLoopThread loopThread;\n muduo::net::EventLoop* loopInAnotherThread = loopThread.startLoop();\n printer.reset(new Printer(&loop, loopInAnotherThread));\n loop.loop();\n}\n\n" }, { "path": "examples/cdns/CMakeLists.txt", "content": "add_library(muduo_cdns Resolver.cc)\ntarget_link_libraries(muduo_cdns muduo_net)\ntarget_link_libraries(muduo_cdns cares)\n\ninstall(TARGETS muduo_cdns DESTINATION lib)\ninstall(FILES Resolver.h DESTINATION include/muduo/cdns)\n\nadd_executable(cdns dns.cc)\ntarget_link_libraries(cdns muduo_cdns)\n\n" }, { "path": "examples/cdns/Resolver.cc", "content": "#include \"examples/cdns/Resolver.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/Channel.h\"\n#include \"muduo/net/EventLoop.h\"\n\n#include \n#include \n#include // inet_ntop\n#include \n\n#include \n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\nusing namespace cdns;\n\nnamespace\n{\ndouble getSeconds(struct timeval* tv)\n{\n if (tv)\n return double(tv->tv_sec) + double(tv->tv_usec)/1000000.0;\n else\n return -1.0;\n}\n\nconst char* getSocketType(int type)\n{\n if (type == SOCK_DGRAM)\n return \"UDP\";\n else if (type == SOCK_STREAM)\n return \"TCP\";\n else\n return \"Unknown\";\n}\n\nconst bool kDebug = false;\n} // namespace\n\nResolver::Resolver(EventLoop* loop, Option opt)\n : loop_(loop),\n ctx_(NULL),\n timerActive_(false)\n{\n static char lookups[] = \"b\";\n struct ares_options options;\n int optmask = ARES_OPT_FLAGS;\n options.flags = ARES_FLAG_NOCHECKRESP;\n options.flags |= ARES_FLAG_STAYOPEN;\n options.flags |= ARES_FLAG_IGNTC; // UDP only\n optmask |= ARES_OPT_SOCK_STATE_CB;\n options.sock_state_cb = &Resolver::ares_sock_state_callback;\n options.sock_state_cb_data = this;\n optmask |= ARES_OPT_TIMEOUT;\n options.timeout = 2;\n if (opt == kDNSonly)\n {\n optmask |= ARES_OPT_LOOKUPS;\n options.lookups = lookups;\n }\n\n int status = ares_init_options(&ctx_, &options, optmask);\n if (status != ARES_SUCCESS)\n {\n assert(0);\n }\n ares_set_socket_callback(ctx_, &Resolver::ares_sock_create_callback, this);\n}\n\nResolver::~Resolver()\n{\n ares_destroy(ctx_);\n}\n\nbool Resolver::resolve(StringArg hostname, const Callback& cb)\n{\n loop_->assertInLoopThread();\n QueryData* queryData = new QueryData(this, cb);\n ares_gethostbyname(ctx_, hostname.c_str(), AF_INET,\n &Resolver::ares_host_callback, queryData);\n struct timeval tv;\n struct timeval* tvp = ares_timeout(ctx_, NULL, &tv);\n double timeout = getSeconds(tvp);\n LOG_DEBUG << \"timeout \" << timeout << \" active \" << timerActive_;\n if (!timerActive_)\n {\n loop_->runAfter(timeout, std::bind(&Resolver::onTimer, this));\n timerActive_ = true;\n }\n return queryData != NULL;\n}\n\nvoid Resolver::onRead(int sockfd, Timestamp t)\n{\n LOG_DEBUG << \"onRead \" << sockfd << \" at \" << t.toString();\n ares_process_fd(ctx_, sockfd, ARES_SOCKET_BAD);\n}\n\nvoid Resolver::onTimer()\n{\n assert(timerActive_ == true);\n ares_process_fd(ctx_, ARES_SOCKET_BAD, ARES_SOCKET_BAD);\n struct timeval tv;\n struct timeval* tvp = ares_timeout(ctx_, NULL, &tv);\n double timeout = getSeconds(tvp);\n LOG_DEBUG << loop_->pollReturnTime().toString() << \" next timeout \" << timeout;\n\n if (timeout < 0)\n {\n timerActive_ = false;\n }\n else\n {\n loop_->runAfter(timeout, std::bind(&Resolver::onTimer, this));\n }\n}\n\nvoid Resolver::onQueryResult(int status, struct hostent* result, const Callback& callback)\n{\n LOG_DEBUG << \"onQueryResult \" << status;\n struct sockaddr_in addr;\n memZero(&addr, sizeof addr);\n addr.sin_family = AF_INET;\n addr.sin_port = 0;\n if (result)\n {\n addr.sin_addr = *reinterpret_cast(result->h_addr);\n if (kDebug)\n {\n printf(\"h_name %s\\n\", result->h_name);\n for (char** alias = result->h_aliases; *alias != NULL; ++alias)\n {\n printf(\"alias: %s\\n\", *alias);\n }\n // printf(\"ttl %d\\n\", ttl);\n // printf(\"h_length %d\\n\", result->h_length);\n for (char** haddr = result->h_addr_list; *haddr != NULL; ++haddr)\n {\n char buf[32];\n inet_ntop(AF_INET, *haddr, buf, sizeof buf);\n printf(\" %s\\n\", buf);\n }\n }\n }\n InetAddress inet(addr);\n callback(inet);\n}\n\nvoid Resolver::onSockCreate(int sockfd, int type)\n{\n loop_->assertInLoopThread();\n assert(channels_.find(sockfd) == channels_.end());\n Channel* channel = new Channel(loop_, sockfd);\n channel->setReadCallback(std::bind(&Resolver::onRead, this, sockfd, _1));\n channel->enableReading();\n channels_[sockfd].reset(channel);\n}\n\nvoid Resolver::onSockStateChange(int sockfd, bool read, bool write)\n{\n loop_->assertInLoopThread();\n ChannelList::iterator it = channels_.find(sockfd);\n assert(it != channels_.end());\n if (read)\n {\n // update\n // if (write) { } else { }\n }\n else\n {\n // remove\n it->second->disableAll();\n it->second->remove();\n channels_.erase(it);\n }\n}\n\nvoid Resolver::ares_host_callback(void* data, int status, int timeouts, struct hostent* hostent)\n{\n QueryData* query = static_cast(data);\n\n query->owner->onQueryResult(status, hostent, query->callback);\n delete query;\n}\n\nint Resolver::ares_sock_create_callback(int sockfd, int type, void* data)\n{\n LOG_TRACE << \"sockfd=\" << sockfd << \" type=\" << getSocketType(type);\n static_cast(data)->onSockCreate(sockfd, type);\n return 0;\n}\n\nvoid Resolver::ares_sock_state_callback(void* data, int sockfd, int read, int write)\n{\n LOG_TRACE << \"sockfd=\" << sockfd << \" read=\" << read << \" write=\" << write;\n static_cast(data)->onSockStateChange(sockfd, read, write);\n}\n\n" }, { "path": "examples/cdns/Resolver.h", "content": "#ifndef MUDUO_EXAMPLES_CDNS_RESOLVER_H\n#define MUDUO_EXAMPLES_CDNS_RESOLVER_H\n\n#include \"muduo/base/noncopyable.h\"\n#include \"muduo/base/StringPiece.h\"\n#include \"muduo/base/Timestamp.h\"\n#include \"muduo/net/InetAddress.h\"\n\n#include \n#include \n#include \n\nextern \"C\"\n{\n struct hostent;\n struct ares_channeldata;\n typedef struct ares_channeldata* ares_channel;\n}\n\nnamespace muduo\n{\nnamespace net\n{\nclass Channel;\nclass EventLoop;\n}\n}\n\nnamespace cdns\n{\n\nclass Resolver : muduo::noncopyable\n{\n public:\n typedef std::function Callback;\n enum Option\n {\n kDNSandHostsFile,\n kDNSonly,\n };\n\n explicit Resolver(muduo::net::EventLoop* loop, Option opt = kDNSandHostsFile);\n ~Resolver();\n\n bool resolve(muduo::StringArg hostname, const Callback& cb);\n\n private:\n\n struct QueryData\n {\n Resolver* owner;\n Callback callback;\n QueryData(Resolver* o, const Callback& cb)\n : owner(o), callback(cb)\n {\n }\n };\n\n muduo::net::EventLoop* loop_;\n ares_channel ctx_;\n bool timerActive_;\n typedef std::map> ChannelList;\n ChannelList channels_;\n\n void onRead(int sockfd, muduo::Timestamp t);\n void onTimer();\n void onQueryResult(int status, struct hostent* result, const Callback& cb);\n void onSockCreate(int sockfd, int type);\n void onSockStateChange(int sockfd, bool read, bool write);\n\n static void ares_host_callback(void* data, int status, int timeouts, struct hostent* hostent);\n static int ares_sock_create_callback(int sockfd, int type, void* data);\n static void ares_sock_state_callback(void* data, int sockfd, int read, int write);\n};\n} // namespace cdns\n\n#endif // MUDUO_EXAMPLES_CDNS_RESOLVER_H\n" }, { "path": "examples/cdns/dns.cc", "content": "#include \"examples/cdns/Resolver.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\nusing namespace cdns;\n\nEventLoop* g_loop;\nint count = 0;\nint total = 0;\n\nvoid quit()\n{\n g_loop->quit();\n}\n\nvoid resolveCallback(const string& host, const InetAddress& addr)\n{\n printf(\"resolveCallback %s -> %s\\n\", host.c_str(), addr.toIpPort().c_str());\n if (++count == total)\n quit();\n}\n\nvoid resolve(Resolver* res, const string& host)\n{\n res->resolve(host, std::bind(&resolveCallback, host, _1));\n}\n\nint main(int argc, char* argv[])\n{\n EventLoop loop;\n loop.runAfter(10, quit);\n g_loop = &loop;\n Resolver resolver(&loop,\n argc == 1 ? Resolver::kDNSonly : Resolver::kDNSandHostsFile);\n if (argc == 1)\n {\n total = 3;\n resolve(&resolver, \"www.chenshuo.com\");\n resolve(&resolver, \"www.example.com\");\n resolve(&resolver, \"www.google.com\");\n }\n else\n {\n total = argc-1;\n for (int i = 1; i < argc; ++i)\n resolve(&resolver, argv[i]);\n }\n loop.loop();\n}\n" }, { "path": "examples/curl/CMakeLists.txt", "content": "add_library(muduo_curl Curl.cc)\ntarget_link_libraries(muduo_curl muduo_net)\ntarget_link_libraries(muduo_curl curl)\n\ninstall(TARGETS muduo_curl DESTINATION lib)\ninstall(FILES Curl.h DESTINATION include/muduo/curl)\n\nadd_executable(mcurl mcurl.cc)\ntarget_link_libraries(mcurl muduo_curl)\n\nadd_executable(curl_download download.cc)\ntarget_link_libraries(curl_download muduo_curl)\n\n" }, { "path": "examples/curl/Curl.cc", "content": "#include \"examples/curl/Curl.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/Channel.h\"\n#include \"muduo/net/EventLoop.h\"\n\n#include \n#include \n\nusing namespace curl;\nusing namespace muduo;\nusing namespace muduo::net;\n\nstatic void dummy(const std::shared_ptr&)\n{\n}\n\nRequest::Request(Curl* owner, const char* url)\n : owner_(owner),\n curl_(CHECK_NOTNULL(curl_easy_init()))\n{\n setopt(CURLOPT_URL, url);\n setopt(CURLOPT_WRITEFUNCTION, &Request::writeData);\n setopt(CURLOPT_WRITEDATA, this);\n setopt(CURLOPT_HEADERFUNCTION, &Request::headerData);\n setopt(CURLOPT_HEADERDATA, this);\n setopt(CURLOPT_PRIVATE, this);\n setopt(CURLOPT_USERAGENT, \"curl\");\n // set useragent\n LOG_DEBUG << curl_ << \" \" << url;\n curl_multi_add_handle(owner_->getCurlm(), curl_);\n}\n\nRequest::~Request()\n{\n assert(!channel_ || channel_->isNoneEvent());\n curl_multi_remove_handle(owner_->getCurlm(), curl_);\n curl_easy_cleanup(curl_);\n}\n\n// NOT implemented yet\n//\n// void Request::allowRedirect(int redirects)\n// {\n// setopt(CURLOPT_FOLLOWLOCATION, 1);\n// setopt(CURLOPT_MAXREDIRS, redirects);\n// }\n\nvoid Request::headerOnly()\n{\n setopt(CURLOPT_NOBODY, 1);\n}\n\nvoid Request::setRange(const StringArg range)\n{\n setopt(CURLOPT_RANGE, range.c_str());\n}\n\nconst char* Request::getEffectiveUrl()\n{\n const char* p = NULL;\n curl_easy_getinfo(curl_, CURLINFO_EFFECTIVE_URL, &p);\n return p;\n}\n\nconst char* Request::getRedirectUrl()\n{\n const char* p = NULL;\n curl_easy_getinfo(curl_, CURLINFO_REDIRECT_URL, &p);\n return p;\n}\n\nint Request::getResponseCode()\n{\n long code = 0;\n curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE, &code);\n return static_cast(code);\n}\n\nChannel* Request::setChannel(int fd)\n{\n assert(channel_.get() == NULL);\n channel_.reset(new Channel(owner_->getLoop(), fd));\n channel_->tie(shared_from_this());\n return get_pointer(channel_);\n}\n\nvoid Request::removeChannel()\n{\n channel_->disableAll();\n channel_->remove();\n owner_->getLoop()->queueInLoop(std::bind(dummy, channel_));\n channel_.reset();\n}\n\nvoid Request::done(int code)\n{\n if (doneCb_)\n {\n doneCb_(this, code);\n }\n}\n\nvoid Request::dataCallback(const char* buffer, int len)\n{\n if (dataCb_)\n {\n dataCb_(buffer, len);\n }\n}\n\nvoid Request::headerCallback(const char* buffer, int len)\n{\n if (headerCb_)\n {\n headerCb_(buffer, len);\n }\n}\n\nsize_t Request::writeData(char* buffer, size_t size, size_t nmemb, void* userp)\n{\n assert(size == 1);\n Request* req = static_cast(userp);\n req->dataCallback(buffer, static_cast(nmemb));\n return nmemb;\n}\n\nsize_t Request::headerData(char* buffer, size_t size, size_t nmemb, void* userp)\n{\n assert(size == 1);\n Request* req = static_cast(userp);\n req->headerCallback(buffer, static_cast(nmemb));\n return nmemb;\n}\n\n// ==================================================================\n\nvoid Curl::initialize(Option opt)\n{\n curl_global_init(opt == kCURLnossl ? CURL_GLOBAL_NOTHING : CURL_GLOBAL_SSL);\n}\n\nint Curl::socketCallback(CURL* c, int fd, int what, void* userp, void* socketp)\n{\n Curl* curl = static_cast(userp);\n const char *whatstr[]={ \"none\", \"IN\", \"OUT\", \"INOUT\", \"REMOVE\" };\n LOG_DEBUG << \"Curl::socketCallback [\" << curl << \"] - fd = \" << fd\n << \" what = \" << whatstr[what];\n Request* req = NULL;\n curl_easy_getinfo(c, CURLINFO_PRIVATE, &req);\n assert(req->getCurl() == c);\n if (what == CURL_POLL_REMOVE)\n {\n muduo::net::Channel* ch = static_cast(socketp);\n assert(req->getChannel() == ch);\n req->removeChannel();\n ch = NULL;\n curl_multi_assign(curl->curlm_, fd, ch);\n }\n else\n {\n muduo::net::Channel* ch = static_cast(socketp);\n if (!ch)\n {\n ch = req->setChannel(fd);\n ch->setReadCallback(std::bind(&Curl::onRead, curl, fd));\n ch->setWriteCallback(std::bind(&Curl::onWrite, curl, fd));\n ch->enableReading();\n curl_multi_assign(curl->curlm_, fd, ch);\n LOG_TRACE << \"new channel for fd=\" << fd;\n }\n assert(req->getChannel() == ch);\n // update\n if (what & CURL_POLL_OUT)\n {\n ch->enableWriting();\n }\n else\n {\n ch->disableWriting();\n }\n }\n return 0;\n}\n\nint Curl::timerCallback(CURLM* curlm, long ms, void* userp)\n{\n Curl* curl = static_cast(userp);\n LOG_DEBUG << curl << \" \" << ms << \" ms\";\n curl->loop_->runAfter(static_cast(ms)/1000.0, std::bind(&Curl::onTimer, curl));\n return 0;\n}\n\nCurl::Curl(EventLoop* loop)\n : loop_(loop),\n curlm_(CHECK_NOTNULL(curl_multi_init())),\n runningHandles_(0),\n prevRunningHandles_(0)\n{\n curl_multi_setopt(curlm_, CURLMOPT_SOCKETFUNCTION, &Curl::socketCallback);\n curl_multi_setopt(curlm_, CURLMOPT_SOCKETDATA, this);\n curl_multi_setopt(curlm_, CURLMOPT_TIMERFUNCTION, &Curl::timerCallback);\n curl_multi_setopt(curlm_, CURLMOPT_TIMERDATA, this);\n}\n\nCurl::~Curl()\n{\n curl_multi_cleanup(curlm_);\n}\n\nRequestPtr Curl::getUrl(StringArg url)\n{\n RequestPtr req(new Request(this, url.c_str()));\n return req;\n}\n\nvoid Curl::onTimer()\n{\n CURLMcode rc = CURLM_OK;\n do {\n LOG_TRACE;\n rc = curl_multi_socket_action(curlm_, CURL_SOCKET_TIMEOUT, 0, &runningHandles_);\n LOG_TRACE << rc << \" \" << runningHandles_;\n } while (rc == CURLM_CALL_MULTI_PERFORM);\n checkFinish();\n}\n\nvoid Curl::onRead(int fd)\n{\n CURLMcode rc = CURLM_OK;\n do {\n LOG_TRACE << fd;\n rc = curl_multi_socket_action(curlm_, fd, CURL_POLL_IN, &runningHandles_);\n LOG_TRACE << fd << \" \" << rc << \" \" << runningHandles_;\n } while (rc == CURLM_CALL_MULTI_PERFORM);\n checkFinish();\n}\n\nvoid Curl::onWrite(int fd)\n{\n CURLMcode rc = CURLM_OK;\n do {\n LOG_TRACE << fd;\n rc = curl_multi_socket_action(curlm_, fd, CURL_POLL_OUT, &runningHandles_);\n LOG_TRACE << fd << \" \" << rc << \" \" << runningHandles_;\n } while (rc == CURLM_CALL_MULTI_PERFORM);\n checkFinish();\n}\n\nvoid Curl::checkFinish()\n{\n if (prevRunningHandles_ > runningHandles_ || runningHandles_ == 0)\n {\n CURLMsg* msg = NULL;\n int left = 0;\n while ( (msg = curl_multi_info_read(curlm_, &left)) != NULL)\n {\n if (msg->msg == CURLMSG_DONE)\n {\n CURL* c = msg->easy_handle;\n CURLcode res = msg->data.result;\n Request* req = NULL;\n curl_easy_getinfo(c, CURLINFO_PRIVATE, &req);\n assert(req->getCurl() == c);\n LOG_TRACE << req << \" done\";\n req->done(res);\n }\n }\n }\n prevRunningHandles_ = runningHandles_;\n}\n" }, { "path": "examples/curl/Curl.h", "content": "#ifndef MUDUO_EXAMPLES_CURL_CURL_H\n#define MUDUO_EXAMPLES_CURL_CURL_H\n\n#include \"muduo/base/noncopyable.h\"\n#include \"muduo/base/StringPiece.h\"\n\n#include \"muduo/net/Callbacks.h\"\n\nextern \"C\"\n{\ntypedef void CURLM;\ntypedef void CURL;\n}\n\nnamespace muduo\n{\nnamespace net\n{\nclass Channel;\nclass EventLoop;\n}\n}\n\nnamespace curl\n{\n\nclass Curl;\n\nclass Request : public std::enable_shared_from_this,\n muduo::noncopyable\n{\n public:\n typedef std::function DataCallback;\n typedef std::function DoneCallback;\n\n Request(Curl*, const char* url);\n ~Request();\n\n void setDataCallback(const DataCallback& cb)\n { dataCb_ = cb; }\n\n void setDoneCallback(const DoneCallback& cb)\n { doneCb_ = cb; }\n\n void setHeaderCallback(const DataCallback& cb)\n { headerCb_ = cb; }\n\n // void allowRedirect(int redirects);\n void headerOnly();\n void setRange(const muduo::StringArg range);\n\n template\n int setopt(OPT opt, long p)\n {\n return curl_easy_setopt(curl_, opt, p);\n }\n\n template\n int setopt(OPT opt, const char* p)\n {\n return curl_easy_setopt(curl_, opt, p);\n }\n\n template\n int setopt(OPT opt, void* p)\n {\n return curl_easy_setopt(curl_, opt, p);\n }\n\n template\n int setopt(OPT opt, size_t (*p)(char *, size_t , size_t , void *))\n {\n return curl_easy_setopt(curl_, opt, p);\n }\n\n const char* getEffectiveUrl();\n const char* getRedirectUrl();\n int getResponseCode();\n\n // internal\n muduo::net::Channel* setChannel(int fd);\n void removeChannel();\n void done(int code);\n CURL* getCurl() { return curl_; }\n muduo::net::Channel* getChannel() { return muduo::get_pointer(channel_); }\n\n private:\n\n void dataCallback(const char* buffer, int len);\n void headerCallback(const char* buffer, int len);\n static size_t writeData(char *buffer, size_t size, size_t nmemb, void *userp);\n static size_t headerData(char *buffer, size_t size, size_t nmemb, void *userp);\n void doneCallback();\n\n class Curl* owner_;\n CURL* curl_;\n std::shared_ptr channel_;\n DataCallback dataCb_;\n DataCallback headerCb_;\n DoneCallback doneCb_;\n};\n\ntypedef std::shared_ptr RequestPtr;\n\nclass Curl : muduo::noncopyable\n{\n public:\n\n enum Option\n {\n kCURLnossl = 0,\n kCURLssl = 1,\n };\n\n explicit Curl(muduo::net::EventLoop* loop);\n ~Curl();\n\n RequestPtr getUrl(muduo::StringArg url);\n\n static void initialize(Option opt = kCURLnossl);\n\n // internal\n CURLM* getCurlm() { return curlm_; }\n muduo::net::EventLoop* getLoop() { return loop_; }\n\n private:\n void onTimer();\n void onRead(int fd);\n void onWrite(int fd);\n void checkFinish();\n\n static int socketCallback(CURL*, int, int, void*, void*);\n static int timerCallback(CURLM*, long, void*);\n\n muduo::net::EventLoop* loop_;\n CURLM* curlm_;\n int runningHandles_;\n int prevRunningHandles_;\n};\n\n} // namespace curl\n\n#endif // MUDUO_EXAMPLES_CURL_CURL_H\n" }, { "path": "examples/curl/README", "content": "This is a proof-of-concept implementation of muduo-curl bridge.\nIt demostrates the simplest use case of curl with muduo.\n\nNote:\n1. DNS resolving could be blocking, if your curl is not built with c-ares.\n2. Request object should survive doneCallback.\n" }, { "path": "examples/curl/download.cc", "content": "// Concurrent downloading one file from HTTP\n\n#include \"examples/curl/Curl.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\ntypedef std::shared_ptr FilePtr;\n\ntemplate\nbool startWith(const string& str, const char (&prefix)[N])\n{\n return str.size() >= N-1 && std::equal(prefix, prefix+N-1, str.begin());\n}\n\nclass Piece : noncopyable\n{\n public:\n Piece(const curl::RequestPtr& req,\n const FilePtr& out,\n const muduo::string& range,\n std::function done)\n : req_(req),\n out_(out),\n range_(range),\n doneCb_(std::move(done))\n {\n LOG_INFO << \"range: \" << range;\n req->setRange(range);\n req_->setDataCallback(\n std::bind(&Piece::onData, this, _1, _2));\n req_->setDoneCallback(\n std::bind(&Piece::onDone, this, _1, _2));\n }\n private:\n void onData(const char* data, int len)\n {\n ::fwrite(data, 1, len, get_pointer(out_));\n }\n\n void onDone(curl::Request* c, int code)\n {\n LOG_INFO << \"[\" << range_ << \"] is done\";\n req_.reset();\n out_.reset();\n doneCb_();\n }\n\n curl::RequestPtr req_;\n FilePtr out_;\n muduo::string range_;\n std::function doneCb_;\n};\n\nclass Downloader : noncopyable\n{\n public:\n Downloader(EventLoop* loop, const string& url)\n : loop_(loop),\n curl_(loop_),\n url_(url),\n req_(curl_.getUrl(url_)),\n found_(false),\n acceptRanges_(false),\n length_(0),\n pieces_(kConcurrent),\n concurrent_(0)\n {\n req_->setHeaderCallback(\n std::bind(&Downloader::onHeader, this, _1, _2));\n req_->setDoneCallback(\n std::bind(&Downloader::onHeaderDone, this, _1, _2));\n req_->headerOnly();\n }\n\n private:\n void onHeader(const char* data, int len)\n {\n string line(data, len);\n if (startWith(line, \"HTTP/1.1 200\") || startWith(line, \"HTTP/1.0 200\"))\n {\n found_ = true;\n }\n if (line == \"Accept-Ranges: bytes\\r\\n\")\n {\n acceptRanges_ = true;\n LOG_DEBUG << \"Accept-Ranges\";\n }\n else if (startWith(line, \"Content-Length:\"))\n {\n length_ = atoll(line.c_str() + strlen(\"Content-Length:\"));\n LOG_INFO << \"Content-Length: \" << length_;\n }\n }\n\n void onHeaderDone(curl::Request* c, int code)\n {\n LOG_DEBUG << code;\n if (acceptRanges_ && length_ >= kConcurrent * 4096)\n {\n LOG_INFO << \"Downloading with \" << kConcurrent << \" connections\";\n concurrent_ = kConcurrent;\n concurrentDownload();\n }\n else if (found_)\n {\n LOG_WARN << \"Single connection download\";\n FILE* fp = ::fopen(\"output\", \"wb\");\n if (fp)\n {\n FilePtr(fp, ::fclose).swap(out_);\n req_.reset();\n req2_ = curl_.getUrl(url_);\n req2_->setDataCallback(\n std::bind(&Downloader::onData, this, _1, _2));\n req2_->setDoneCallback(\n std::bind(&Downloader::onDownloadDone, this));\n concurrent_ = 1;\n }\n else\n {\n LOG_ERROR << \"Can not create output file\";\n loop_->quit();\n }\n }\n else\n {\n LOG_ERROR << \"File not found\";\n loop_->quit();\n }\n }\n\n void concurrentDownload()\n {\n const int64_t pieceLen = length_ / kConcurrent;\n for (int i = 0; i < kConcurrent; ++i)\n {\n char buf[256];\n snprintf(buf, sizeof buf, \"output-%05d-of-%05d\", i, kConcurrent);\n FILE* fp = ::fopen(buf, \"wb\");\n if (fp)\n {\n FilePtr out(fp, ::fclose);\n curl::RequestPtr req = curl_.getUrl(url_);\n\n std::ostringstream range;\n if (i < kConcurrent - 1)\n {\n range << i * pieceLen << \"-\" << (i+1) * pieceLen - 1;\n }\n else\n {\n range << i * pieceLen << \"-\" << length_ - 1;\n }\n pieces_[i].reset(new Piece(req,\n out,\n range.str(),\n std::bind(&Downloader::onDownloadDone, this)));\n }\n else\n {\n LOG_ERROR << \"Can not create output file: \" << buf;\n loop_->quit();\n }\n }\n }\n\n void onData(const char* data, int len)\n {\n ::fwrite(data, 1, len, get_pointer(out_));\n }\n\n void onDownloadDone()\n {\n if (--concurrent_ <= 0)\n {\n loop_->quit();\n }\n }\n\n EventLoop* loop_;\n curl::Curl curl_;\n string url_;\n curl::RequestPtr req_;\n curl::RequestPtr req2_;\n bool found_;\n bool acceptRanges_;\n int64_t length_;\n FilePtr out_;\n std::vector> pieces_;\n int concurrent_;\n\n const static int kConcurrent = 4;\n};\n\nint main(int argc, char* argv[])\n{\n EventLoop loop;\n curl::Curl::initialize(curl::Curl::kCURLssl);\n string url = argc > 1 ? argv[1] : \"https://chenshuo-public.s3.amazonaws.com/pdf/allinone.pdf\";\n Downloader d(&loop, url);\n loop.loop();\n}\n" }, { "path": "examples/curl/mcurl.cc", "content": "#include \"examples/curl/Curl.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \n\nusing namespace muduo::net;\n\nEventLoop* g_loop = NULL;\n\nvoid onData(const char* data, int len)\n{\n printf(\"len %d\\n\", len);\n}\n\nvoid done(curl::Request* c, int code)\n{\n printf(\"done %p %s %d\\n\", c, c->getEffectiveUrl(), code);\n}\n\nvoid done2(curl::Request* c, int code)\n{\n printf(\"done2 %p %s %d %d\\n\", c, c->getRedirectUrl(), c->getResponseCode(), code);\n // g_loop->quit();\n}\n\nint main(int argc, char* argv[])\n{\n EventLoop loop;\n g_loop = &loop;\n loop.runAfter(30.0, std::bind(&EventLoop::quit, &loop));\n curl::Curl::initialize(curl::Curl::kCURLssl);\n curl::Curl curl(&loop);\n\n curl::RequestPtr req = curl.getUrl(\"http://chenshuo.com\");\n req->setDataCallback(onData);\n req->setDoneCallback(done);\n\n curl::RequestPtr req2 = curl.getUrl(\"https://github.com\");\n // req2->allowRedirect(5);\n req2->setDataCallback(onData);\n req2->setDoneCallback(done);\n\n curl::RequestPtr req3 = curl.getUrl(\"http://example.com\");\n // req3->allowRedirect(5);\n req3->setDataCallback(onData);\n req3->setDoneCallback(done2);\n\n loop.loop();\n}\n" }, { "path": "examples/fastcgi/CMakeLists.txt", "content": "add_executable(fastcgi_test fastcgi.cc fastcgi_test.cc ../sudoku/sudoku.cc)\ntarget_link_libraries(fastcgi_test muduo_net)\n\n" }, { "path": "examples/fastcgi/fastcgi.cc", "content": "#include \"examples/fastcgi/fastcgi.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/Endian.h\"\n\nstruct FastCgiCodec::RecordHeader\n{\n uint8_t version;\n uint8_t type;\n uint16_t id;\n uint16_t length;\n uint8_t padding;\n uint8_t unused;\n};\n\nconst unsigned FastCgiCodec::kRecordHeader = static_cast(sizeof(FastCgiCodec::RecordHeader));\n\nenum FcgiType\n{\n kFcgiInvalid = 0,\n kFcgiBeginRequest = 1,\n kFcgiAbortRequest = 2,\n kFcgiEndRequest = 3,\n kFcgiParams = 4,\n kFcgiStdin = 5,\n kFcgiStdout = 6,\n kFcgiStderr = 7,\n kFcgiData = 8,\n kFcgiGetValues = 9,\n kFcgiGetValuesResult = 10,\n};\n\nenum FcgiRole\n{\n // kFcgiInvalid = 0,\n kFcgiResponder = 1,\n kFcgiAuthorizer = 2,\n};\n\nenum FcgiConstant\n{\n kFcgiKeepConn = 1,\n};\n\nusing namespace muduo::net;\n\nbool FastCgiCodec::onParams(const char* content, uint16_t length)\n{\n if (length > 0)\n {\n paramsStream_.append(content, length);\n }\n else if (!parseAllParams())\n {\n LOG_ERROR << \"parseAllParams() failed\";\n return false;\n }\n return true;\n}\n\nvoid FastCgiCodec::onStdin(const char* content, uint16_t length)\n{\n if (length > 0)\n {\n stdin_.append(content, length);\n }\n else\n {\n gotRequest_ = true;\n }\n}\n\nbool FastCgiCodec::parseAllParams()\n{\n while (paramsStream_.readableBytes() > 0)\n {\n uint32_t nameLen = readLen();\n if (nameLen == static_cast(-1))\n return false;\n uint32_t valueLen = readLen();\n if (valueLen == static_cast(-1))\n return false;\n if (paramsStream_.readableBytes() >= nameLen+valueLen)\n {\n std::string name = paramsStream_.retrieveAsString(nameLen);\n params_[name] = paramsStream_.retrieveAsString(valueLen);\n }\n else\n {\n return false;\n }\n }\n return true;\n}\n\nuint32_t FastCgiCodec::readLen()\n{\n if (paramsStream_.readableBytes() >= 1)\n {\n uint8_t byte = paramsStream_.peekInt8();\n if (byte & 0x80)\n {\n if (paramsStream_.readableBytes() >= sizeof(uint32_t))\n {\n return paramsStream_.readInt32() & 0x7fffffff;\n }\n else\n {\n return -1;\n }\n }\n else\n {\n return paramsStream_.readInt8();\n }\n }\n else\n {\n return -1;\n }\n}\n\nusing muduo::net::Buffer;\n\nvoid FastCgiCodec::endStdout(Buffer* buf)\n{\n RecordHeader header =\n {\n 1,\n kFcgiStdout,\n sockets::hostToNetwork16(1),\n 0,\n 0,\n 0,\n };\n buf->append(&header, kRecordHeader);\n}\n\nvoid FastCgiCodec::endRequest(Buffer* buf)\n{\n RecordHeader header =\n {\n 1,\n kFcgiEndRequest,\n sockets::hostToNetwork16(1),\n sockets::hostToNetwork16(kRecordHeader),\n 0,\n 0,\n };\n buf->append(&header, kRecordHeader);\n buf->appendInt32(0);\n buf->appendInt32(0);\n}\n\nvoid FastCgiCodec::respond(Buffer* response)\n{\n if (response->readableBytes() < 65536\n && response->prependableBytes() >= kRecordHeader)\n {\n RecordHeader header =\n {\n 1,\n kFcgiStdout,\n sockets::hostToNetwork16(1),\n sockets::hostToNetwork16(static_cast(response->readableBytes())),\n static_cast(-response->readableBytes() & 7),\n 0,\n };\n response->prepend(&header, kRecordHeader);\n response->append(\"\\0\\0\\0\\0\\0\\0\\0\\0\", header.padding);\n }\n else\n {\n // FIXME:\n }\n\n endStdout(response);\n endRequest(response);\n}\n\nbool FastCgiCodec::parseRequest(Buffer* buf)\n{\n while (buf->readableBytes() >= kRecordHeader)\n {\n RecordHeader header;\n memcpy(&header, buf->peek(), kRecordHeader);\n header.id = sockets::networkToHost16(header.id);\n header.length = sockets::networkToHost16(header.length);\n size_t total = kRecordHeader + header.length + header.padding;\n if (buf->readableBytes() >= total)\n {\n switch (header.type)\n {\n case kFcgiBeginRequest:\n onBeginRequest(header, buf);\n // FIXME: check\n break;\n case kFcgiParams:\n onParams(buf->peek() + kRecordHeader, header.length);\n // FIXME: check\n break;\n case kFcgiStdin:\n onStdin(buf->peek() + kRecordHeader, header.length);\n break;\n case kFcgiData:\n // FIXME:\n break;\n case kFcgiGetValues:\n // FIXME:\n break;\n default:\n // FIXME:\n break;\n }\n buf->retrieve(total);\n }\n else\n {\n break;\n }\n }\n return true;\n}\n\nuint16_t readInt16(const void* p)\n{\n uint16_t be16 = 0;\n ::memcpy(&be16, p, sizeof be16);\n return sockets::networkToHost16(be16);\n}\n\nbool FastCgiCodec::onBeginRequest(const RecordHeader& header, const Buffer* buf)\n{\n assert(buf->readableBytes() >= header.length);\n assert(header.type == kFcgiBeginRequest);\n\n if (header.length >= kRecordHeader)\n {\n uint16_t role = readInt16(buf->peek()+kRecordHeader);\n uint8_t flags = buf->peek()[kRecordHeader + sizeof(int16_t)];\n if (role == kFcgiResponder)\n {\n keepConn_ = flags == kFcgiKeepConn;\n return true;\n }\n }\n return false;\n}\n" }, { "path": "examples/fastcgi/fastcgi.h", "content": "#ifndef MUDUO_EXAMPLES_FASTCGI_FASTCGI_H\n#define MUDUO_EXAMPLES_FASTCGI_FASTCGI_H\n\n#include \"muduo/net/TcpConnection.h\"\n#include \n\n// one FastCgiCodec per TcpConnection\n// both lighttpd and nginx do not implement multiplexing,\n// so there is no concurrent requests of one connection.\nclass FastCgiCodec : muduo::noncopyable\n{\n public:\n typedef std::map ParamMap;\n typedef std::function Callback;\n\n explicit FastCgiCodec(const Callback& cb)\n : cb_(cb),\n gotRequest_(false),\n keepConn_(false)\n {\n }\n\n void onMessage(const muduo::net::TcpConnectionPtr& conn,\n muduo::net::Buffer* buf,\n muduo::Timestamp receiveTime)\n {\n parseRequest(buf);\n if (gotRequest_)\n {\n cb_(conn, params_, &stdin_);\n stdin_.retrieveAll();\n paramsStream_.retrieveAll();\n params_.clear();\n gotRequest_ = false;\n if (!keepConn_)\n {\n conn->shutdown();\n }\n }\n }\n\n static void respond(muduo::net::Buffer* response);\n\n private:\n struct RecordHeader;\n bool parseRequest(muduo::net::Buffer* buf);\n bool onBeginRequest(const RecordHeader& header, const muduo::net::Buffer* buf);\n void onStdin(const char* content, uint16_t length);\n bool onParams(const char* content, uint16_t length);\n bool parseAllParams();\n uint32_t readLen();\n\n static void endStdout(muduo::net::Buffer* buf);\n static void endRequest(muduo::net::Buffer* buf);\n\n Callback cb_;\n bool gotRequest_;\n bool keepConn_;\n muduo::net::Buffer stdin_;\n muduo::net::Buffer paramsStream_;\n ParamMap params_;\n\n const static unsigned kRecordHeader;\n};\n\n#endif // MUDUO_EXAMPLES_FASTCGI_FASTCGI_H\n" }, { "path": "examples/fastcgi/fastcgi_test.cc", "content": "#include \"examples/fastcgi/fastcgi.h\"\n#include \"examples/sudoku/sudoku.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n\nusing namespace muduo;\nusing namespace muduo::net;\n\nconst string kPath = \"/sudoku/\";\n\nvoid onRequest(const TcpConnectionPtr& conn,\n FastCgiCodec::ParamMap& params,\n Buffer* in)\n{\n string uri = params[\"REQUEST_URI\"];\n LOG_INFO << conn->name() << \": \" << uri;\n\n for (FastCgiCodec::ParamMap::const_iterator it = params.begin();\n it != params.end(); ++it)\n {\n LOG_DEBUG << it->first << \" = \" << it->second;\n }\n if (in->readableBytes() > 0)\n LOG_DEBUG << \"stdin \" << in->retrieveAllAsString();\n Buffer response;\n response.append(\"Context-Type: text/plain\\r\\n\\r\\n\");\n if (uri.size() == kCells + kPath.size() && uri.find(kPath) == 0)\n {\n response.append(solveSudoku(uri.substr(kPath.size())));\n }\n else\n {\n // FIXME: set http status code 400\n response.append(\"bad request\");\n }\n\n FastCgiCodec::respond(&response);\n conn->send(&response);\n}\n\nvoid onConnection(const TcpConnectionPtr& conn)\n{\n if (conn->connected())\n {\n typedef std::shared_ptr CodecPtr;\n CodecPtr codec(new FastCgiCodec(onRequest));\n conn->setContext(codec);\n conn->setMessageCallback(\n std::bind(&FastCgiCodec::onMessage, codec, _1, _2, _3));\n conn->setTcpNoDelay(true);\n }\n}\n\nint main(int argc, char* argv[])\n{\n int port = 19981;\n int threads = 0;\n if (argc > 1)\n port = atoi(argv[1]);\n if (argc > 2)\n threads = atoi(argv[2]);\n InetAddress addr(static_cast(port));\n LOG_INFO << \"Sudoku FastCGI listens on \" << addr.toIpPort()\n << \" threads \" << threads;\n muduo::net::EventLoop loop;\n TcpServer server(&loop, addr, \"FastCGI\");\n server.setConnectionCallback(onConnection);\n server.setThreadNum(threads);\n server.start();\n loop.loop();\n}\n" }, { "path": "examples/fastcgi/nginx.conf", "content": "\n#user nobody;\nworker_processes 1;\n\n#error_log logs/error.log;\n#error_log logs/error.log notice;\n#error_log logs/error.log info;\n\n#pid logs/nginx.pid;\n\nevents {\n worker_connections 1024;\n}\n\nhttp {\n #include mime.types;\n default_type application/octet-stream;\n\n #log_format main '$remote_addr - $remote_user [$time_local] \"$request\" '\n # '$status $body_bytes_sent \"$http_referer\" '\n # '\"$http_user_agent\" \"$http_x_forwarded_for\"';\n\n #access_log logs/access.log main;\n access_log off;\n\n sendfile on;\n #tcp_nopush on;\n\n keepalive_timeout 65;\n\n #gzip on;\n\n upstream muduo_backend {\n server localhost:19981;\n #server localhost:19982;\n keepalive 32;\n }\n\n server {\n listen 10080;\n server_name localhost;\n\n #access_log logs/host.access.log main;\n\n location / {\n root html;\n index index.html index.htm;\n }\n\n #error_page 404 /404.html;\n\n # redirect server error pages to the static page /50x.html\n #\n error_page 500 502 503 504 /50x.html;\n location = /50x.html {\n root html;\n }\n\n # pass /sudoku/ to muduo FastCGI server listening on 127.0.0.1:19981\n #\n location /sudoku/ {\n fastcgi_keep_conn on;\n fastcgi_pass muduo_backend;\n #include fastcgi_params;\n #fastcgi_param QUERY_STRING $query_string;\n #fastcgi_param REQUEST_METHOD $request_method;\n #fastcgi_param CONTENT_TYPE $content_type;\n #fastcgi_param CONTENT_LENGTH $content_length;\n\n #fastcgi_param SCRIPT_NAME $fastcgi_script_name;\n fastcgi_param REQUEST_URI $request_uri;\n #fastcgi_param DOCUMENT_URI $document_uri;\n #fastcgi_param DOCUMENT_ROOT $document_root;\n #fastcgi_param SERVER_PROTOCOL $server_protocol;\n #fastcgi_param HTTPS $https if_not_empty;\n\n #fastcgi_param GATEWAY_INTERFACE CGI/1.1;\n #fastcgi_param SERVER_SOFTWARE nginx/$nginx_version;\n\n #fastcgi_param REMOTE_ADDR $remote_addr;\n #fastcgi_param REMOTE_PORT $remote_port;\n #fastcgi_param SERVER_ADDR $server_addr;\n #fastcgi_param SERVER_PORT $server_port;\n #fastcgi_param SERVER_NAME $server_name;\n }\n\n # proxy the PHP scripts to Apache listening on 127.0.0.1:80\n #\n #location ~ \\.php$ {\n # proxy_pass http://127.0.0.1;\n #}\n\n # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000\n #\n #location ~ \\.php$ {\n # root html;\n # fastcgi_pass 127.0.0.1:9000;\n # fastcgi_index index.php;\n # fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;\n # include fastcgi_params;\n #}\n\n # deny access to .htaccess files, if Apache's document root\n # concurs with nginx's one\n #\n #location ~ /\\.ht {\n # deny all;\n #}\n }\n}\n" }, { "path": "examples/filetransfer/CMakeLists.txt", "content": "add_executable(filetransfer_download download.cc)\ntarget_link_libraries(filetransfer_download muduo_net)\n\nadd_executable(filetransfer_download2 download2.cc)\ntarget_link_libraries(filetransfer_download2 muduo_net)\n\nadd_executable(filetransfer_download3 download3.cc)\ntarget_link_libraries(filetransfer_download3 muduo_net)\n\n" }, { "path": "examples/filetransfer/download.cc", "content": "#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nconst char* g_file = NULL;\n\n// FIXME: use FileUtil::readFile()\nstring readFile(const char* filename)\n{\n string content;\n FILE* fp = ::fopen(filename, \"rb\");\n if (fp)\n {\n // inefficient!!!\n const int kBufSize = 1024*1024;\n char iobuf[kBufSize];\n ::setbuffer(fp, iobuf, sizeof iobuf);\n\n char buf[kBufSize];\n size_t nread = 0;\n while ( (nread = ::fread(buf, 1, sizeof buf, fp)) > 0)\n {\n content.append(buf, nread);\n }\n ::fclose(fp);\n }\n return content;\n}\n\nvoid onHighWaterMark(const TcpConnectionPtr& conn, size_t len)\n{\n LOG_INFO << \"HighWaterMark \" << len;\n}\n\nvoid onConnection(const TcpConnectionPtr& conn)\n{\n LOG_INFO << \"FileServer - \" << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n if (conn->connected())\n {\n LOG_INFO << \"FileServer - Sending file \" << g_file\n << \" to \" << conn->peerAddress().toIpPort();\n conn->setHighWaterMarkCallback(onHighWaterMark, 64*1024);\n string fileContent = readFile(g_file);\n conn->send(fileContent);\n conn->shutdown();\n LOG_INFO << \"FileServer - done\";\n }\n}\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n if (argc > 1)\n {\n g_file = argv[1];\n\n EventLoop loop;\n InetAddress listenAddr(2021);\n TcpServer server(&loop, listenAddr, \"FileServer\");\n server.setConnectionCallback(onConnection);\n server.start();\n loop.loop();\n }\n else\n {\n fprintf(stderr, \"Usage: %s file_for_downloading\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/filetransfer/download2.cc", "content": "#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nvoid onHighWaterMark(const TcpConnectionPtr& conn, size_t len)\n{\n LOG_INFO << \"HighWaterMark \" << len;\n}\n\nconst int kBufSize = 64*1024;\nconst char* g_file = NULL;\n\nvoid onConnection(const TcpConnectionPtr& conn)\n{\n LOG_INFO << \"FileServer - \" << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n if (conn->connected())\n {\n LOG_INFO << \"FileServer - Sending file \" << g_file\n << \" to \" << conn->peerAddress().toIpPort();\n conn->setHighWaterMarkCallback(onHighWaterMark, kBufSize+1);\n\n FILE* fp = ::fopen(g_file, \"rb\");\n if (fp)\n {\n conn->setContext(fp);\n char buf[kBufSize];\n size_t nread = ::fread(buf, 1, sizeof buf, fp);\n conn->send(buf, static_cast(nread));\n }\n else\n {\n conn->shutdown();\n LOG_INFO << \"FileServer - no such file\";\n }\n }\n else\n {\n if (!conn->getContext().empty())\n {\n FILE* fp = boost::any_cast(conn->getContext());\n if (fp)\n {\n ::fclose(fp);\n }\n }\n }\n}\n\nvoid onWriteComplete(const TcpConnectionPtr& conn)\n{\n FILE* fp = boost::any_cast(conn->getContext());\n char buf[kBufSize];\n size_t nread = ::fread(buf, 1, sizeof buf, fp);\n if (nread > 0)\n {\n conn->send(buf, static_cast(nread));\n }\n else\n {\n ::fclose(fp);\n fp = NULL;\n conn->setContext(fp);\n conn->shutdown();\n LOG_INFO << \"FileServer - done\";\n }\n}\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n if (argc > 1)\n {\n g_file = argv[1];\n\n EventLoop loop;\n InetAddress listenAddr(2021);\n TcpServer server(&loop, listenAddr, \"FileServer\");\n server.setConnectionCallback(onConnection);\n server.setWriteCompleteCallback(onWriteComplete);\n server.start();\n loop.loop();\n }\n else\n {\n fprintf(stderr, \"Usage: %s file_for_downloading\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/filetransfer/download3.cc", "content": "#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nvoid onHighWaterMark(const TcpConnectionPtr& conn, size_t len)\n{\n LOG_INFO << \"HighWaterMark \" << len;\n}\n\nconst int kBufSize = 64*1024;\nconst char* g_file = NULL;\ntypedef std::shared_ptr FilePtr;\n\nvoid onConnection(const TcpConnectionPtr& conn)\n{\n LOG_INFO << \"FileServer - \" << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n if (conn->connected())\n {\n LOG_INFO << \"FileServer - Sending file \" << g_file\n << \" to \" << conn->peerAddress().toIpPort();\n conn->setHighWaterMarkCallback(onHighWaterMark, kBufSize+1);\n\n FILE* fp = ::fopen(g_file, \"rb\");\n if (fp)\n {\n FilePtr ctx(fp, ::fclose);\n conn->setContext(ctx);\n char buf[kBufSize];\n size_t nread = ::fread(buf, 1, sizeof buf, fp);\n conn->send(buf, static_cast(nread));\n }\n else\n {\n conn->shutdown();\n LOG_INFO << \"FileServer - no such file\";\n }\n }\n}\n\nvoid onWriteComplete(const TcpConnectionPtr& conn)\n{\n const FilePtr& fp = boost::any_cast(conn->getContext());\n char buf[kBufSize];\n size_t nread = ::fread(buf, 1, sizeof buf, get_pointer(fp));\n if (nread > 0)\n {\n conn->send(buf, static_cast(nread));\n }\n else\n {\n conn->shutdown();\n LOG_INFO << \"FileServer - done\";\n }\n}\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n if (argc > 1)\n {\n g_file = argv[1];\n\n EventLoop loop;\n InetAddress listenAddr(2021);\n TcpServer server(&loop, listenAddr, \"FileServer\");\n server.setConnectionCallback(onConnection);\n server.setWriteCompleteCallback(onWriteComplete);\n server.start();\n loop.loop();\n }\n else\n {\n fprintf(stderr, \"Usage: %s file_for_downloading\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/filetransfer/loadtest/Client.java", "content": "import java.net.InetSocketAddress;\nimport java.util.Random;\nimport java.util.concurrent.CountDownLatch;\nimport java.util.concurrent.Executors;\n\nimport org.jboss.netty.bootstrap.ClientBootstrap;\nimport org.jboss.netty.channel.ChannelFactory;\nimport org.jboss.netty.channel.ChannelPipeline;\nimport org.jboss.netty.channel.ChannelPipelineFactory;\nimport org.jboss.netty.channel.Channels;\nimport org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;\n\npublic class Client {\n\n private static final class PipelineFactory implements ChannelPipelineFactory {\n private final int kMinLength;\n private final int kMaxLength;\n private final CountDownLatch latch;\n Random random = new Random();\n\n private PipelineFactory(int kMinLength, int kMaxLength, CountDownLatch latch) {\n this.kMinLength = kMinLength;\n this.kMaxLength = kMaxLength;\n this.latch = latch;\n assert kMinLength <= kMaxLength;\n }\n\n @Override\n public ChannelPipeline getPipeline() throws Exception {\n int variance = random.nextInt(kMaxLength - kMinLength + 1);\n int maxLength = kMinLength + variance;\n return Channels.pipeline(new Handler(maxLength, latch));\n }\n }\n\n static final int kClients = 500;\n static final int kMB = 1024 * 1024;\n static final int kMinLength = 1 * kMB;\n static final int kMaxLength = 6 * kMB;\n\n public static void main(String[] args) throws Exception {\n ChannelFactory channelFactory = new NioClientSocketChannelFactory(\n Executors.newCachedThreadPool(),\n Executors.newCachedThreadPool());\n long start = System.currentTimeMillis();\n\n final CountDownLatch latch = new CountDownLatch(kClients);\n ChannelPipelineFactory pipelineFactory = new PipelineFactory(kMinLength, kMaxLength, latch);\n for (int i = 0; i < kClients; ++i) {\n ClientBootstrap bootstrap = new ClientBootstrap(channelFactory);\n bootstrap.setPipelineFactory(pipelineFactory);\n bootstrap.connect(new InetSocketAddress(args[0], 2021));\n }\n\n latch.await();\n\n System.out.println(Thread.currentThread().getId() + \" All done. \"\n + (System.currentTimeMillis() - start));\n System.exit(0);\n }\n\n}\n" }, { "path": "examples/filetransfer/loadtest/Handler.java", "content": "import java.math.BigInteger;\nimport java.security.MessageDigest;\nimport java.util.concurrent.CountDownLatch;\n\nimport org.jboss.netty.buffer.BigEndianHeapChannelBuffer;\nimport org.jboss.netty.channel.Channel;\nimport org.jboss.netty.channel.ChannelHandlerContext;\nimport org.jboss.netty.channel.ChannelStateEvent;\nimport org.jboss.netty.channel.ExceptionEvent;\nimport org.jboss.netty.channel.MessageEvent;\nimport org.jboss.netty.channel.SimpleChannelUpstreamHandler;\n\npublic class Handler extends SimpleChannelUpstreamHandler {\n\n private static int created = 0;\n private int received = 0;\n private final int maxLength;\n private int id;\n private CountDownLatch latch;\n private MessageDigest digest;\n\n public Handler(int maxLength, CountDownLatch latch) throws Exception {\n this.id = created++;\n this.maxLength = maxLength;\n this.latch = latch;\n this.digest = MessageDigest.getInstance(\"MD5\");\n System.out.println(\"Handler tid=\" + Thread.currentThread().getId() + \" \" + id);\n }\n\n @Override\n public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)\n throws Exception {\n System.out.println(\"channelConnected tid=\" + Thread.currentThread().getId() + \" \" + id);\n }\n\n @Override\n public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e)\n throws Exception {\n byte[] md5 = digest.digest();\n BigInteger bigInt = new BigInteger(1, md5);\n System.out.println(\"channelDisconnected tid=\" + Thread.currentThread().getId() + \" \" + id\n + \" got \"\n + received + \" \" + bigInt.toString(16));\n latch.countDown();\n }\n\n @Override\n public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {\n BigEndianHeapChannelBuffer message = (BigEndianHeapChannelBuffer) e.getMessage();\n // System.out.println(\"messageReceived \" + ctx.getChannel() + message.readableBytes());\n received += message.readableBytes();\n digest.update(message.array(), message.readerIndex(), message.readableBytes());\n if (received > maxLength) {\n System.out.println(\"messageReceived tid=\" + Thread.currentThread().getId()\n + \" \" + id + \" got \" + received);\n ctx.getChannel().close();\n }\n }\n\n @Override\n public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {\n e.getCause().printStackTrace();\n\n Channel ch = e.getChannel();\n ch.close();\n latch.countDown();\n }\n}\n" }, { "path": "examples/hub/CMakeLists.txt", "content": "add_executable(hub hub.cc codec.cc)\ntarget_link_libraries(hub muduo_inspect)\n\nadd_library(muduo_pubsub pubsub.cc codec.cc)\ntarget_link_libraries(muduo_pubsub muduo_net)\n\nadd_executable(pub pub.cc)\ntarget_link_libraries(pub muduo_pubsub)\n\nadd_executable(sub sub.cc)\ntarget_link_libraries(sub muduo_pubsub)\n\n" }, { "path": "examples/hub/README", "content": "hub - a server for broadcasting\npubsub - a client library of hub\npub - a command line tool for publishing content on a topic\nsub - a demo tool for subscribing a topic\n\n" }, { "path": "examples/hub/codec.cc", "content": "#include \"examples/hub/codec.h\"\n\nusing namespace muduo;\nusing namespace muduo::net;\nusing namespace pubsub;\n\nParseResult pubsub::parseMessage(Buffer* buf,\n string* cmd,\n string* topic,\n string* content)\n{\n ParseResult result = kError;\n const char* crlf = buf->findCRLF();\n if (crlf)\n {\n const char* space = std::find(buf->peek(), crlf, ' ');\n if (space != crlf)\n {\n cmd->assign(buf->peek(), space);\n topic->assign(space+1, crlf);\n if (*cmd == \"pub\")\n {\n const char* start = crlf + 2;\n crlf = buf->findCRLF(start);\n if (crlf)\n {\n content->assign(start, crlf);\n buf->retrieveUntil(crlf+2);\n result = kSuccess;\n }\n else\n {\n result = kContinue;\n }\n }\n else\n {\n buf->retrieveUntil(crlf+2);\n result = kSuccess;\n }\n }\n else\n {\n result = kError;\n }\n }\n else\n {\n result = kContinue;\n }\n return result;\n}\n\n" }, { "path": "examples/hub/codec.h", "content": "#ifndef MUDUO_EXAMPLES_HUB_CODEC_H\n#define MUDUO_EXAMPLES_HUB_CODEC_H\n\n// internal header file\n\n#include \"muduo/base/Types.h\"\n#include \"muduo/net/Buffer.h\"\n\nnamespace pubsub\n{\nusing muduo::string;\n\nenum ParseResult\n{\n kError,\n kSuccess,\n kContinue,\n};\n\nParseResult parseMessage(muduo::net::Buffer* buf,\n string* cmd,\n string* topic,\n string* content);\n} // namespace pubsub\n\n#endif // MUDUO_EXAMPLES_HUB_CODEC_H\n\n" }, { "path": "examples/hub/hub.cc", "content": "#include \"examples/hub/codec.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nnamespace pubsub\n{\n\ntypedef std::set ConnectionSubscription;\n\nclass Topic : public muduo::copyable\n{\n public:\n Topic(const string& topic)\n : topic_(topic)\n {\n }\n\n void add(const TcpConnectionPtr& conn)\n {\n audiences_.insert(conn);\n if (lastPubTime_.valid())\n {\n conn->send(makeMessage());\n }\n }\n\n void remove(const TcpConnectionPtr& conn)\n {\n audiences_.erase(conn);\n }\n\n void publish(const string& content, Timestamp time)\n {\n content_ = content;\n lastPubTime_ = time;\n string message = makeMessage();\n for (std::set::iterator it = audiences_.begin();\n it != audiences_.end();\n ++it)\n {\n (*it)->send(message);\n }\n }\n\n private:\n\n string makeMessage()\n {\n return \"pub \" + topic_ + \"\\r\\n\" + content_ + \"\\r\\n\";\n }\n\n string topic_;\n string content_;\n Timestamp lastPubTime_;\n std::set audiences_;\n};\n\nclass PubSubServer : noncopyable\n{\n public:\n PubSubServer(muduo::net::EventLoop* loop,\n const muduo::net::InetAddress& listenAddr)\n : loop_(loop),\n server_(loop, listenAddr, \"PubSubServer\")\n {\n server_.setConnectionCallback(\n std::bind(&PubSubServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&PubSubServer::onMessage, this, _1, _2, _3));\n loop_->runEvery(1.0, std::bind(&PubSubServer::timePublish, this));\n }\n\n void start()\n {\n server_.start();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n if (conn->connected())\n {\n conn->setContext(ConnectionSubscription());\n }\n else\n {\n const ConnectionSubscription& connSub\n = boost::any_cast(conn->getContext());\n // subtle: doUnsubscribe will erase *it, so increase before calling.\n for (ConnectionSubscription::const_iterator it = connSub.begin();\n it != connSub.end();)\n {\n doUnsubscribe(conn, *it++);\n }\n }\n }\n\n void onMessage(const TcpConnectionPtr& conn,\n Buffer* buf,\n Timestamp receiveTime)\n {\n ParseResult result = kSuccess;\n while (result == kSuccess)\n {\n string cmd;\n string topic;\n string content;\n result = parseMessage(buf, &cmd, &topic, &content);\n if (result == kSuccess)\n {\n if (cmd == \"pub\")\n {\n doPublish(conn->name(), topic, content, receiveTime);\n }\n else if (cmd == \"sub\")\n {\n LOG_INFO << conn->name() << \" subscribes \" << topic;\n doSubscribe(conn, topic);\n }\n else if (cmd == \"unsub\")\n {\n doUnsubscribe(conn, topic);\n }\n else\n {\n conn->shutdown();\n result = kError;\n }\n }\n else if (result == kError)\n {\n conn->shutdown();\n }\n }\n }\n\n void timePublish()\n {\n Timestamp now = Timestamp::now();\n doPublish(\"internal\", \"utc_time\", now.toFormattedString(), now);\n }\n\n void doSubscribe(const TcpConnectionPtr& conn,\n const string& topic)\n {\n ConnectionSubscription* connSub\n = boost::any_cast(conn->getMutableContext());\n\n connSub->insert(topic);\n getTopic(topic).add(conn);\n }\n\n void doUnsubscribe(const TcpConnectionPtr& conn,\n const string& topic)\n {\n LOG_INFO << conn->name() << \" unsubscribes \" << topic;\n getTopic(topic).remove(conn);\n // topic could be the one to be destroyed, so don't use it after erasing.\n ConnectionSubscription* connSub\n = boost::any_cast(conn->getMutableContext());\n connSub->erase(topic);\n }\n\n void doPublish(const string& source,\n const string& topic,\n const string& content,\n Timestamp time)\n {\n getTopic(topic).publish(content, time);\n }\n\n Topic& getTopic(const string& topic)\n {\n std::map::iterator it = topics_.find(topic);\n if (it == topics_.end())\n {\n it = topics_.insert(make_pair(topic, Topic(topic))).first;\n }\n return it->second;\n }\n\n EventLoop* loop_;\n TcpServer server_;\n std::map topics_;\n};\n\n} // namespace pubsub\n\nint main(int argc, char* argv[])\n{\n if (argc > 1)\n {\n uint16_t port = static_cast(atoi(argv[1]));\n EventLoop loop;\n if (argc > 2)\n {\n //int inspectPort = atoi(argv[2]);\n }\n pubsub::PubSubServer server(&loop, InetAddress(port));\n server.start();\n loop.loop();\n }\n else\n {\n printf(\"Usage: %s pubsub_port [inspect_port]\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/hub/pub.cc", "content": "#include \"examples/hub/pubsub.h\"\n#include \"muduo/base/ProcessInfo.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/EventLoopThread.h\"\n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\nusing namespace pubsub;\n\nEventLoop* g_loop = NULL;\nstring g_topic;\nstring g_content;\n\nvoid connection(PubSubClient* client)\n{\n if (client->connected())\n {\n client->publish(g_topic, g_content);\n client->stop();\n }\n else\n {\n g_loop->quit();\n }\n}\n\nint main(int argc, char* argv[])\n{\n if (argc == 4)\n {\n string hostport = argv[1];\n size_t colon = hostport.find(':');\n if (colon != string::npos)\n {\n string hostip = hostport.substr(0, colon);\n uint16_t port = static_cast(atoi(hostport.c_str()+colon+1));\n g_topic = argv[2];\n g_content = argv[3];\n\n string name = ProcessInfo::username()+\"@\"+ProcessInfo::hostname();\n name += \":\" + ProcessInfo::pidString();\n\n if (g_content == \"-\")\n {\n EventLoopThread loopThread;\n g_loop = loopThread.startLoop();\n PubSubClient client(g_loop, InetAddress(hostip, port), name);\n client.start();\n\n string line;\n while (getline(std::cin, line))\n {\n client.publish(g_topic, line);\n }\n client.stop();\n CurrentThread::sleepUsec(1000*1000);\n }\n else\n {\n EventLoop loop;\n g_loop = &loop;\n PubSubClient client(g_loop, InetAddress(hostip, port), name);\n client.setConnectionCallback(connection);\n client.start();\n loop.loop();\n }\n }\n else\n {\n printf(\"Usage: %s hub_ip:port topic content\\n\", argv[0]);\n }\n }\n else\n {\n printf(\"Usage: %s hub_ip:port topic content\\n\"\n \"Read contents from stdin:\\n\"\n \" %s hub_ip:port topic -\\n\", argv[0], argv[0]);\n }\n}\n" }, { "path": "examples/hub/pubsub.cc", "content": "#include \"examples/hub/pubsub.h\"\n#include \"examples/hub/codec.h\"\n\nusing namespace muduo;\nusing namespace muduo::net;\nusing namespace pubsub;\n\nPubSubClient::PubSubClient(EventLoop* loop,\n const InetAddress& hubAddr,\n const string& name)\n : client_(loop, hubAddr, name)\n{\n // FIXME: dtor is not thread safe\n client_.setConnectionCallback(\n std::bind(&PubSubClient::onConnection, this, _1));\n client_.setMessageCallback(\n std::bind(&PubSubClient::onMessage, this, _1, _2, _3));\n}\n\nvoid PubSubClient::start()\n{\n client_.connect();\n}\n\nvoid PubSubClient::stop()\n{\n client_.disconnect();\n}\n\nbool PubSubClient::connected() const\n{\n return conn_ && conn_->connected();\n}\n\nbool PubSubClient::subscribe(const string& topic, const SubscribeCallback& cb)\n{\n string message = \"sub \" + topic + \"\\r\\n\";\n subscribeCallback_ = cb;\n return send(message);\n}\n\nvoid PubSubClient::unsubscribe(const string& topic)\n{\n string message = \"unsub \" + topic + \"\\r\\n\";\n send(message);\n}\n\n\nbool PubSubClient::publish(const string& topic, const string& content)\n{\n string message = \"pub \" + topic + \"\\r\\n\" + content + \"\\r\\n\";\n return send(message);\n}\n\nvoid PubSubClient::onConnection(const TcpConnectionPtr& conn)\n{\n if (conn->connected())\n {\n conn_ = conn;\n // FIXME: re-sub\n }\n else\n {\n conn_.reset();\n }\n if (connectionCallback_)\n {\n connectionCallback_(this);\n }\n}\n\nvoid PubSubClient::onMessage(const TcpConnectionPtr& conn,\n Buffer* buf,\n Timestamp receiveTime)\n{\n ParseResult result = kSuccess;\n while (result == kSuccess)\n {\n string cmd;\n string topic;\n string content;\n result = parseMessage(buf, &cmd, &topic, &content);\n if (result == kSuccess)\n {\n if (cmd == \"pub\" && subscribeCallback_)\n {\n subscribeCallback_(topic, content, receiveTime);\n }\n }\n else if (result == kError)\n {\n conn->shutdown();\n }\n }\n}\n\nbool PubSubClient::send(const string& message)\n{\n bool succeed = false;\n if (conn_ && conn_->connected())\n {\n conn_->send(message);\n succeed = true;\n }\n return succeed;\n}\n" }, { "path": "examples/hub/pubsub.h", "content": "#ifndef MUDUO_EXAMPLES_HUB_PUBSUB_H\n#define MUDUO_EXAMPLES_HUB_PUBSUB_H\n\n#include \"muduo/net/TcpClient.h\"\n\nnamespace pubsub\n{\nusing muduo::string;\n\n// FIXME: dtor is not thread safe\nclass PubSubClient : muduo::noncopyable\n{\n public:\n typedef std::function ConnectionCallback;\n typedef std::function SubscribeCallback;\n\n PubSubClient(muduo::net::EventLoop* loop,\n const muduo::net::InetAddress& hubAddr,\n const string& name);\n void start();\n void stop();\n bool connected() const;\n\n void setConnectionCallback(const ConnectionCallback& cb)\n { connectionCallback_ = cb; }\n\n bool subscribe(const string& topic, const SubscribeCallback& cb);\n void unsubscribe(const string& topic);\n bool publish(const string& topic, const string& content);\n\n private:\n void onConnection(const muduo::net::TcpConnectionPtr& conn);\n void onMessage(const muduo::net::TcpConnectionPtr& conn,\n muduo::net::Buffer* buf,\n muduo::Timestamp receiveTime);\n bool send(const string& message);\n\n muduo::net::TcpClient client_;\n muduo::net::TcpConnectionPtr conn_;\n ConnectionCallback connectionCallback_;\n SubscribeCallback subscribeCallback_;\n};\n} // namespace pubsub\n\n#endif // MUDUO_EXAMPLES_HUB_PUBSUB_H\n" }, { "path": "examples/hub/sub.cc", "content": "#include \"examples/hub/pubsub.h\"\n#include \"muduo/base/ProcessInfo.h\"\n#include \"muduo/net/EventLoop.h\"\n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\nusing namespace pubsub;\n\nEventLoop* g_loop = NULL;\nstd::vector g_topics;\n\nvoid subscription(const string& topic, const string& content, Timestamp)\n{\n printf(\"%s: %s\\n\", topic.c_str(), content.c_str());\n}\n\nvoid connection(PubSubClient* client)\n{\n if (client->connected())\n {\n for (std::vector::iterator it = g_topics.begin();\n it != g_topics.end(); ++it)\n {\n client->subscribe(*it, subscription);\n }\n }\n else\n {\n g_loop->quit();\n }\n}\n\nint main(int argc, char* argv[])\n{\n if (argc > 2)\n {\n string hostport = argv[1];\n size_t colon = hostport.find(':');\n if (colon != string::npos)\n {\n string hostip = hostport.substr(0, colon);\n uint16_t port = static_cast(atoi(hostport.c_str()+colon+1));\n for (int i = 2; i < argc; ++i)\n {\n g_topics.push_back(argv[i]);\n }\n\n EventLoop loop;\n g_loop = &loop;\n string name = ProcessInfo::username()+\"@\"+ProcessInfo::hostname();\n name += \":\" + ProcessInfo::pidString();\n PubSubClient client(&loop, InetAddress(hostip, port), name);\n client.setConnectionCallback(connection);\n client.start();\n loop.loop();\n }\n else\n {\n printf(\"Usage: %s hub_ip:port topic [topic ...]\\n\", argv[0]);\n }\n }\n else\n {\n printf(\"Usage: %s hub_ip:port topic [topic ...]\\n\", argv[0]);\n }\n}\n" }, { "path": "examples/idleconnection/CMakeLists.txt", "content": "add_executable(idleconnection_echo echo.cc main.cc)\ntarget_link_libraries(idleconnection_echo muduo_net)\n\nadd_executable(idleconnection_echo2 sortedlist.cc)\ntarget_link_libraries(idleconnection_echo2 muduo_net)\n" }, { "path": "examples/idleconnection/echo.cc", "content": "#include \"examples/idleconnection/echo.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\n\nEchoServer::EchoServer(EventLoop* loop,\n const InetAddress& listenAddr,\n int idleSeconds)\n : server_(loop, listenAddr, \"EchoServer\"),\n connectionBuckets_(idleSeconds)\n{\n server_.setConnectionCallback(\n std::bind(&EchoServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&EchoServer::onMessage, this, _1, _2, _3));\n loop->runEvery(1.0, std::bind(&EchoServer::onTimer, this));\n connectionBuckets_.resize(idleSeconds);\n dumpConnectionBuckets();\n}\n\nvoid EchoServer::start()\n{\n server_.start();\n}\n\nvoid EchoServer::onConnection(const TcpConnectionPtr& conn)\n{\n LOG_INFO << \"EchoServer - \" << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n if (conn->connected())\n {\n EntryPtr entry(new Entry(conn));\n connectionBuckets_.back().insert(entry);\n dumpConnectionBuckets();\n WeakEntryPtr weakEntry(entry);\n conn->setContext(weakEntry);\n }\n else\n {\n assert(!conn->getContext().empty());\n WeakEntryPtr weakEntry(boost::any_cast(conn->getContext()));\n LOG_DEBUG << \"Entry use_count = \" << weakEntry.use_count();\n }\n}\n\nvoid EchoServer::onMessage(const TcpConnectionPtr& conn,\n Buffer* buf,\n Timestamp time)\n{\n string msg(buf->retrieveAllAsString());\n LOG_INFO << conn->name() << \" echo \" << msg.size()\n << \" bytes at \" << time.toString();\n conn->send(msg);\n\n assert(!conn->getContext().empty());\n WeakEntryPtr weakEntry(boost::any_cast(conn->getContext()));\n EntryPtr entry(weakEntry.lock());\n if (entry)\n {\n connectionBuckets_.back().insert(entry);\n dumpConnectionBuckets();\n }\n}\n\nvoid EchoServer::onTimer()\n{\n connectionBuckets_.push_back(Bucket());\n dumpConnectionBuckets();\n}\n\nvoid EchoServer::dumpConnectionBuckets() const\n{\n LOG_INFO << \"size = \" << connectionBuckets_.size();\n int idx = 0;\n for (WeakConnectionList::const_iterator bucketI = connectionBuckets_.begin();\n bucketI != connectionBuckets_.end();\n ++bucketI, ++idx)\n {\n const Bucket& bucket = *bucketI;\n printf(\"[%d] len = %zd : \", idx, bucket.size());\n for (const auto& it : bucket)\n {\n bool connectionDead = it->weakConn_.expired();\n printf(\"%p(%ld)%s, \", get_pointer(it), it.use_count(),\n connectionDead ? \" DEAD\" : \"\");\n }\n puts(\"\");\n }\n}\n\n" }, { "path": "examples/idleconnection/echo.h", "content": "#ifndef MUDUO_EXAMPLES_IDLECONNECTION_ECHO_H\n#define MUDUO_EXAMPLES_IDLECONNECTION_ECHO_H\n\n#include \"muduo/net/TcpServer.h\"\n//#include \n\n#include \n\n#include \n\n// RFC 862\nclass EchoServer\n{\n public:\n EchoServer(muduo::net::EventLoop* loop,\n const muduo::net::InetAddress& listenAddr,\n int idleSeconds);\n\n void start();\n\n private:\n void onConnection(const muduo::net::TcpConnectionPtr& conn);\n\n void onMessage(const muduo::net::TcpConnectionPtr& conn,\n muduo::net::Buffer* buf,\n muduo::Timestamp time);\n\n void onTimer();\n\n void dumpConnectionBuckets() const;\n\n typedef std::weak_ptr WeakTcpConnectionPtr;\n\n struct Entry : public muduo::copyable\n {\n explicit Entry(const WeakTcpConnectionPtr& weakConn)\n : weakConn_(weakConn)\n {\n }\n\n ~Entry()\n {\n muduo::net::TcpConnectionPtr conn = weakConn_.lock();\n if (conn)\n {\n conn->shutdown();\n }\n }\n\n WeakTcpConnectionPtr weakConn_;\n };\n typedef std::shared_ptr EntryPtr;\n typedef std::weak_ptr WeakEntryPtr;\n typedef std::unordered_set Bucket;\n typedef boost::circular_buffer WeakConnectionList;\n\n muduo::net::TcpServer server_;\n WeakConnectionList connectionBuckets_;\n};\n\n#endif // MUDUO_EXAMPLES_IDLECONNECTION_ECHO_H\n" }, { "path": "examples/idleconnection/main.cc", "content": "#include \"examples/idleconnection/echo.h\"\n#include \n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n\nusing namespace muduo;\nusing namespace muduo::net;\n\n/*\nvoid testHash()\n{\n boost::hash > h;\n std::shared_ptr x1(new int(10));\n std::shared_ptr x2(new int(10));\n h(x1);\n assert(h(x1) != h(x2));\n x1 = x2;\n assert(h(x1) == h(x2));\n x1.reset();\n assert(h(x1) != h(x2));\n x2.reset();\n assert(h(x1) == h(x2));\n}\n*/\n\nint main(int argc, char* argv[])\n{\n // testHash();\n EventLoop loop;\n InetAddress listenAddr(2007);\n int idleSeconds = 10;\n if (argc > 1)\n {\n idleSeconds = atoi(argv[1]);\n }\n LOG_INFO << \"pid = \" << getpid() << \", idle seconds = \" << idleSeconds;\n EchoServer server(&loop, listenAddr, idleSeconds);\n server.start();\n loop.loop();\n}\n\n" }, { "path": "examples/idleconnection/sortedlist.cc", "content": "#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/TcpServer.h\"\n#include \n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\n// RFC 862\nclass EchoServer\n{\n public:\n EchoServer(EventLoop* loop,\n const InetAddress& listenAddr,\n int idleSeconds);\n\n void start()\n {\n server_.start();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn);\n\n void onMessage(const TcpConnectionPtr& conn,\n Buffer* buf,\n Timestamp time);\n\n void onTimer();\n\n void dumpConnectionList() const;\n\n typedef std::weak_ptr WeakTcpConnectionPtr;\n typedef std::list WeakConnectionList;\n\n struct Node : public muduo::copyable\n {\n Timestamp lastReceiveTime;\n WeakConnectionList::iterator position;\n };\n\n TcpServer server_;\n int idleSeconds_;\n WeakConnectionList connectionList_;\n};\n\nEchoServer::EchoServer(EventLoop* loop,\n const InetAddress& listenAddr,\n int idleSeconds)\n : server_(loop, listenAddr, \"EchoServer\"),\n idleSeconds_(idleSeconds)\n{\n server_.setConnectionCallback(\n std::bind(&EchoServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&EchoServer::onMessage, this, _1, _2, _3));\n loop->runEvery(1.0, std::bind(&EchoServer::onTimer, this));\n dumpConnectionList();\n}\n\nvoid EchoServer::onConnection(const TcpConnectionPtr& conn)\n{\n LOG_INFO << \"EchoServer - \" << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n if (conn->connected())\n {\n Node node;\n node.lastReceiveTime = Timestamp::now();\n connectionList_.push_back(conn);\n node.position = --connectionList_.end();\n conn->setContext(node);\n }\n else\n {\n assert(!conn->getContext().empty());\n const Node& node = boost::any_cast(conn->getContext());\n connectionList_.erase(node.position);\n }\n dumpConnectionList();\n}\n\nvoid EchoServer::onMessage(const TcpConnectionPtr& conn,\n Buffer* buf,\n Timestamp time)\n{\n string msg(buf->retrieveAllAsString());\n LOG_INFO << conn->name() << \" echo \" << msg.size()\n << \" bytes at \" << time.toString();\n conn->send(msg);\n\n assert(!conn->getContext().empty());\n Node* node = boost::any_cast(conn->getMutableContext());\n node->lastReceiveTime = time;\n connectionList_.splice(connectionList_.end(), connectionList_, node->position);\n assert(node->position == --connectionList_.end());\n\n dumpConnectionList();\n}\n\nvoid EchoServer::onTimer()\n{\n dumpConnectionList();\n Timestamp now = Timestamp::now();\n for (WeakConnectionList::iterator it = connectionList_.begin();\n it != connectionList_.end();)\n {\n TcpConnectionPtr conn = it->lock();\n if (conn)\n {\n Node* n = boost::any_cast(conn->getMutableContext());\n double age = timeDifference(now, n->lastReceiveTime);\n if (age > idleSeconds_)\n {\n if (conn->connected())\n {\n conn->shutdown();\n LOG_INFO << \"shutting down \" << conn->name();\n conn->forceCloseWithDelay(3.5); // > round trip of the whole Internet.\n }\n }\n else if (age < 0)\n {\n LOG_WARN << \"Time jump\";\n n->lastReceiveTime = now;\n }\n else\n {\n break;\n }\n ++it;\n }\n else\n {\n LOG_WARN << \"Expired\";\n it = connectionList_.erase(it);\n }\n }\n}\n\nvoid EchoServer::dumpConnectionList() const\n{\n LOG_INFO << \"size = \" << connectionList_.size();\n\n for (WeakConnectionList::const_iterator it = connectionList_.begin();\n it != connectionList_.end(); ++it)\n {\n TcpConnectionPtr conn = it->lock();\n if (conn)\n {\n printf(\"conn %p\\n\", get_pointer(conn));\n const Node& n = boost::any_cast(conn->getContext());\n printf(\" time %s\\n\", n.lastReceiveTime.toString().c_str());\n }\n else\n {\n printf(\"expired\\n\");\n }\n }\n}\n\nint main(int argc, char* argv[])\n{\n EventLoop loop;\n InetAddress listenAddr(2007);\n int idleSeconds = 10;\n if (argc > 1)\n {\n idleSeconds = atoi(argv[1]);\n }\n LOG_INFO << \"pid = \" << getpid() << \", idle seconds = \" << idleSeconds;\n EchoServer server(&loop, listenAddr, idleSeconds);\n server.start();\n loop.loop();\n}\n\n" }, { "path": "examples/maxconnection/CMakeLists.txt", "content": "add_executable(maxconnection_echo echo.cc main.cc)\ntarget_link_libraries(maxconnection_echo muduo_net)\n" }, { "path": "examples/maxconnection/echo.cc", "content": "#include \"examples/maxconnection/echo.h\"\n\n#include \"muduo/base/Logging.h\"\n\nusing namespace muduo;\nusing namespace muduo::net;\n\nEchoServer::EchoServer(EventLoop* loop,\n const InetAddress& listenAddr,\n int maxConnections)\n : server_(loop, listenAddr, \"EchoServer\"),\n numConnected_(0),\n kMaxConnections_(maxConnections)\n{\n server_.setConnectionCallback(\n std::bind(&EchoServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&EchoServer::onMessage, this, _1, _2, _3));\n}\n\nvoid EchoServer::start()\n{\n server_.start();\n}\n\nvoid EchoServer::onConnection(const TcpConnectionPtr& conn)\n{\n LOG_INFO << \"EchoServer - \" << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n if (conn->connected())\n {\n ++numConnected_;\n if (numConnected_ > kMaxConnections_)\n {\n conn->shutdown();\n conn->forceCloseWithDelay(3.0); // > round trip of the whole Internet.\n }\n }\n else\n {\n --numConnected_;\n }\n LOG_INFO << \"numConnected = \" << numConnected_;\n}\n\nvoid EchoServer::onMessage(const TcpConnectionPtr& conn,\n Buffer* buf,\n Timestamp time)\n{\n string msg(buf->retrieveAllAsString());\n LOG_INFO << conn->name() << \" echo \" << msg.size() << \" bytes at \" << time.toString();\n conn->send(msg);\n}\n\n" }, { "path": "examples/maxconnection/echo.h", "content": "#ifndef MUDUO_EXAMPLES_MAXCONNECTION_ECHO_H\n#define MUDUO_EXAMPLES_MAXCONNECTION_ECHO_H\n\n#include \"muduo/net/TcpServer.h\"\n\n// RFC 862\nclass EchoServer\n{\n public:\n EchoServer(muduo::net::EventLoop* loop,\n const muduo::net::InetAddress& listenAddr,\n int maxConnections);\n\n void start();\n\n private:\n void onConnection(const muduo::net::TcpConnectionPtr& conn);\n\n void onMessage(const muduo::net::TcpConnectionPtr& conn,\n muduo::net::Buffer* buf,\n muduo::Timestamp time);\n\n muduo::net::TcpServer server_;\n int numConnected_; // should be atomic_int\n const int kMaxConnections_;\n};\n\n#endif // MUDUO_EXAMPLES_MAXCONNECTION_ECHO_H\n" }, { "path": "examples/maxconnection/main.cc", "content": "#include \"examples/maxconnection/echo.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n\n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n EventLoop loop;\n InetAddress listenAddr(2007);\n int maxConnections = 5;\n if (argc > 1)\n {\n maxConnections = atoi(argv[1]);\n }\n LOG_INFO << \"maxConnections = \" << maxConnections;\n EchoServer server(&loop, listenAddr, maxConnections);\n server.start();\n loop.loop();\n}\n\n" }, { "path": "examples/memcached/README", "content": "Simple implementation of memcached protocol for both server and client side.\nNot meant to replace memcached, but just sample code of network programming with muduo.\n\nServer limits:\n - The memory management is not customized, just uses (tc)malloc.\n - It doesn't control the memory footprint\n - Unix domain socket is not supported\n - Only listen on one TCP port\n\nServer goals:\n - Pass as many feature tests as possible\n - Prefer simplicity over performance\n\nTODO:\n - incr/decr\n - UDP\n - Binary protocol\n - expiration\n - LRU\n" }, { "path": "examples/memcached/client/CMakeLists.txt", "content": "if(BOOSTPO_LIBRARY)\n add_executable(memcached_bench bench.cc)\n target_link_libraries(memcached_bench muduo_net boost_program_options)\nendif()\n" }, { "path": "examples/memcached/client/bench.cc", "content": "#include \"muduo/base/CountDownLatch.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/EventLoopThreadPool.h\"\n#include \"muduo/net/TcpClient.h\"\n\n#include \n#include \n\n#include \n\nnamespace po = boost::program_options;\nusing namespace muduo;\nusing namespace muduo::net;\n\nclass Client : noncopyable\n{\n public:\n enum Operation\n {\n kGet,\n kSet,\n };\n\n Client(const string& name,\n EventLoop* loop,\n const InetAddress& serverAddr,\n Operation op,\n int requests,\n int keys,\n int valuelen,\n CountDownLatch* connected,\n CountDownLatch* finished)\n : name_(name),\n client_(loop, serverAddr, name),\n op_(op),\n sent_(0),\n acked_(0),\n requests_(requests),\n keys_(keys),\n valuelen_(valuelen),\n value_(valuelen_, 'a'),\n connected_(connected),\n finished_(finished)\n {\n value_ += \"\\r\\n\";\n client_.setConnectionCallback(std::bind(&Client::onConnection, this, _1));\n client_.setMessageCallback(std::bind(&Client::onMessage, this, _1, _2, _3));\n client_.connect();\n }\n\n void send()\n {\n Buffer buf;\n fill(&buf);\n conn_->send(&buf);\n }\n\n private:\n\n void onConnection(const TcpConnectionPtr& conn)\n {\n if (conn->connected())\n {\n conn_ = conn;\n connected_->countDown();\n }\n else\n {\n conn_.reset();\n client_.getLoop()->queueInLoop(std::bind(&CountDownLatch::countDown, finished_));\n }\n }\n\n void onMessage(const TcpConnectionPtr& conn,\n Buffer* buffer,\n Timestamp receiveTime)\n {\n if (op_ == kSet)\n {\n while (buffer->readableBytes() > 0)\n {\n const char* crlf = buffer->findCRLF();\n if (crlf)\n {\n buffer->retrieveUntil(crlf+2);\n ++acked_;\n if (sent_ < requests_)\n {\n send();\n }\n }\n else\n {\n break;\n }\n }\n }\n else\n {\n while (buffer->readableBytes() > 0)\n {\n const char* end = static_cast(memmem(buffer->peek(),\n buffer->readableBytes(),\n \"END\\r\\n\", 5));\n if (end)\n {\n buffer->retrieveUntil(end+5);\n ++acked_;\n if (sent_ < requests_)\n {\n send();\n }\n }\n else\n {\n break;\n }\n }\n }\n if (acked_ == requests_)\n {\n conn_->shutdown();\n }\n }\n\n void fill(Buffer* buf)\n {\n char req[256];\n if (op_ == kSet)\n {\n snprintf(req, sizeof req, \"set %s%d 42 0 %d\\r\\n\", name_.c_str(), sent_ % keys_, valuelen_);\n ++sent_;\n buf->append(req);\n buf->append(value_);\n }\n else\n {\n snprintf(req, sizeof req, \"get %s%d\\r\\n\", name_.c_str(), sent_ % keys_);\n ++sent_;\n buf->append(req);\n }\n }\n\n string name_;\n TcpClient client_;\n TcpConnectionPtr conn_;\n const Operation op_;\n int sent_;\n int acked_;\n const int requests_;\n const int keys_;\n const int valuelen_;\n string value_;\n CountDownLatch* const connected_;\n CountDownLatch* const finished_;\n};\n\nint main(int argc, char* argv[])\n{\n Logger::setLogLevel(Logger::WARN);\n\n uint16_t tcpport = 11211;\n string hostIp = \"127.0.0.1\";\n int threads = 4;\n int clients = 100;\n int requests = 100000;\n int keys = 10000;\n bool set = false;\n\n po::options_description desc(\"Allowed options\");\n desc.add_options()\n (\"help,h\", \"Help\")\n (\"port,p\", po::value(&tcpport), \"TCP port\")\n (\"ip,i\", po::value(&hostIp), \"Host IP\")\n (\"threads,t\", po::value(&threads), \"Number of worker threads\")\n (\"clients,c\", po::value(&clients), \"Number of concurrent clients\")\n (\"requests,r\", po::value(&requests), \"Number of requests per clients\")\n (\"keys,k\", po::value(&keys), \"Number of keys per clients\")\n (\"set,s\", \"Get or Set\")\n ;\n\n po::variables_map vm;\n po::store(po::parse_command_line(argc, argv, desc), vm);\n po::notify(vm);\n\n if (vm.count(\"help\"))\n {\n std::cout << desc << \"\\n\";\n return 0;\n }\n set = vm.count(\"set\");\n\n InetAddress serverAddr(hostIp, tcpport);\n LOG_WARN << \"Connecting \" << serverAddr.toIpPort();\n\n EventLoop loop;\n EventLoopThreadPool pool(&loop, \"bench-memcache\");\n\n int valuelen = 100;\n Client::Operation op = set ? Client::kSet : Client::kGet;\n\n double memoryMiB = 1.0 * clients * keys * (32+80+valuelen+8) / 1024 / 1024;\n LOG_WARN << \"estimated memcached-debug memory usage \" << int(memoryMiB) << \" MiB\";\n\n pool.setThreadNum(threads);\n pool.start();\n\n char buf[32];\n CountDownLatch connected(clients);\n CountDownLatch finished(clients);\n std::vector> holder;\n for (int i = 0; i < clients; ++i)\n {\n snprintf(buf, sizeof buf, \"%d-\", i+1);\n holder.emplace_back(new Client(buf,\n pool.getNextLoop(),\n serverAddr,\n op,\n requests,\n keys,\n valuelen,\n &connected,\n &finished));\n }\n connected.wait();\n LOG_WARN << clients << \" clients all connected\";\n Timestamp start = Timestamp::now();\n for (int i = 0; i < clients; ++i)\n {\n holder[i]->send();\n }\n finished.wait();\n Timestamp end = Timestamp::now();\n LOG_WARN << \"All finished\";\n double seconds = timeDifference(end, start);\n LOG_WARN << seconds << \" sec\";\n LOG_WARN << 1.0 * clients * requests / seconds << \" QPS\";\n}\n" }, { "path": "examples/memcached/server/CMakeLists.txt", "content": "if(BOOSTPO_LIBRARY)\n add_executable(memcached_debug Item.cc MemcacheServer.cc Session.cc server.cc)\n target_link_libraries(memcached_debug muduo_net muduo_inspect boost_program_options)\nendif()\n\nadd_executable(memcached_footprint Item.cc MemcacheServer.cc Session.cc footprint_test.cc)\ntarget_link_libraries(memcached_footprint muduo_net muduo_inspect)\n\nif(TCMALLOC_INCLUDE_DIR AND TCMALLOC_LIBRARY)\n set_target_properties(memcached_footprint PROPERTIES COMPILE_FLAGS \"-DHAVE_TCMALLOC\")\n if(BOOSTPO_LIBRARY)\n set_target_properties(memcached_debug PROPERTIES COMPILE_FLAGS \"-DHAVE_TCMALLOC\")\n endif()\nendif()\n\n" }, { "path": "examples/memcached/server/Item.cc", "content": "#include \"examples/memcached/server/Item.h\"\n\n#include \"muduo/base/LogStream.h\"\n#include \"muduo/net/Buffer.h\"\n\n#include \n\n#include // memcpy\n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nItem::Item(StringPiece keyArg,\n uint32_t flagsArg,\n int exptimeArg,\n int valuelen,\n uint64_t casArg)\n : keylen_(keyArg.size()),\n flags_(flagsArg),\n rel_exptime_(exptimeArg),\n valuelen_(valuelen),\n receivedBytes_(0),\n cas_(casArg),\n hash_(boost::hash_range(keyArg.begin(), keyArg.end())),\n data_(static_cast(::malloc(totalLen())))\n{\n assert(valuelen_ >= 2);\n assert(receivedBytes_ < totalLen());\n append(keyArg.data(), keylen_);\n}\n\nvoid Item::append(const char* data, size_t len)\n{\n assert(len <= neededBytes());\n memcpy(data_ + receivedBytes_, data, len);\n receivedBytes_ += static_cast(len);\n assert(receivedBytes_ <= totalLen());\n}\n\nvoid Item::output(Buffer* out, bool needCas) const\n{\n out->append(\"VALUE \");\n out->append(data_, keylen_);\n LogStream buf;\n buf << ' ' << flags_ << ' ' << valuelen_-2;\n if (needCas)\n {\n buf << ' ' << cas_;\n }\n buf << \"\\r\\n\";\n out->append(buf.buffer().data(), buf.buffer().length());\n out->append(value(), valuelen_);\n}\n\nvoid Item::resetKey(StringPiece k)\n{\n assert(k.size() <= 250);\n keylen_ = k.size();\n receivedBytes_ = 0;\n append(k.data(), k.size());\n hash_ = boost::hash_range(k.begin(), k.end());\n}\n" }, { "path": "examples/memcached/server/Item.h", "content": "#ifndef MUDUO_EXAMPLES_MEMCACHED_SERVER_ITEM_H\n#define MUDUO_EXAMPLES_MEMCACHED_SERVER_ITEM_H\n\n#include \"muduo/base/Atomic.h\"\n#include \"muduo/base/StringPiece.h\"\n#include \"muduo/base/Types.h\"\n\n#include \n\nnamespace muduo\n{\nnamespace net\n{\nclass Buffer;\n}\n}\n\nclass Item;\ntypedef std::shared_ptr ItemPtr; // TODO: use unique_ptr\ntypedef std::shared_ptr ConstItemPtr; // TODO: use unique_ptr\n\n// Item is immutable once added into hash table\nclass Item : muduo::noncopyable\n{\n public:\n enum UpdatePolicy\n {\n kInvalid,\n kSet,\n kAdd,\n kReplace,\n kAppend,\n kPrepend,\n kCas,\n };\n\n static ItemPtr makeItem(muduo::StringPiece keyArg,\n uint32_t flagsArg,\n int exptimeArg,\n int valuelen,\n uint64_t casArg)\n {\n return std::make_shared(keyArg, flagsArg, exptimeArg, valuelen, casArg);\n //return ItemPtr(new Item(keyArg, flagsArg, exptimeArg, valuelen, casArg));\n }\n\n Item(muduo::StringPiece keyArg,\n uint32_t flagsArg,\n int exptimeArg,\n int valuelen,\n uint64_t casArg);\n\n ~Item()\n {\n ::free(data_);\n }\n\n muduo::StringPiece key() const\n {\n return muduo::StringPiece(data_, keylen_);\n }\n\n uint32_t flags() const\n {\n return flags_;\n }\n\n int rel_exptime() const\n {\n return rel_exptime_;\n }\n\n const char* value() const\n {\n return data_+keylen_;\n }\n\n size_t valueLength() const\n {\n return valuelen_;\n }\n\n uint64_t cas() const\n {\n return cas_;\n }\n\n size_t hash() const\n {\n return hash_;\n }\n\n void setCas(uint64_t casArg)\n {\n cas_ = casArg;\n }\n\n size_t neededBytes() const\n {\n return totalLen() - receivedBytes_;\n }\n\n void append(const char* data, size_t len);\n\n bool endsWithCRLF() const\n {\n return receivedBytes_ == totalLen()\n && data_[totalLen()-2] == '\\r'\n && data_[totalLen()-1] == '\\n';\n }\n\n void output(muduo::net::Buffer* out, bool needCas = false) const;\n\n void resetKey(muduo::StringPiece k);\n\n private:\n int totalLen() const { return keylen_ + valuelen_; }\n\n int keylen_;\n const uint32_t flags_;\n const int rel_exptime_;\n const int valuelen_;\n int receivedBytes_; // FIXME: remove this member\n uint64_t cas_;\n size_t hash_;\n char* data_;\n};\n\n#endif // MUDUO_EXAMPLES_MEMCACHED_SERVER_ITEM_H\n" }, { "path": "examples/memcached/server/MemcacheServer.cc", "content": "#include \"examples/memcached/server/MemcacheServer.h\"\n\n#include \"muduo/base/Atomic.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n\nusing namespace muduo;\nusing namespace muduo::net;\n\nmuduo::AtomicInt64 g_cas;\n\nMemcacheServer::Options::Options()\n{\n memZero(this, sizeof(*this));\n}\n\nstruct MemcacheServer::Stats\n{\n};\n\nMemcacheServer::MemcacheServer(muduo::net::EventLoop* loop, const Options& options)\n : loop_(loop),\n options_(options),\n startTime_(::time(NULL)-1),\n server_(loop, InetAddress(options.tcpport), \"muduo-memcached\"),\n stats_(new Stats)\n{\n server_.setConnectionCallback(\n std::bind(&MemcacheServer::onConnection, this, _1));\n}\n\nMemcacheServer::~MemcacheServer() = default;\n\nvoid MemcacheServer::start()\n{\n server_.start();\n}\n\nvoid MemcacheServer::stop()\n{\n loop_->runAfter(3.0, std::bind(&EventLoop::quit, loop_));\n}\n\nbool MemcacheServer::storeItem(const ItemPtr& item, const Item::UpdatePolicy policy, bool* exists)\n{\n assert(item->neededBytes() == 0);\n MutexLock& mutex = shards_[item->hash() % kShards].mutex;\n ItemMap& items = shards_[item->hash() % kShards].items;\n MutexLockGuard lock(mutex);\n ItemMap::const_iterator it = items.find(item);\n *exists = it != items.end();\n if (policy == Item::kSet)\n {\n item->setCas(g_cas.incrementAndGet());\n if (*exists)\n {\n items.erase(it);\n }\n items.insert(item);\n }\n else\n {\n if (policy == Item::kAdd)\n {\n if (*exists)\n {\n return false;\n }\n else\n {\n item->setCas(g_cas.incrementAndGet());\n items.insert(item);\n }\n }\n else if (policy == Item::kReplace)\n {\n if (*exists)\n {\n item->setCas(g_cas.incrementAndGet());\n items.erase(it);\n items.insert(item);\n }\n else\n {\n return false;\n }\n }\n else if (policy == Item::kAppend || policy == Item::kPrepend)\n {\n if (*exists)\n {\n const ConstItemPtr& oldItem = *it;\n int newLen = static_cast(item->valueLength() + oldItem->valueLength() - 2);\n ItemPtr newItem(Item::makeItem(item->key(),\n oldItem->flags(),\n oldItem->rel_exptime(),\n newLen,\n g_cas.incrementAndGet()));\n if (policy == Item::kAppend)\n {\n newItem->append(oldItem->value(), oldItem->valueLength() - 2);\n newItem->append(item->value(), item->valueLength());\n }\n else\n {\n newItem->append(item->value(), item->valueLength() - 2);\n newItem->append(oldItem->value(), oldItem->valueLength());\n }\n assert(newItem->neededBytes() == 0);\n assert(newItem->endsWithCRLF());\n items.erase(it);\n items.insert(newItem);\n }\n else\n {\n return false;\n }\n }\n else if (policy == Item::kCas)\n {\n if (*exists && (*it)->cas() == item->cas())\n {\n item->setCas(g_cas.incrementAndGet());\n items.erase(it);\n items.insert(item);\n }\n else\n {\n return false;\n }\n }\n else\n {\n assert(false);\n }\n }\n return true;\n}\n\nConstItemPtr MemcacheServer::getItem(const ConstItemPtr& key) const\n{\n MutexLock& mutex = shards_[key->hash() % kShards].mutex;\n const ItemMap& items = shards_[key->hash() % kShards].items;\n MutexLockGuard lock(mutex);\n ItemMap::const_iterator it = items.find(key);\n return it != items.end() ? *it : ConstItemPtr();\n}\n\nbool MemcacheServer::deleteItem(const ConstItemPtr& key)\n{\n MutexLock& mutex = shards_[key->hash() % kShards].mutex;\n ItemMap& items = shards_[key->hash() % kShards].items;\n MutexLockGuard lock(mutex);\n return items.erase(key) == 1;\n}\n\nvoid MemcacheServer::onConnection(const TcpConnectionPtr& conn)\n{\n if (conn->connected())\n {\n SessionPtr session(new Session(this, conn));\n MutexLockGuard lock(mutex_);\n assert(sessions_.find(conn->name()) == sessions_.end());\n sessions_[conn->name()] = session;\n // assert(sessions_.size() == stats_.current_conns);\n }\n else\n {\n MutexLockGuard lock(mutex_);\n assert(sessions_.find(conn->name()) != sessions_.end());\n sessions_.erase(conn->name());\n // assert(sessions_.size() == stats_.current_conns);\n }\n}\n" }, { "path": "examples/memcached/server/MemcacheServer.h", "content": "#ifndef MUDUO_EXAMPLES_MEMCACHED_SERVER_MEMCACHESERVER_H\n#define MUDUO_EXAMPLES_MEMCACHED_SERVER_MEMCACHESERVER_H\n\n#include \"examples/memcached/server/Item.h\"\n#include \"examples/memcached/server/Session.h\"\n\n#include \"muduo/base/Mutex.h\"\n#include \"muduo/net/TcpServer.h\"\n#include \"examples/wordcount/hash.h\"\n\n#include \n#include \n#include \n\nclass MemcacheServer : muduo::noncopyable\n{\n public:\n struct Options\n {\n Options();\n uint16_t tcpport;\n uint16_t udpport;\n uint16_t gperfport;\n int threads;\n };\n\n MemcacheServer(muduo::net::EventLoop* loop, const Options&);\n ~MemcacheServer();\n\n void setThreadNum(int threads) { server_.setThreadNum(threads); }\n void start();\n void stop();\n\n time_t startTime() const { return startTime_; }\n\n bool storeItem(const ItemPtr& item, Item::UpdatePolicy policy, bool* exists);\n ConstItemPtr getItem(const ConstItemPtr& key) const;\n bool deleteItem(const ConstItemPtr& key);\n\n private:\n void onConnection(const muduo::net::TcpConnectionPtr& conn);\n\n struct Stats;\n\n muduo::net::EventLoop* loop_; // not own\n Options options_;\n const time_t startTime_;\n\n mutable muduo::MutexLock mutex_;\n std::unordered_map sessions_ GUARDED_BY(mutex_);\n\n // a complicated solution to save memory\n struct Hash\n {\n size_t operator()(const ConstItemPtr& x) const\n {\n return x->hash();\n }\n };\n\n struct Equal\n {\n bool operator()(const ConstItemPtr& x, const ConstItemPtr& y) const\n {\n return x->key() == y->key();\n }\n };\n\n typedef std::unordered_set ItemMap;\n\n struct MapWithLock\n {\n ItemMap items;\n mutable muduo::MutexLock mutex;\n };\n\n const static int kShards = 4096;\n\n std::array shards_;\n\n // NOT guarded by mutex_, but here because server_ has to destructs before\n // sessions_\n muduo::net::TcpServer server_;\n std::unique_ptr stats_ PT_GUARDED_BY(mutex_);\n};\n\n#endif // MUDUO_EXAMPLES_MEMCACHED_SERVER_MEMCACHESERVER_H\n" }, { "path": "examples/memcached/server/Session.cc", "content": "#include \"examples/memcached/server/Session.h\"\n#include \"examples/memcached/server/MemcacheServer.h\"\n\n#ifdef HAVE_TCMALLOC\n#include \n#endif\n\nusing namespace muduo;\nusing namespace muduo::net;\n\nstatic bool isBinaryProtocol(uint8_t firstByte)\n{\n return firstByte == 0x80;\n}\n\nconst int kLongestKeySize = 250;\nstring Session::kLongestKey(kLongestKeySize, 'x');\n\ntemplate \nbool Session::SpaceSeparator::operator()(InputIterator& next, InputIterator end, Token& tok)\n{\n while (next != end && *next == ' ')\n ++next;\n if (next == end)\n {\n tok.clear();\n return false;\n }\n InputIterator start(next);\n const char* sp = static_cast(memchr(start, ' ', end - start));\n if (sp)\n {\n tok.set(start, static_cast(sp - start));\n next = sp;\n }\n else\n {\n tok.set(start, static_cast(end - next));\n next = end;\n }\n return true;\n}\n\nstruct Session::Reader\n{\n Reader(Tokenizer::iterator& beg, Tokenizer::iterator end)\n : first_(beg),\n last_(end)\n {\n }\n\n template\n bool read(T* val)\n {\n if (first_ == last_)\n return false;\n char* end = NULL;\n uint64_t x = strtoull((*first_).data(), &end, 10);\n if (end == (*first_).end())\n {\n *val = static_cast(x);\n ++first_;\n return true;\n }\n return false;\n }\n\n private:\n Tokenizer::iterator first_;\n Tokenizer::iterator last_;;\n};\n\nvoid Session::onMessage(const muduo::net::TcpConnectionPtr& conn,\n muduo::net::Buffer* buf,\n muduo::Timestamp)\n\n{\n const size_t initialReadable = buf->readableBytes();\n\n while (buf->readableBytes() > 0)\n {\n if (state_ == kNewCommand)\n {\n if (protocol_ == kAuto)\n {\n assert(bytesRead_ == 0);\n protocol_ = isBinaryProtocol(buf->peek()[0]) ? kBinary : kAscii;\n }\n\n assert(protocol_ == kAscii || protocol_ == kBinary);\n if (protocol_ == kBinary)\n {\n // FIXME\n }\n else // ASCII protocol\n {\n const char* crlf = buf->findCRLF();\n if (crlf)\n {\n int len = static_cast(crlf - buf->peek());\n StringPiece request(buf->peek(), len);\n if (processRequest(request))\n {\n resetRequest();\n }\n buf->retrieveUntil(crlf + 2);\n }\n else\n {\n if (buf->readableBytes() > 1024)\n {\n // FIXME: check for 'get' and 'gets'\n conn_->shutdown();\n // buf->retrieveAll() ???\n }\n break;\n }\n }\n }\n else if (state_ == kReceiveValue)\n {\n receiveValue(buf);\n }\n else if (state_ == kDiscardValue)\n {\n discardValue(buf);\n }\n else\n {\n assert(false);\n }\n }\n bytesRead_ += initialReadable - buf->readableBytes();\n}\n\nvoid Session::receiveValue(muduo::net::Buffer* buf)\n{\n assert(currItem_.get());\n assert(state_ == kReceiveValue);\n // if (protocol_ == kBinary)\n\n const size_t avail = std::min(buf->readableBytes(), currItem_->neededBytes());\n assert(currItem_.unique());\n currItem_->append(buf->peek(), avail);\n buf->retrieve(avail);\n if (currItem_->neededBytes() == 0)\n {\n if (currItem_->endsWithCRLF())\n {\n bool exists = false;\n if (owner_->storeItem(currItem_, policy_, &exists))\n {\n reply(\"STORED\\r\\n\");\n }\n else\n {\n if (policy_ == Item::kCas)\n {\n if (exists)\n {\n reply(\"EXISTS\\r\\n\");\n }\n else\n {\n reply(\"NOT_FOUND\\r\\n\");\n }\n }\n else\n {\n reply(\"NOT_STORED\\r\\n\");\n }\n }\n }\n else\n {\n reply(\"CLIENT_ERROR bad data chunk\\r\\n\");\n }\n resetRequest();\n state_ = kNewCommand;\n }\n}\n\nvoid Session::discardValue(muduo::net::Buffer* buf)\n{\n assert(!currItem_);\n assert(state_ == kDiscardValue);\n if (buf->readableBytes() < bytesToDiscard_)\n {\n bytesToDiscard_ -= buf->readableBytes();\n buf->retrieveAll();\n }\n else\n {\n buf->retrieve(bytesToDiscard_);\n bytesToDiscard_ = 0;\n resetRequest();\n state_ = kNewCommand;\n }\n}\n\nbool Session::processRequest(StringPiece request)\n{\n assert(command_.empty());\n assert(!noreply_);\n assert(policy_ == Item::kInvalid);\n assert(!currItem_);\n assert(bytesToDiscard_ == 0);\n ++requestsProcessed_;\n\n // check 'noreply' at end of request line\n if (request.size() >= 8)\n {\n StringPiece end(request.end() - 8, 8);\n if (end == \" noreply\")\n {\n noreply_ = true;\n request.remove_suffix(8);\n }\n }\n\n SpaceSeparator sep;\n Tokenizer tok(request.begin(), request.end(), sep);\n Tokenizer::iterator beg = tok.begin();\n if (beg == tok.end())\n {\n reply(\"ERROR\\r\\n\");\n return true;\n }\n (*beg).CopyToString(&command_);\n ++beg;\n if (command_ == \"set\" || command_ == \"add\" || command_ == \"replace\"\n || command_ == \"append\" || command_ == \"prepend\" || command_ == \"cas\")\n {\n // this normally returns false\n return doUpdate(beg, tok.end());\n }\n else if (command_ == \"get\" || command_ == \"gets\")\n {\n bool cas = command_ == \"gets\";\n\n // FIXME: send multiple chunks with write complete callback.\n while (beg != tok.end())\n {\n StringPiece key = *beg;\n bool good = key.size() <= kLongestKeySize;\n if (!good)\n {\n reply(\"CLIENT_ERROR bad command line format\\r\\n\");\n return true;\n }\n\n needle_->resetKey(key);\n ConstItemPtr item = owner_->getItem(needle_);\n ++beg;\n if (item)\n {\n item->output(&outputBuf_, cas);\n }\n }\n outputBuf_.append(\"END\\r\\n\");\n\n if (conn_->outputBuffer()->writableBytes() > 65536 + outputBuf_.readableBytes())\n {\n LOG_DEBUG << \"shrink output buffer from \" << conn_->outputBuffer()->internalCapacity();\n conn_->outputBuffer()->shrink(65536 + outputBuf_.readableBytes());\n }\n\n conn_->send(&outputBuf_);\n }\n else if (command_ == \"delete\")\n {\n doDelete(beg, tok.end());\n }\n else if (command_ == \"version\")\n {\n#ifdef HAVE_TCMALLOC\n reply(\"VERSION 0.01 muduo with tcmalloc\\r\\n\");\n#else\n reply(\"VERSION 0.01 muduo\\r\\n\");\n#endif\n }\n#ifdef HAVE_TCMALLOC\n else if (command_ == \"memstat\")\n {\n char buf[1024*64];\n MallocExtension::instance()->GetStats(buf, sizeof buf);\n reply(buf);\n }\n#endif\n else if (command_ == \"quit\")\n {\n conn_->shutdown();\n }\n else if (command_ == \"shutdown\")\n {\n // \"ERROR: shutdown not enabled\"\n conn_->shutdown();\n owner_->stop();\n }\n else\n {\n reply(\"ERROR\\r\\n\");\n LOG_INFO << \"Unknown command: \" << command_;\n }\n return true;\n}\n\nvoid Session::resetRequest()\n{\n command_.clear();\n noreply_ = false;\n policy_ = Item::kInvalid;\n currItem_.reset();\n bytesToDiscard_ = 0;\n}\n\nvoid Session::reply(muduo::StringPiece msg)\n{\n if (!noreply_)\n {\n conn_->send(msg.data(), msg.size());\n }\n}\n\nbool Session::doUpdate(Session::Tokenizer::iterator& beg, Session::Tokenizer::iterator end)\n{\n if (command_ == \"set\")\n policy_ = Item::kSet;\n else if (command_ == \"add\")\n policy_ = Item::kAdd;\n else if (command_ == \"replace\")\n policy_ = Item::kReplace;\n else if (command_ == \"append\")\n policy_ = Item::kAppend;\n else if (command_ == \"prepend\")\n policy_ = Item::kPrepend;\n else if (command_ == \"cas\")\n policy_ = Item::kCas;\n else\n assert(false);\n\n // FIXME: check (beg != end)\n StringPiece key = (*beg);\n ++beg;\n bool good = key.size() <= kLongestKeySize;\n\n uint32_t flags = 0;\n time_t exptime = 1;\n int bytes = -1;\n uint64_t cas = 0;\n\n Reader r(beg, end);\n good = good && r.read(&flags) && r.read(&exptime) && r.read(&bytes);\n\n int rel_exptime = static_cast(exptime);\n if (exptime > 60*60*24*30)\n {\n rel_exptime = static_cast(exptime - owner_->startTime());\n if (rel_exptime < 1)\n {\n rel_exptime = 1;\n }\n }\n else\n {\n // rel_exptime = exptime + currentTime;\n }\n\n if (good && policy_ == Item::kCas)\n {\n good = r.read(&cas);\n }\n\n if (!good)\n {\n reply(\"CLIENT_ERROR bad command line format\\r\\n\");\n return true;\n }\n if (bytes > 1024*1024)\n {\n reply(\"SERVER_ERROR object too large for cache\\r\\n\");\n needle_->resetKey(key);\n owner_->deleteItem(needle_);\n bytesToDiscard_ = bytes + 2;\n state_ = kDiscardValue;\n return false;\n }\n else\n {\n currItem_ = Item::makeItem(key, flags, rel_exptime, bytes + 2, cas);\n state_ = kReceiveValue;\n return false;\n }\n}\n\nvoid Session::doDelete(Session::Tokenizer::iterator& beg, Session::Tokenizer::iterator end)\n{\n assert(command_ == \"delete\");\n // FIXME: check (beg != end)\n StringPiece key = *beg;\n bool good = key.size() <= kLongestKeySize;\n ++beg;\n if (!good)\n {\n reply(\"CLIENT_ERROR bad command line format\\r\\n\");\n }\n else if (beg != end && *beg != \"0\") // issue 108, old protocol\n {\n reply(\"CLIENT_ERROR bad command line format. Usage: delete [noreply]\\r\\n\");\n }\n else\n {\n needle_->resetKey(key);\n if (owner_->deleteItem(needle_))\n {\n reply(\"DELETED\\r\\n\");\n }\n else\n {\n reply(\"NOT_FOUND\\r\\n\");\n }\n }\n}\n" }, { "path": "examples/memcached/server/Session.h", "content": "#ifndef MUDUO_EXAMPLES_MEMCACHED_SERVER_SESSION_H\n#define MUDUO_EXAMPLES_MEMCACHED_SERVER_SESSION_H\n\n#include \"examples/memcached/server/Item.h\"\n\n#include \"muduo/base/Logging.h\"\n\n#include \"muduo/net/TcpConnection.h\"\n\n#include \n\nusing muduo::string;\n\nclass MemcacheServer;\n\nclass Session : public std::enable_shared_from_this,\n muduo::noncopyable\n{\n public:\n Session(MemcacheServer* owner, const muduo::net::TcpConnectionPtr& conn)\n : owner_(owner),\n conn_(conn),\n state_(kNewCommand),\n protocol_(kAscii), // FIXME\n noreply_(false),\n policy_(Item::kInvalid),\n bytesToDiscard_(0),\n needle_(Item::makeItem(kLongestKey, 0, 0, 2, 0)),\n bytesRead_(0),\n requestsProcessed_(0)\n {\n using std::placeholders::_1;\n using std::placeholders::_2;\n using std::placeholders::_3;\n\n conn_->setMessageCallback(\n std::bind(&Session::onMessage, this, _1, _2, _3));\n }\n\n ~Session()\n {\n LOG_INFO << \"requests processed: \" << requestsProcessed_\n << \" input buffer size: \" << conn_->inputBuffer()->internalCapacity()\n << \" output buffer size: \" << conn_->outputBuffer()->internalCapacity();\n }\n\n private:\n enum State\n {\n kNewCommand,\n kReceiveValue,\n kDiscardValue,\n };\n\n enum Protocol\n {\n kAscii,\n kBinary,\n kAuto,\n };\n\n void onMessage(const muduo::net::TcpConnectionPtr& conn,\n muduo::net::Buffer* buf,\n muduo::Timestamp);\n void onWriteComplete(const muduo::net::TcpConnectionPtr& conn);\n void receiveValue(muduo::net::Buffer* buf);\n void discardValue(muduo::net::Buffer* buf);\n // TODO: highWaterMark\n // TODO: onWriteComplete\n\n // returns true if finished a request\n bool processRequest(muduo::StringPiece request);\n void resetRequest();\n void reply(muduo::StringPiece msg);\n\n struct SpaceSeparator\n {\n void reset() {}\n template \n bool operator()(InputIterator& next, InputIterator end, Token& tok);\n };\n\n typedef boost::tokenizer Tokenizer;\n struct Reader;\n bool doUpdate(Tokenizer::iterator& beg, Tokenizer::iterator end);\n void doDelete(Tokenizer::iterator& beg, Tokenizer::iterator end);\n\n MemcacheServer* owner_;\n muduo::net::TcpConnectionPtr conn_;\n State state_;\n Protocol protocol_;\n\n // current request\n string command_;\n bool noreply_;\n Item::UpdatePolicy policy_;\n ItemPtr currItem_;\n size_t bytesToDiscard_;\n // cached\n ItemPtr needle_;\n muduo::net::Buffer outputBuf_;\n\n // per session stats\n size_t bytesRead_;\n size_t requestsProcessed_;\n\n static string kLongestKey;\n};\n\ntypedef std::shared_ptr SessionPtr;\n\n#endif // MUDUO_EXAMPLES_MEMCACHED_SERVER_SESSION_H\n" }, { "path": "examples/memcached/server/footprint_test.cc", "content": "#include \"examples/memcached/server/MemcacheServer.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/inspect/ProcessInspector.h\"\n\n#include \n#ifdef HAVE_TCMALLOC\n#include \n#include \n#endif\n\nusing namespace muduo::net;\n\nint main(int argc, char* argv[])\n{\n#ifdef HAVE_TCMALLOC\n MallocExtension::Initialize();\n#endif\n int items = argc > 1 ? atoi(argv[1]) : 10000;\n int keylen = argc > 2 ? atoi(argv[2]) : 10;\n int valuelen = argc > 3 ? atoi(argv[3]) : 100;\n EventLoop loop;\n MemcacheServer::Options options;\n MemcacheServer server(&loop, options);\n\n printf(\"sizeof(Item) = %zd\\npid = %d\\nitems = %d\\nkeylen = %d\\nvaluelen = %d\\n\",\n sizeof(Item), getpid(), items, keylen, valuelen);\n char key[256] = { 0 };\n string value;\n for (int i = 0; i < items; ++i)\n {\n snprintf(key, sizeof key, \"%0*d\", keylen, i);\n value.assign(valuelen, \"0123456789\"[i % 10]);\n ItemPtr item(Item::makeItem(key, 0, 0, valuelen+2, 1));\n item->append(value.data(), value.size());\n item->append(\"\\r\\n\", 2);\n assert(item->endsWithCRLF());\n bool exists = false;\n bool stored = server.storeItem(item, Item::kAdd, &exists);\n assert(stored); (void) stored;\n assert(!exists);\n }\n Inspector::ArgList arg;\n printf(\"==========\\n%s\\n\",\n ProcessInspector::overview(HttpRequest::kGet, arg).c_str());\n // TODO: print bytes per item, overhead percent\n fflush(stdout);\n#ifdef HAVE_TCMALLOC\n char buf[8192];\n MallocExtension::instance()->GetStats(buf, sizeof buf);\n printf(\"%s\\n\", buf);\n HeapProfilerDump(\"end\");\n\n/*\n // only works for tcmalloc_debug\n int blocks = 0;\n size_t total = 0;\n int histogram[kMallocHistogramSize] = { 0, };\n MallocExtension::instance()->MallocMemoryStats(&blocks, &total, histogram);\n printf(\"==========\\nblocks = %d\\ntotal = %zd\\n\", blocks, total);\n for (int i = 0; i < kMallocHistogramSize; ++i)\n {\n printf(\"%d = %d\\n\", i, histogram[i]);\n }\n*/\n#endif\n}\n" }, { "path": "examples/memcached/server/server.cc", "content": "#include \"examples/memcached/server/MemcacheServer.h\"\n\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/EventLoopThread.h\"\n#include \"muduo/net/inspect/Inspector.h\"\n\n#include \n\nnamespace po = boost::program_options;\nusing namespace muduo::net;\n\nbool parseCommandLine(int argc, char* argv[], MemcacheServer::Options* options)\n{\n options->tcpport = 11211;\n options->gperfport = 11212;\n options->threads = 4;\n\n po::options_description desc(\"Allowed options\");\n desc.add_options()\n (\"help,h\", \"Help\")\n (\"port,p\", po::value(&options->tcpport), \"TCP port\")\n (\"udpport,U\", po::value(&options->udpport), \"UDP port\")\n (\"gperf,g\", po::value(&options->gperfport), \"port for gperftools\")\n (\"threads,t\", po::value(&options->threads), \"Number of worker threads\")\n ;\n\n po::variables_map vm;\n po::store(po::parse_command_line(argc, argv, desc), vm);\n po::notify(vm);\n\n if (vm.count(\"help\"))\n {\n //printf(\"memcached 1.1.0\\n\");\n return false;\n }\n return true;\n}\n\nint main(int argc, char* argv[])\n{\n EventLoop loop;\n EventLoopThread inspectThread;\n MemcacheServer::Options options;\n if (parseCommandLine(argc, argv, &options))\n {\n // FIXME: how to destruct it safely ?\n new Inspector(inspectThread.startLoop(), InetAddress(options.gperfport), \"memcached-debug\");\n\n MemcacheServer server(&loop, options);\n server.setThreadNum(options.threads);\n server.start();\n loop.loop();\n }\n}\n\n" }, { "path": "examples/multiplexer/CMakeLists.txt", "content": "add_executable(multiplex_server multiplexer.cc)\ntarget_link_libraries(multiplex_server muduo_net)\n\nadd_executable(multiplex_server_simple multiplexer_simple.cc)\ntarget_link_libraries(multiplex_server_simple muduo_net)\n\nadd_executable(multiplex_demux demux.cc)\ntarget_link_libraries(multiplex_demux muduo_net)\n\n" }, { "path": "examples/multiplexer/demux.cc", "content": "#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/InetAddress.h\"\n#include \"muduo/net/TcpClient.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\ntypedef std::shared_ptr TcpClientPtr;\n\n// const int kMaxConns = 1;\nconst size_t kMaxPacketLen = 255;\nconst size_t kHeaderLen = 3;\n\nconst uint16_t kListenPort = 9999;\nconst char* socksIp = \"127.0.0.1\";\nconst uint16_t kSocksPort = 7777;\n\nstruct Entry\n{\n int connId;\n TcpClientPtr client;\n TcpConnectionPtr connection;\n Buffer pending;\n};\n\nclass DemuxServer : noncopyable\n{\n public:\n DemuxServer(EventLoop* loop, const InetAddress& listenAddr, const InetAddress& socksAddr)\n : loop_(loop),\n server_(loop, listenAddr, \"DemuxServer\"),\n socksAddr_(socksAddr)\n {\n server_.setConnectionCallback(\n std::bind(&DemuxServer::onServerConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&DemuxServer::onServerMessage, this, _1, _2, _3));\n }\n\n void start()\n {\n server_.start();\n }\n\n void onServerConnection(const TcpConnectionPtr& conn)\n {\n if (conn->connected())\n {\n if (serverConn_)\n {\n conn->shutdown();\n }\n else\n {\n serverConn_ = conn;\n LOG_INFO << \"onServerConnection set serverConn_\";\n }\n }\n else\n {\n if (serverConn_ == conn)\n {\n serverConn_.reset();\n socksConns_.clear();\n\n LOG_INFO << \"onServerConnection reset serverConn_\";\n }\n }\n }\n\n void onServerMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)\n {\n while (buf->readableBytes() > kHeaderLen)\n {\n int len = static_cast(*buf->peek());\n if (buf->readableBytes() < len + kHeaderLen)\n {\n break;\n }\n else\n {\n int connId = static_cast(buf->peek()[1]);\n connId |= (static_cast(buf->peek()[2]) << 8);\n\n if (connId != 0)\n {\n assert(socksConns_.find(connId) != socksConns_.end());\n TcpConnectionPtr& socksConn = socksConns_[connId].connection;\n if (socksConn)\n {\n assert(socksConns_[connId].pending.readableBytes() == 0);\n socksConn->send(buf->peek() + kHeaderLen, len);\n }\n else\n {\n socksConns_[connId].pending.append(buf->peek() + kHeaderLen, len);\n }\n }\n else\n {\n string cmd(buf->peek() + kHeaderLen, len);\n doCommand(cmd);\n }\n buf->retrieve(len + kHeaderLen);\n }\n }\n }\n\n void doCommand(const string& cmd)\n {\n static const string kConn = \"CONN \";\n\n int connId = atoi(&cmd[kConn.size()]);\n bool isUp = cmd.find(\" IS UP\") != string::npos;\n LOG_INFO << \"doCommand \" << connId << \" \" << isUp;\n if (isUp)\n {\n assert(socksConns_.find(connId) == socksConns_.end());\n char connName[256];\n snprintf(connName, sizeof connName, \"SocksClient %d\", connId);\n Entry entry;\n entry.connId = connId;\n entry.client.reset(new TcpClient(loop_, socksAddr_, connName));\n entry.client->setConnectionCallback(\n std::bind(&DemuxServer::onSocksConnection, this, connId, _1));\n entry.client->setMessageCallback(\n std::bind(&DemuxServer::onSocksMessage, this, connId, _1, _2, _3));\n // FIXME: setWriteCompleteCallback\n socksConns_[connId] = entry;\n entry.client->connect();\n }\n else\n {\n assert(socksConns_.find(connId) != socksConns_.end());\n TcpConnectionPtr& socksConn = socksConns_[connId].connection;\n if (socksConn)\n {\n socksConn->shutdown();\n }\n else\n {\n socksConns_.erase(connId);\n }\n }\n }\n\n void onSocksConnection(int connId, const TcpConnectionPtr& conn)\n {\n assert(socksConns_.find(connId) != socksConns_.end());\n if (conn->connected())\n {\n socksConns_[connId].connection = conn;\n Buffer& pendingData = socksConns_[connId].pending;\n if (pendingData.readableBytes() > 0)\n {\n conn->send(&pendingData);\n }\n }\n else\n {\n if (serverConn_)\n {\n char buf[256];\n int len = snprintf(buf, sizeof(buf), \"DISCONNECT %d\\r\\n\", connId);\n Buffer buffer;\n buffer.append(buf, len);\n sendServerPacket(0, &buffer);\n }\n else\n {\n socksConns_.erase(connId);\n }\n }\n }\n\n void onSocksMessage(int connId, const TcpConnectionPtr& conn, Buffer* buf, Timestamp)\n {\n assert(socksConns_.find(connId) != socksConns_.end());\n while (buf->readableBytes() > kMaxPacketLen)\n {\n Buffer packet;\n packet.append(buf->peek(), kMaxPacketLen);\n buf->retrieve(kMaxPacketLen);\n sendServerPacket(connId, &packet);\n }\n if (buf->readableBytes() > 0)\n {\n sendServerPacket(connId, buf);\n }\n }\n\n void sendServerPacket(int connId, Buffer* buf)\n {\n size_t len = buf->readableBytes();\n LOG_DEBUG << len;\n assert(len <= kMaxPacketLen);\n uint8_t header[kHeaderLen] = {\n static_cast(len),\n static_cast(connId & 0xFF),\n static_cast((connId & 0xFF00) >> 8)\n };\n buf->prepend(header, kHeaderLen);\n if (serverConn_)\n {\n serverConn_->send(buf);\n }\n }\n\n EventLoop* loop_;\n TcpServer server_;\n TcpConnectionPtr serverConn_;\n const InetAddress socksAddr_;\n std::map socksConns_;\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n EventLoop loop;\n InetAddress listenAddr(kListenPort);\n if (argc > 1)\n {\n socksIp = argv[1];\n }\n InetAddress socksAddr(socksIp, kSocksPort);\n DemuxServer server(&loop, listenAddr, socksAddr);\n\n server.start();\n\n loop.loop();\n}\n\n" }, { "path": "examples/multiplexer/harness/run.sh", "content": "#!/bin/sh\n\nCLASSPATH=lib/netty-3.2.4.Final.jar:lib/slf4j-api-1.6.1.jar:lib/slf4j-simple-1.6.1.jar:./bin\n\nexport CLASSPATH\nmkdir -p bin\njavac -d bin ./src/com/chenshuo/muduo/example/multiplexer/*.java ./src/com/chenshuo/muduo/example/multiplexer/testcase/*.java\njava -ea -Djava.net.preferIPv4Stack=true com.chenshuo.muduo.example.multiplexer.MultiplexerTest localhost\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/DataEvent.java", "content": "package com.chenshuo.muduo.example.multiplexer;\n\nimport java.nio.charset.Charset;\n\nimport org.jboss.netty.buffer.ChannelBuffer;\n\npublic class DataEvent extends Event {\n\n public final EventSource source;\n public final int whichClient;\n public final ChannelBuffer data;\n\n public DataEvent(EventSource source, int whichClient, ChannelBuffer data) {\n this.source = source;\n this.whichClient = whichClient;\n this.data = data;\n }\n\n public String getString() {\n return data.toString(Charset.defaultCharset());\n }\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/Event.java", "content": "package com.chenshuo.muduo.example.multiplexer;\n\npublic class Event {\n\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/EventQueue.java", "content": "package com.chenshuo.muduo.example.multiplexer;\n\nimport java.util.concurrent.BlockingDeque;\nimport java.util.concurrent.LinkedBlockingDeque;\nimport java.util.concurrent.TimeUnit;\n\npublic class EventQueue {\n private BlockingDeque queue = new LinkedBlockingDeque();\n \n public void put(Event e) {\n queue.add(e);\n }\n \n public Event take() {\n try {\n return queue.poll(5, TimeUnit.SECONDS);\n } catch (InterruptedException e) {\n return null;\n }\n }\n \n public boolean isEmpty() {\n return queue.isEmpty();\n }\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/EventSource.java", "content": "package com.chenshuo.muduo.example.multiplexer;\n\npublic enum EventSource {\n kBackend, kClient\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/MockBackendServer.java", "content": "package com.chenshuo.muduo.example.multiplexer;\n\nimport static org.jboss.netty.buffer.ChannelBuffers.wrappedBuffer;\n\nimport java.net.InetSocketAddress;\nimport java.nio.charset.Charset;\nimport java.util.concurrent.CountDownLatch;\nimport java.util.concurrent.Executor;\n\nimport org.jboss.netty.bootstrap.ServerBootstrap;\nimport org.jboss.netty.buffer.ChannelBuffer;\nimport org.jboss.netty.channel.Channel;\nimport org.jboss.netty.channel.ChannelFactory;\nimport org.jboss.netty.channel.ChannelHandlerContext;\nimport org.jboss.netty.channel.ChannelPipeline;\nimport org.jboss.netty.channel.ChannelPipelineFactory;\nimport org.jboss.netty.channel.ChannelStateEvent;\nimport org.jboss.netty.channel.Channels;\nimport org.jboss.netty.channel.ExceptionEvent;\nimport org.jboss.netty.channel.MessageEvent;\nimport org.jboss.netty.channel.SimpleChannelHandler;\nimport org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;\nimport org.jboss.netty.handler.codec.frame.LengthFieldBasedFrameDecoder;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\npublic class MockBackendServer {\n private static final Logger logger = LoggerFactory.getLogger(\"MockBackendServer\");\n\n private class Handler extends SimpleChannelHandler {\n\n @Override\n public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)\n throws Exception {\n logger.debug(\"channelConnected {},, {}\", ctx, e);\n assert connection == null;\n connection = e.getChannel();\n latch.countDown();\n }\n\n @Override\n public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e)\n throws Exception {\n logger.debug(\"channelDisconnected {},, {}\", ctx, e);\n assert connection == e.getChannel();\n connection = null;\n }\n\n @Override\n public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)\n throws Exception {\n logger.debug(\"messageReceived {},, {}\", ctx, e);\n assert connection == e.getChannel();\n ChannelBuffer input = (ChannelBuffer) e.getMessage();\n int len = input.readUnsignedByte();\n int whichClient = input.readUnsignedShort();\n assert len == input.readableBytes();\n logger.debug(\"From {}, '{}'\", whichClient, input.toString(Charset.defaultCharset()));\n queue.put(new DataEvent(EventSource.kBackend, whichClient, input));\n }\n\n @Override\n public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)\n throws Exception {\n logger.error(\"exceptionCaught {},, {}\", ctx, e);\n }\n }\n\n private final EventQueue queue;\n private final int port;\n private final Executor boss;\n private final Executor worker;\n private final CountDownLatch latch;\n private Channel listener;\n private volatile Channel connection;\n\n public MockBackendServer(EventQueue queue, int listeningPort, Executor boss, Executor worker,\n CountDownLatch latch) {\n this.queue = queue;\n port = listeningPort;\n this.boss = boss;\n this.worker = worker;\n this.latch = latch;\n }\n\n public void start() {\n ServerBootstrap bootstrap = getBootstrap();\n listener = bootstrap.bind(new InetSocketAddress(port));\n logger.debug(\"started\");\n }\n\n public void sendToClient(int whichClient, ChannelBuffer data) {\n ChannelBuffer output = data.factory().getBuffer(3);\n output.writeByte(data.readableBytes());\n output.writeShort(whichClient);\n connection.write(wrappedBuffer(output, data));\n }\n\n public ChannelBuffer sendToClient(int whichClient, String str) {\n byte[] bytes = str.getBytes();\n ChannelBuffer data = MultiplexerTest.bufferFactory.getBuffer(bytes, 0, bytes.length);\n sendToClient(whichClient, data);\n return data;\n }\n\n public void stop() {\n listener.close();\n }\n\n private ServerBootstrap getBootstrap() {\n ChannelFactory factory = new NioServerSocketChannelFactory(boss, worker);\n ServerBootstrap bootstrap = new ServerBootstrap(factory);\n bootstrap.setPipelineFactory(new ChannelPipelineFactory() {\n @Override\n public ChannelPipeline getPipeline() throws Exception {\n return Channels.pipeline(\n new LengthFieldBasedFrameDecoder(255 + 3, 0, 1, 2, 0),\n new Handler());\n }\n });\n bootstrap.setOption(\"reuseAddress\", true);\n bootstrap.setOption(\"child.tcpNoDelay\", true);\n bootstrap.setOption(\"child.bufferFactory\", MultiplexerTest.bufferFactory);\n return bootstrap;\n }\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/MockClient.java", "content": "package com.chenshuo.muduo.example.multiplexer;\n\nimport java.net.InetSocketAddress;\nimport java.util.concurrent.Executor;\nimport java.util.concurrent.TimeUnit;\n\nimport org.jboss.netty.bootstrap.ClientBootstrap;\nimport org.jboss.netty.buffer.ChannelBuffer;\nimport org.jboss.netty.channel.Channel;\nimport org.jboss.netty.channel.ChannelFactory;\nimport org.jboss.netty.channel.ChannelFuture;\nimport org.jboss.netty.channel.ChannelHandlerContext;\nimport org.jboss.netty.channel.ChannelPipeline;\nimport org.jboss.netty.channel.ChannelPipelineFactory;\nimport org.jboss.netty.channel.ChannelStateEvent;\nimport org.jboss.netty.channel.Channels;\nimport org.jboss.netty.channel.ExceptionEvent;\nimport org.jboss.netty.channel.MessageEvent;\nimport org.jboss.netty.channel.SimpleChannelHandler;\nimport org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;\nimport org.jboss.netty.util.HashedWheelTimer;\nimport org.jboss.netty.util.Timeout;\nimport org.jboss.netty.util.Timer;\nimport org.jboss.netty.util.TimerTask;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\npublic class MockClient {\n private static final Logger logger = LoggerFactory.getLogger(\"MockClient\");\n\n private class Handler extends SimpleChannelHandler {\n\n @Override\n public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)\n throws Exception {\n logger.debug(\"channelConnected {},, {}\", ctx, e);\n assert connection == null;\n connection = e.getChannel();\n if (latch != null)\n latch.countDown();\n }\n\n @Override\n public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e)\n throws Exception {\n logger.debug(\"channelDisconnected {},, {}\", ctx, e);\n assert connection == e.getChannel();\n connection = null;\n }\n\n @Override\n public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)\n throws Exception {\n logger.debug(\"messageReceived {},, {}\", ctx, e);\n assert connection == e.getChannel();\n queue.put(new DataEvent(EventSource.kClient, connId, (ChannelBuffer) e.getMessage()));\n }\n\n @Override\n public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)\n throws Exception {\n logger.error(\"exceptionCaught {},, {}\", ctx, e);\n // reconnect();\n }\n\n @SuppressWarnings(\"unused\")\n private void reconnect() {\n timer.newTimeout(new TimerTask() {\n @Override\n public void run(Timeout timeout) throws Exception {\n logger.info(\"Reconnecting\");\n bootstrap.connect();\n\n }\n }, 5, TimeUnit.SECONDS);\n }\n }\n\n private final EventQueue queue;\n private final InetSocketAddress remoteAddress;\n private final Executor boss;\n private final Executor worker;\n private final Timer timer;\n private volatile Channel connection;\n private ClientBootstrap bootstrap;\n private int connId;\n private MyCountDownLatch latch;\n\n public MockClient(EventQueue queue, InetSocketAddress remoteAddress, Executor boss,\n Executor worker) {\n this.queue = queue;\n this.remoteAddress = remoteAddress;\n this.boss = boss;\n this.worker = worker;\n this.timer = new HashedWheelTimer();\n connId = -1;\n }\n\n public ChannelFuture connect() {\n assert bootstrap == null;\n\n ChannelFactory factory = new NioClientSocketChannelFactory(boss, worker);\n bootstrap = new ClientBootstrap(factory);\n\n bootstrap.setPipelineFactory(new ChannelPipelineFactory() {\n public ChannelPipeline getPipeline() {\n return Channels.pipeline(new Handler());\n }\n });\n\n bootstrap.setOption(\"tcpNoDelay\", true);\n bootstrap.setOption(\"remoteAddress\", remoteAddress);\n\n return bootstrap.connect();\n }\n\n public void connectAndWait() {\n latch = new MyCountDownLatch(1);\n connect();\n latch.awaitUninterruptibly(500);\n assert connection != null;\n }\n\n public void send(ChannelBuffer buf) {\n connection.write(buf);\n }\n \n public ChannelBuffer send(String str) {\n byte[] bytes = str.getBytes();\n ChannelBuffer buf = MultiplexerTest.bufferFactory.getBuffer(bytes, 0, bytes.length);\n connection.write(buf);\n return buf;\n }\n \n public void disconnect() {\n connection.close();\n }\n\n public void setId(int connId) {\n assert this.connId == -1;\n this.connId = connId;\n }\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/MultiplexerTest.java", "content": "package com.chenshuo.muduo.example.multiplexer;\n\nimport java.net.InetSocketAddress;\nimport java.nio.ByteOrder;\nimport java.util.ArrayList;\nimport java.util.concurrent.ExecutorService;\nimport java.util.concurrent.Executors;\nimport java.util.regex.Pattern;\n\nimport org.jboss.netty.buffer.ChannelBufferFactory;\nimport org.jboss.netty.buffer.HeapChannelBufferFactory;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\nimport com.chenshuo.muduo.example.multiplexer.testcase.TestOneClientBothSend;\nimport com.chenshuo.muduo.example.multiplexer.testcase.TestOneClientNoData;\nimport com.chenshuo.muduo.example.multiplexer.testcase.TestOneClientSend;\nimport com.chenshuo.muduo.example.multiplexer.testcase.TestOneClientBackendSend;\nimport com.chenshuo.muduo.example.multiplexer.testcase.TestTwoClients;\n\npublic class MultiplexerTest {\n private static final Logger logger = LoggerFactory.getLogger(\"MultiplexerTest\");\n public static final ChannelBufferFactory bufferFactory =\n HeapChannelBufferFactory.getInstance(ByteOrder.LITTLE_ENDIAN);\n \n public final Pattern commandChannel = Pattern.compile(\"CONN (\\\\d+) FROM [0-9.:]+ IS ([A-Z]+)\\r\\n\");\n \n private static final int kMultiplexerServerPort = 3333;\n private static final int kLogicalServerPort = 9999;\n private final InetSocketAddress multiplexerAddress;\n private final ExecutorService boss;\n private final ExecutorService worker;\n private EventQueue queue;\n private MyCountDownLatch latch;\n private MockBackendServer backend;\n private ArrayList testCases;\n\n public MultiplexerTest(String multiplexerHost) {\n multiplexerAddress = new InetSocketAddress(multiplexerHost, kMultiplexerServerPort);\n boss = Executors.newCachedThreadPool();\n worker = Executors.newCachedThreadPool();\n queue = new EventQueue();\n latch = new MyCountDownLatch(1);\n backend = new MockBackendServer(queue, kLogicalServerPort, boss, worker, latch);\n testCases = new ArrayList();\n }\n\n public static void main(String[] args) {\n if (args.length >= 1) {\n String multiplexerHost = args[0];\n MultiplexerTest test = new MultiplexerTest(multiplexerHost);\n test.addTestCase(new TestOneClientNoData());\n test.addTestCase(new TestOneClientSend());\n test.addTestCase(new TestOneClientBackendSend());\n test.addTestCase(new TestOneClientBothSend());\n test.addTestCase(new TestTwoClients());\n test.run();\n } else {\n System.out.println(\"Usage: ./run.sh path_to_test_data multiplexer_host\");\n System.out.println(\"Example: ./run.sh localhost\");\n }\n }\n\n private void addTestCase(TestCase testCase) {\n testCases.add(testCase);\n testCase.setOwner(this);\n }\n\n private void run() {\n logger.info(\"Waiting for connection\");\n backend.start();\n latch.awaitUninterruptibly();\n\n logger.info(\"Ready\");\n for (TestCase testCase : testCases) {\n testCase.test();\n }\n System.out.flush();\n sleep(500);\n logger.info(\"Finished\");\n System.exit(0);\n }\n\n public MockClient newClient() {\n MockClient client = new MockClient(queue, multiplexerAddress, boss, worker);\n client.connectAndWait();\n return client;\n }\n\n public EventQueue getEventQueue() {\n return queue;\n }\n \n public MockBackendServer getBackend() {\n return backend;\n }\n\n public void sleep(int millis) {\n try {\n Thread.sleep(millis);\n } catch (InterruptedException e) {\n }\n }\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/MyCountDownLatch.java", "content": "package com.chenshuo.muduo.example.multiplexer;\n\nimport java.util.concurrent.CountDownLatch;\nimport java.util.concurrent.TimeUnit;\n\npublic class MyCountDownLatch extends CountDownLatch {\n\n public MyCountDownLatch(int count) {\n super(count);\n }\n\n public void awaitUninterruptibly() {\n try {\n await();\n } catch (InterruptedException e) {\n }\n }\n\n public void awaitUninterruptibly(int millis) {\n try {\n await(millis, TimeUnit.MILLISECONDS);\n } catch (InterruptedException e) {\n }\n }\n\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/TestCase.java", "content": "package com.chenshuo.muduo.example.multiplexer;\n\nimport org.jboss.netty.buffer.ChannelBufferFactory;\n\npublic abstract class TestCase {\n protected static final ChannelBufferFactory bufferFactory = MultiplexerTest.bufferFactory;\n\n protected MultiplexerTest god;\n protected EventQueue queue;\n protected MockBackendServer backend;\n\n public void setOwner(MultiplexerTest god) {\n this.god = god;\n queue = god.getEventQueue();\n backend = god.getBackend();\n }\n\n public void test() {\n try {\n run();\n } catch (TestFailedException e) {\n System.out.printf(\"%s FAILED: %s\\n\", this.getClass().getSimpleName(), e.getMessage());\n e.printStackTrace();\n return;\n } catch (Exception e) {\n System.out.printf(\"%s FATAL: %s\\n\", this.getClass().getSimpleName(), e.toString());\n e.printStackTrace();\n return;\n }\n System.out.printf(\"%s PASS\\n\", this.getClass().getSimpleName());\n }\n\n protected void assertEquals(Object expected, Object actual) {\n if (!expected.equals(actual))\n fail(\"assertEquals failed\");\n }\n\n protected void assertTrue(boolean yes) {\n if (!yes)\n fail(\"assertTrue failed\");\n }\n\n protected void fail(String message) {\n throw new TestFailedException(message);\n }\n\n public abstract void run();\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/TestFailedException.java", "content": "package com.chenshuo.muduo.example.multiplexer;\n\npublic class TestFailedException extends RuntimeException {\n private static final long serialVersionUID = 1982L;\n\n public TestFailedException(String message) {\n super(message);\n }\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/testcase/TestOneClientBackendSend.java", "content": "package com.chenshuo.muduo.example.multiplexer.testcase;\n\nimport java.nio.charset.Charset;\nimport java.util.regex.Matcher;\n\nimport org.jboss.netty.buffer.ChannelBuffer;\n\nimport com.chenshuo.muduo.example.multiplexer.DataEvent;\nimport com.chenshuo.muduo.example.multiplexer.Event;\nimport com.chenshuo.muduo.example.multiplexer.EventSource;\nimport com.chenshuo.muduo.example.multiplexer.MockClient;\nimport com.chenshuo.muduo.example.multiplexer.TestCase;\n\npublic class TestOneClientBackendSend extends TestCase {\n\n @Override\n public void run() {\n if (!queue.isEmpty())\n fail(\"EventQueue is not empty\");\n\n // step 1\n MockClient client = god.newClient();\n Event ev = queue.take();\n DataEvent de = (DataEvent) ev;\n assertEquals(EventSource.kBackend, de.source);\n\n Matcher m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n\n final int connId = Integer.parseInt(m.group(1));\n assertTrue(connId > 0);\n client.setId(connId);\n\n assertEquals(\"UP\", m.group(2));\n\n // step 2\n ChannelBuffer buf = backend.sendToClient(connId, \"hello\");\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kClient, de.source);\n assertEquals(connId, de.whichClient);\n assertEquals(buf, de.data);\n System.out.println(de.data.toString(Charset.defaultCharset()));\n\n // step 3\n buf = backend.sendToClient(connId, \"World!\");\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kClient, de.source);\n assertEquals(connId, de.whichClient);\n assertEquals(buf, de.data);\n System.out.println(de.data.toString(Charset.defaultCharset()));\n\n StringBuilder sb = new StringBuilder();\n for (int i = 0; i < 255; ++i)\n sb.append('H');\n\n buf = backend.sendToClient(connId, sb.toString());\n\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kClient, de.source);\n assertEquals(connId, de.whichClient);\n assertEquals(buf, de.data);\n\n // step 4\n client.disconnect();\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n\n assertEquals(connId, Integer.parseInt(m.group(1)));\n assertEquals(\"DOWN\", m.group(2));\n }\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/testcase/TestOneClientBothSend.java", "content": "package com.chenshuo.muduo.example.multiplexer.testcase;\n\nimport java.nio.charset.Charset;\nimport java.util.regex.Matcher;\n\nimport org.jboss.netty.buffer.ChannelBuffer;\n\nimport com.chenshuo.muduo.example.multiplexer.DataEvent;\nimport com.chenshuo.muduo.example.multiplexer.Event;\nimport com.chenshuo.muduo.example.multiplexer.EventSource;\nimport com.chenshuo.muduo.example.multiplexer.MockClient;\nimport com.chenshuo.muduo.example.multiplexer.TestCase;\n\npublic class TestOneClientBothSend extends TestCase {\n\n @Override\n public void run() {\n if (!queue.isEmpty())\n fail(\"EventQueue is not empty\");\n\n // step 1\n MockClient client = god.newClient();\n Event ev = queue.take();\n DataEvent de = (DataEvent) ev;\n assertEquals(EventSource.kBackend, de.source);\n\n Matcher m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n\n final int connId = Integer.parseInt(m.group(1));\n assertTrue(connId > 0);\n client.setId(connId);\n\n assertEquals(\"UP\", m.group(2));\n\n // step 2\n ChannelBuffer buf = client.send(\"hello\");\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n assertEquals(connId, de.whichClient);\n assertEquals(buf, de.data);\n System.out.println(de.data.toString(Charset.defaultCharset()));\n\n // step 3\n buf = backend.sendToClient(connId, \"World!\");\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kClient, de.source);\n assertEquals(connId, de.whichClient);\n assertEquals(buf, de.data);\n System.out.println(de.data.toString(Charset.defaultCharset()));\n\n // step 4\n client.disconnect();\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n\n assertEquals(connId, Integer.parseInt(m.group(1)));\n assertEquals(\"DOWN\", m.group(2));\n }\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/testcase/TestOneClientNoData.java", "content": "package com.chenshuo.muduo.example.multiplexer.testcase;\n\nimport java.util.regex.Matcher;\n\nimport com.chenshuo.muduo.example.multiplexer.DataEvent;\nimport com.chenshuo.muduo.example.multiplexer.Event;\nimport com.chenshuo.muduo.example.multiplexer.EventSource;\nimport com.chenshuo.muduo.example.multiplexer.MockClient;\nimport com.chenshuo.muduo.example.multiplexer.TestCase;\n\npublic class TestOneClientNoData extends TestCase {\n\n @Override\n public void run() {\n if (!queue.isEmpty())\n fail(\"EventQueue is not empty\");\n \n MockClient client = god.newClient();\n Event ev = queue.take();\n DataEvent de = (DataEvent) ev;\n assertEquals(EventSource.kBackend, de.source);\n\n Matcher m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n \n int connId = Integer.parseInt(m.group(1));\n assertTrue(connId > 0);\n client.setId(connId);\n \n assertEquals(\"UP\", m.group(2));\n \n client.disconnect();\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n \n assertEquals(connId, Integer.parseInt(m.group(1)));\n assertEquals(\"DOWN\", m.group(2));\n }\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/testcase/TestOneClientSend.java", "content": "package com.chenshuo.muduo.example.multiplexer.testcase;\n\nimport java.nio.charset.Charset;\nimport java.util.regex.Matcher;\n\nimport org.jboss.netty.buffer.ChannelBuffer;\n\nimport com.chenshuo.muduo.example.multiplexer.DataEvent;\nimport com.chenshuo.muduo.example.multiplexer.Event;\nimport com.chenshuo.muduo.example.multiplexer.EventSource;\nimport com.chenshuo.muduo.example.multiplexer.MockClient;\nimport com.chenshuo.muduo.example.multiplexer.TestCase;\n\npublic class TestOneClientSend extends TestCase {\n\n @Override\n public void run() {\n if (!queue.isEmpty())\n fail(\"EventQueue is not empty\");\n\n // step 1\n MockClient client = god.newClient();\n Event ev = queue.take();\n DataEvent de = (DataEvent) ev;\n assertEquals(EventSource.kBackend, de.source);\n\n Matcher m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n\n final int connId = Integer.parseInt(m.group(1));\n assertTrue(connId > 0);\n client.setId(connId);\n\n assertEquals(\"UP\", m.group(2));\n\n // step 2\n ChannelBuffer buf = client.send(\"hello\");\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n assertEquals(connId, de.whichClient);\n assertEquals(buf, de.data);\n System.out.println(de.data.toString(Charset.defaultCharset()));\n\n // step 3\n buf = client.send(\"World!\");\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n assertEquals(connId, de.whichClient);\n assertEquals(buf, de.data);\n System.out.println(de.data.toString(Charset.defaultCharset()));\n\n StringBuilder sb = new StringBuilder();\n for (int i = 0; i < 500; ++i)\n sb.append('H');\n\n buf = client.send(sb.toString());\n\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n assertEquals(connId, de.whichClient);\n assertEquals(buf.copy(0, 255), de.data);\n\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n assertEquals(connId, de.whichClient);\n assertEquals(buf.copy(255, 245), de.data);\n\n // step 4\n client.disconnect();\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n\n assertEquals(connId, Integer.parseInt(m.group(1)));\n assertEquals(\"DOWN\", m.group(2));\n }\n}\n" }, { "path": "examples/multiplexer/harness/src/com/chenshuo/muduo/example/multiplexer/testcase/TestTwoClients.java", "content": "package com.chenshuo.muduo.example.multiplexer.testcase;\n\nimport java.nio.charset.Charset;\nimport java.util.regex.Matcher;\n\nimport org.jboss.netty.buffer.ChannelBuffer;\n\nimport com.chenshuo.muduo.example.multiplexer.DataEvent;\nimport com.chenshuo.muduo.example.multiplexer.Event;\nimport com.chenshuo.muduo.example.multiplexer.EventSource;\nimport com.chenshuo.muduo.example.multiplexer.MockClient;\nimport com.chenshuo.muduo.example.multiplexer.TestCase;\n\npublic class TestTwoClients extends TestCase {\n\n @Override\n public void run() {\n if (!queue.isEmpty())\n fail(\"EventQueue is not empty\");\n\n // step 1\n final MockClient client1 = god.newClient();\n Event ev = queue.take();\n DataEvent de = (DataEvent) ev;\n assertEquals(EventSource.kBackend, de.source);\n\n Matcher m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n\n final int connId1 = Integer.parseInt(m.group(1));\n assertTrue(connId1 > 0);\n client1.setId(connId1);\n assertEquals(\"UP\", m.group(2));\n\n // step 2\n final MockClient client2 = god.newClient();\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n\n m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n\n final int connId2 = Integer.parseInt(m.group(1));\n assertTrue(connId2 > 0);\n client2.setId(connId2);\n assertEquals(\"UP\", m.group(2));\n\n ChannelBuffer buf = client1.send(\"hello\");\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n assertEquals(connId1, de.whichClient);\n assertEquals(buf, de.data);\n System.out.println(de.data.toString(Charset.defaultCharset()));\n\n // step 3\n buf = backend.sendToClient(connId2, \"World!\");\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kClient, de.source);\n assertEquals(connId2, de.whichClient);\n assertEquals(buf, de.data);\n System.out.println(de.data.toString(Charset.defaultCharset()));\n\n // step 4\n client1.disconnect();\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n assertEquals(connId1, Integer.parseInt(m.group(1)));\n assertEquals(\"DOWN\", m.group(2));\n\n client2.disconnect();\n de = (DataEvent) queue.take();\n assertEquals(EventSource.kBackend, de.source);\n m = god.commandChannel.matcher(de.getString());\n if (!m.matches())\n fail(\"command channel message doesn't match.\");\n assertEquals(connId2, Integer.parseInt(m.group(1)));\n assertEquals(\"DOWN\", m.group(2));\n\n }\n}\n" }, { "path": "examples/multiplexer/multiplexer.cc", "content": "#include \"muduo/base/Atomic.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Mutex.h\"\n#include \"muduo/base/Thread.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/InetAddress.h\"\n#include \"muduo/net/TcpClient.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nconst int kMaxConns = 10; // 65535\nconst size_t kMaxPacketLen = 255;\nconst size_t kHeaderLen = 3;\n\nconst uint16_t kClientPort = 3333;\nconst char* backendIp = \"127.0.0.1\";\nconst uint16_t kBackendPort = 9999;\n\nclass MultiplexServer\n{\n public:\n MultiplexServer(EventLoop* loop,\n const InetAddress& listenAddr,\n const InetAddress& backendAddr,\n int numThreads)\n : server_(loop, listenAddr, \"MultiplexServer\"),\n backend_(loop, backendAddr, \"MultiplexBackend\"),\n numThreads_(numThreads),\n oldCounter_(0),\n startTime_(Timestamp::now())\n {\n server_.setConnectionCallback(\n std::bind(&MultiplexServer::onClientConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&MultiplexServer::onClientMessage, this, _1, _2, _3));\n server_.setThreadNum(numThreads);\n\n backend_.setConnectionCallback(\n std::bind(&MultiplexServer::onBackendConnection, this, _1));\n backend_.setMessageCallback(\n std::bind(&MultiplexServer::onBackendMessage, this, _1, _2, _3));\n backend_.enableRetry();\n\n // loop->runEvery(10.0, std::bind(&MultiplexServer::printStatistics, this));\n\n }\n\n void start()\n {\n LOG_INFO << \"starting \" << numThreads_ << \" threads.\";\n backend_.connect();\n server_.start();\n }\n\n private:\n void sendBackendPacket(int id, Buffer* buf)\n {\n size_t len = buf->readableBytes();\n assert(len <= kMaxPacketLen);\n uint8_t header[kHeaderLen] = {\n static_cast(len),\n static_cast(id & 0xFF),\n static_cast((id & 0xFF00) >> 8)\n };\n buf->prepend(header, kHeaderLen);\n TcpConnectionPtr backendConn;\n {\n MutexLockGuard lock(mutex_);\n backendConn = backendConn_;\n }\n if (backendConn)\n {\n backendConn->send(buf);\n }\n }\n\n void sendBackendString(int id, const string& msg)\n {\n assert(msg.size() <= kMaxPacketLen);\n Buffer buf;\n buf.append(msg);\n sendBackendPacket(id, &buf);\n }\n\n void sendBackendBuffer(int id, Buffer* buf)\n {\n while (buf->readableBytes() > kMaxPacketLen)\n {\n Buffer packet;\n packet.append(buf->peek(), kMaxPacketLen);\n buf->retrieve(kMaxPacketLen);\n sendBackendPacket(id, &packet);\n }\n if (buf->readableBytes() > 0)\n {\n sendBackendPacket(id, buf);\n }\n }\n\n void sendToClient(Buffer* buf)\n {\n while (buf->readableBytes() > kHeaderLen)\n {\n int len = static_cast(*buf->peek());\n if (buf->readableBytes() < len + kHeaderLen)\n {\n break;\n }\n else\n {\n int id = static_cast(buf->peek()[1]);\n id |= (static_cast(buf->peek()[2]) << 8);\n\n TcpConnectionPtr clientConn;\n {\n MutexLockGuard lock(mutex_);\n std::map::iterator it = clientConns_.find(id);\n if (it != clientConns_.end())\n {\n clientConn = it->second;\n }\n }\n if (clientConn)\n {\n clientConn->send(buf->peek() + kHeaderLen, len);\n }\n buf->retrieve(len + kHeaderLen);\n }\n }\n }\n\n void onClientConnection(const TcpConnectionPtr& conn)\n {\n LOG_TRACE << \"Client \" << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n if (conn->connected())\n {\n int id = -1;\n {\n MutexLockGuard lock(mutex_);\n if (!availIds_.empty())\n {\n id = availIds_.front();\n availIds_.pop();\n clientConns_[id] = conn;\n }\n }\n\n if (id <= 0)\n {\n conn->shutdown();\n }\n else\n {\n conn->setContext(id);\n char buf[256];\n snprintf(buf, sizeof(buf), \"CONN %d FROM %s IS UP\\r\\n\", id,\n conn->peerAddress().toIpPort().c_str());\n sendBackendString(0, buf);\n }\n }\n else\n {\n if (!conn->getContext().empty())\n {\n int id = boost::any_cast(conn->getContext());\n assert(id > 0 && id <= kMaxConns);\n char buf[256];\n snprintf(buf, sizeof(buf), \"CONN %d FROM %s IS DOWN\\r\\n\",\n id, conn->peerAddress().toIpPort().c_str());\n sendBackendString(0, buf);\n\n MutexLockGuard lock(mutex_);\n if (backendConn_)\n {\n availIds_.push(id);\n clientConns_.erase(id);\n }\n else\n {\n assert(availIds_.empty());\n assert(clientConns_.empty());\n }\n }\n }\n }\n\n void onClientMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)\n {\n size_t len = buf->readableBytes();\n transferred_.addAndGet(len);\n receivedMessages_.incrementAndGet();\n if (!conn->getContext().empty())\n {\n int id = boost::any_cast(conn->getContext());\n sendBackendBuffer(id, buf);\n // assert(buf->readableBytes() == 0);\n }\n else\n {\n buf->retrieveAll();\n // FIXME: error handling\n }\n }\n\n void onBackendConnection(const TcpConnectionPtr& conn)\n {\n LOG_TRACE << \"Backend \" << conn->localAddress().toIpPort() << \" -> \"\n << conn->peerAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n std::vector connsToDestroy;\n if (conn->connected())\n {\n MutexLockGuard lock(mutex_);\n backendConn_ = conn;\n assert(availIds_.empty());\n for (int i = 1; i <= kMaxConns; ++i)\n {\n availIds_.push(i);\n }\n }\n else\n {\n MutexLockGuard lock(mutex_);\n backendConn_.reset();\n connsToDestroy.reserve(clientConns_.size());\n for (std::map::iterator it = clientConns_.begin();\n it != clientConns_.end();\n ++it)\n {\n connsToDestroy.push_back(it->second);\n }\n clientConns_.clear();\n while (!availIds_.empty())\n {\n availIds_.pop();\n }\n }\n\n for (std::vector::iterator it = connsToDestroy.begin();\n it != connsToDestroy.end();\n ++it)\n {\n (*it)->shutdown();\n }\n }\n\n void onBackendMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)\n {\n size_t len = buf->readableBytes();\n transferred_.addAndGet(len);\n receivedMessages_.incrementAndGet();\n sendToClient(buf);\n }\n\n void printStatistics()\n {\n Timestamp endTime = Timestamp::now();\n int64_t newCounter = transferred_.get();\n int64_t bytes = newCounter - oldCounter_;\n int64_t msgs = receivedMessages_.getAndSet(0);\n double time = timeDifference(endTime, startTime_);\n printf(\"%4.3f MiB/s %4.3f Ki Msgs/s %6.2f bytes per msg\\n\",\n static_cast(bytes)/time/1024/1024,\n static_cast(msgs)/time/1024,\n static_cast(bytes)/static_cast(msgs));\n\n oldCounter_ = newCounter;\n startTime_ = endTime;\n }\n\n TcpServer server_;\n TcpClient backend_;\n int numThreads_;\n AtomicInt64 transferred_;\n AtomicInt64 receivedMessages_;\n int64_t oldCounter_;\n Timestamp startTime_;\n MutexLock mutex_;\n TcpConnectionPtr backendConn_ GUARDED_BY(mutex_);\n std::map clientConns_ GUARDED_BY(mutex_);\n std::queue availIds_ GUARDED_BY(mutex_);\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid() << \", tid = \" << CurrentThread::tid();\n int numThreads = 4;\n if (argc > 1)\n {\n backendIp = argv[1];\n }\n if (argc > 2)\n {\n numThreads = atoi(argv[2]);\n }\n EventLoop loop;\n InetAddress listenAddr(kClientPort);\n InetAddress backendAddr(backendIp, kBackendPort);\n MultiplexServer server(&loop, listenAddr, backendAddr, numThreads);\n\n server.start();\n\n loop.loop();\n}\n\n" }, { "path": "examples/multiplexer/multiplexer_simple.cc", "content": "#include \"muduo/base/Logging.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/InetAddress.h\"\n#include \"muduo/net/TcpClient.h\"\n#include \"muduo/net/TcpServer.h\"\n\n#include \n#include \n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nconst int kMaxConns = 10; // 65535\nconst size_t kMaxPacketLen = 255;\nconst size_t kHeaderLen = 3;\n\nconst uint16_t kClientPort = 3333;\nconst char* backendIp = \"127.0.0.1\";\nconst uint16_t kBackendPort = 9999;\n\nclass MultiplexServer : noncopyable\n{\n public:\n MultiplexServer(EventLoop* loop, const InetAddress& listenAddr, const InetAddress& backendAddr)\n : server_(loop, listenAddr, \"MultiplexServer\"),\n backend_(loop, backendAddr, \"MultiplexBackend\")\n {\n server_.setConnectionCallback(\n std::bind(&MultiplexServer::onClientConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&MultiplexServer::onClientMessage, this, _1, _2, _3));\n backend_.setConnectionCallback(\n std::bind(&MultiplexServer::onBackendConnection, this, _1));\n backend_.setMessageCallback(\n std::bind(&MultiplexServer::onBackendMessage, this, _1, _2, _3));\n backend_.enableRetry();\n }\n\n void start()\n {\n backend_.connect();\n server_.start();\n }\n\n private:\n\n void onClientConnection(const TcpConnectionPtr& conn)\n {\n LOG_TRACE << \"Client \" << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n if (conn->connected())\n {\n int id = -1;\n if (!availIds_.empty())\n {\n id = availIds_.front();\n availIds_.pop();\n clientConns_[id] = conn;\n }\n\n if (id <= 0)\n {\n // no client id available\n conn->shutdown();\n }\n else\n {\n conn->setContext(id);\n char buf[256];\n snprintf(buf, sizeof(buf), \"CONN %d FROM %s IS UP\\r\\n\",\n id, conn->peerAddress().toIpPort().c_str());\n sendBackendString(0, buf);\n }\n }\n else\n {\n if (!conn->getContext().empty())\n {\n int id = boost::any_cast(conn->getContext());\n assert(id > 0 && id <= kMaxConns);\n char buf[256];\n snprintf(buf, sizeof(buf), \"CONN %d FROM %s IS DOWN\\r\\n\",\n id, conn->peerAddress().toIpPort().c_str());\n sendBackendString(0, buf);\n\n if (backendConn_)\n {\n // put client id back for reusing\n availIds_.push(id);\n clientConns_.erase(id);\n }\n else\n {\n assert(availIds_.empty());\n assert(clientConns_.empty());\n }\n }\n }\n }\n\n void sendBackendString(int id, const string& msg)\n {\n assert(msg.size() <= kMaxPacketLen);\n Buffer buf;\n buf.append(msg);\n sendBackendPacket(id, &buf);\n }\n\n void onClientMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)\n {\n if (!conn->getContext().empty())\n {\n int id = boost::any_cast(conn->getContext());\n sendBackendBuffer(id, buf);\n }\n else\n {\n buf->retrieveAll();\n // FIXME: error handling\n }\n }\n\n void sendBackendBuffer(int id, Buffer* buf)\n {\n while (buf->readableBytes() > kMaxPacketLen)\n {\n Buffer packet;\n packet.append(buf->peek(), kMaxPacketLen);\n buf->retrieve(kMaxPacketLen);\n sendBackendPacket(id, &packet);\n }\n if (buf->readableBytes() > 0)\n {\n sendBackendPacket(id, buf);\n }\n }\n\n void sendBackendPacket(int id, Buffer* buf)\n {\n size_t len = buf->readableBytes();\n LOG_DEBUG << \"sendBackendPacket \" << len;\n assert(len <= kMaxPacketLen);\n uint8_t header[kHeaderLen] = {\n static_cast(len),\n static_cast(id & 0xFF),\n static_cast((id & 0xFF00) >> 8)\n };\n buf->prepend(header, kHeaderLen);\n if (backendConn_)\n {\n backendConn_->send(buf);\n }\n }\n\n void onBackendConnection(const TcpConnectionPtr& conn)\n {\n LOG_TRACE << \"Backend \" << conn->localAddress().toIpPort() << \" -> \"\n << conn->peerAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n if (conn->connected())\n {\n backendConn_ = conn;\n assert(availIds_.empty());\n for (int i = 1; i <= kMaxConns; ++i)\n {\n availIds_.push(i);\n }\n }\n else\n {\n backendConn_.reset();\n for (std::map::iterator it = clientConns_.begin();\n it != clientConns_.end();\n ++it)\n {\n it->second->shutdown();\n }\n clientConns_.clear();\n while (!availIds_.empty())\n {\n availIds_.pop();\n }\n }\n }\n\n void onBackendMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)\n {\n sendToClient(buf);\n }\n\n void sendToClient(Buffer* buf)\n {\n while (buf->readableBytes() > kHeaderLen)\n {\n int len = static_cast(*buf->peek());\n if (buf->readableBytes() < len + kHeaderLen)\n {\n break;\n }\n else\n {\n int id = static_cast(buf->peek()[1]);\n id |= (static_cast(buf->peek()[2]) << 8);\n\n if (id != 0)\n {\n std::map::iterator it = clientConns_.find(id);\n if (it != clientConns_.end())\n {\n it->second->send(buf->peek() + kHeaderLen, len);\n }\n }\n else\n {\n string cmd(buf->peek() + kHeaderLen, len);\n LOG_INFO << \"Backend cmd \" << cmd;\n doCommand(cmd);\n }\n buf->retrieve(len + kHeaderLen);\n }\n }\n }\n\n void doCommand(const string& cmd)\n {\n static const string kDisconnectCmd = \"DISCONNECT \";\n\n if (cmd.size() > kDisconnectCmd.size()\n && std::equal(kDisconnectCmd.begin(), kDisconnectCmd.end(), cmd.begin()))\n {\n int connId = atoi(&cmd[kDisconnectCmd.size()]);\n std::map::iterator it = clientConns_.find(connId);\n if (it != clientConns_.end())\n {\n it->second->shutdown();\n }\n }\n }\n\n TcpServer server_;\n TcpClient backend_;\n // MutexLock mutex_;\n TcpConnectionPtr backendConn_;\n std::map clientConns_;\n std::queue availIds_;\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid();\n EventLoop loop;\n InetAddress listenAddr(kClientPort);\n if (argc > 1)\n {\n backendIp = argv[1];\n }\n InetAddress backendAddr(backendIp, kBackendPort);\n MultiplexServer server(&loop, listenAddr, backendAddr);\n\n server.start();\n\n loop.loop();\n}\n\n" }, { "path": "examples/netty/discard/CMakeLists.txt", "content": "add_executable(netty_discard_client client.cc)\ntarget_link_libraries(netty_discard_client muduo_net)\n\nadd_executable(netty_discard_server server.cc)\ntarget_link_libraries(netty_discard_server muduo_net)\n\n" }, { "path": "examples/netty/discard/client.cc", "content": "#include \"muduo/net/TcpClient.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Thread.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/InetAddress.h\"\n\n#include \n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nclass DiscardClient : noncopyable\n{\n public:\n DiscardClient(EventLoop* loop, const InetAddress& listenAddr, int size)\n : loop_(loop),\n client_(loop, listenAddr, \"DiscardClient\"),\n message_(size, 'H')\n {\n client_.setConnectionCallback(\n std::bind(&DiscardClient::onConnection, this, _1));\n client_.setMessageCallback(\n std::bind(&DiscardClient::onMessage, this, _1, _2, _3));\n client_.setWriteCompleteCallback(\n std::bind(&DiscardClient::onWriteComplete, this, _1));\n //client_.enableRetry();\n }\n\n void connect()\n {\n client_.connect();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_TRACE << conn->localAddress().toIpPort() << \" -> \"\n << conn->peerAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n if (conn->connected())\n {\n conn->setTcpNoDelay(true);\n conn->send(message_);\n }\n else\n {\n loop_->quit();\n }\n }\n\n void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp time)\n {\n buf->retrieveAll();\n }\n\n void onWriteComplete(const TcpConnectionPtr& conn)\n {\n LOG_INFO << \"write complete \" << message_.size();\n conn->send(message_);\n }\n\n EventLoop* loop_;\n TcpClient client_;\n string message_;\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid() << \", tid = \" << CurrentThread::tid();\n if (argc > 1)\n {\n EventLoop loop;\n InetAddress serverAddr(argv[1], 2009);\n\n int size = 256;\n if (argc > 2)\n {\n size = atoi(argv[2]);\n }\n\n DiscardClient client(&loop, serverAddr, size);\n client.connect();\n loop.loop();\n }\n else\n {\n printf(\"Usage: %s host_ip [msg_size]\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/netty/discard/server.cc", "content": "#include \"muduo/net/TcpServer.h\"\n\n#include \"muduo/base/Atomic.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Thread.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/InetAddress.h\"\n\n#include \n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nint numThreads = 0;\n\nclass DiscardServer\n{\n public:\n DiscardServer(EventLoop* loop, const InetAddress& listenAddr)\n : server_(loop, listenAddr, \"DiscardServer\"),\n oldCounter_(0),\n startTime_(Timestamp::now())\n {\n server_.setConnectionCallback(\n std::bind(&DiscardServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&DiscardServer::onMessage, this, _1, _2, _3));\n server_.setThreadNum(numThreads);\n loop->runEvery(3.0, std::bind(&DiscardServer::printThroughput, this));\n }\n\n void start()\n {\n LOG_INFO << \"starting \" << numThreads << \" threads.\";\n server_.start();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_TRACE << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n }\n\n void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)\n {\n size_t len = buf->readableBytes();\n transferred_.add(len);\n receivedMessages_.incrementAndGet();\n buf->retrieveAll();\n }\n\n void printThroughput()\n {\n Timestamp endTime = Timestamp::now();\n int64_t newCounter = transferred_.get();\n int64_t bytes = newCounter - oldCounter_;\n int64_t msgs = receivedMessages_.getAndSet(0);\n double time = timeDifference(endTime, startTime_);\n printf(\"%4.3f MiB/s %4.3f Ki Msgs/s %6.2f bytes per msg\\n\",\n static_cast(bytes)/time/1024/1024,\n static_cast(msgs)/time/1024,\n static_cast(bytes)/static_cast(msgs));\n\n oldCounter_ = newCounter;\n startTime_ = endTime;\n }\n\n TcpServer server_;\n\n AtomicInt64 transferred_;\n AtomicInt64 receivedMessages_;\n int64_t oldCounter_;\n Timestamp startTime_;\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid() << \", tid = \" << CurrentThread::tid();\n if (argc > 1)\n {\n numThreads = atoi(argv[1]);\n }\n EventLoop loop;\n InetAddress listenAddr(2009);\n DiscardServer server(&loop, listenAddr);\n\n server.start();\n\n loop.loop();\n}\n\n" }, { "path": "examples/netty/echo/CMakeLists.txt", "content": "add_executable(netty_echo_client client.cc)\ntarget_link_libraries(netty_echo_client muduo_net)\n\nadd_executable(netty_echo_server server.cc)\ntarget_link_libraries(netty_echo_server muduo_net)\n\nadd_executable(netty_echo_server2 server2.cc)\ntarget_link_libraries(netty_echo_server2 muduo_net)\n\n" }, { "path": "examples/netty/echo/client.cc", "content": "#include \"muduo/net/TcpClient.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Thread.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/InetAddress.h\"\n\n#include \n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nclass EchoClient : noncopyable\n{\n public:\n EchoClient(EventLoop* loop, const InetAddress& listenAddr, int size)\n : loop_(loop),\n client_(loop, listenAddr, \"EchoClient\"),\n message_(size, 'H')\n {\n client_.setConnectionCallback(\n std::bind(&EchoClient::onConnection, this, _1));\n client_.setMessageCallback(\n std::bind(&EchoClient::onMessage, this, _1, _2, _3));\n //client_.enableRetry();\n }\n\n void connect()\n {\n client_.connect();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_TRACE << conn->localAddress().toIpPort() << \" -> \"\n << conn->peerAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n\n if (conn->connected())\n {\n conn->setTcpNoDelay(true);\n conn->send(message_);\n }\n else\n {\n loop_->quit();\n }\n }\n\n void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp time)\n {\n conn->send(buf);\n }\n\n EventLoop* loop_;\n TcpClient client_;\n string message_;\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid() << \", tid = \" << CurrentThread::tid();\n if (argc > 1)\n {\n EventLoop loop;\n InetAddress serverAddr(argv[1], 2007);\n\n int size = 256;\n if (argc > 2)\n {\n size = atoi(argv[2]);\n }\n\n EchoClient client(&loop, serverAddr, size);\n client.connect();\n loop.loop();\n }\n else\n {\n printf(\"Usage: %s host_ip [msg_size]\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/netty/echo/server.cc", "content": "#include \"muduo/net/TcpServer.h\"\n\n#include \"muduo/base/Atomic.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Thread.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/InetAddress.h\"\n\n#include \n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nint numThreads = 0;\n\nclass EchoServer\n{\n public:\n EchoServer(EventLoop* loop, const InetAddress& listenAddr)\n : server_(loop, listenAddr, \"EchoServer\"),\n oldCounter_(0),\n startTime_(Timestamp::now())\n {\n server_.setConnectionCallback(\n std::bind(&EchoServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&EchoServer::onMessage, this, _1, _2, _3));\n server_.setThreadNum(numThreads);\n loop->runEvery(3.0, std::bind(&EchoServer::printThroughput, this));\n }\n\n void start()\n {\n LOG_INFO << \"starting \" << numThreads << \" threads.\";\n server_.start();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_TRACE << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n conn->setTcpNoDelay(true);\n }\n\n void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)\n {\n size_t len = buf->readableBytes();\n transferred_.addAndGet(len);\n receivedMessages_.incrementAndGet();\n conn->send(buf);\n }\n\n void printThroughput()\n {\n Timestamp endTime = Timestamp::now();\n int64_t newCounter = transferred_.get();\n int64_t bytes = newCounter - oldCounter_;\n int64_t msgs = receivedMessages_.getAndSet(0);\n double time = timeDifference(endTime, startTime_);\n printf(\"%4.3f MiB/s %4.3f Ki Msgs/s %6.2f bytes per msg\\n\",\n static_cast(bytes)/time/1024/1024,\n static_cast(msgs)/time/1024,\n static_cast(bytes)/static_cast(msgs));\n\n oldCounter_ = newCounter;\n startTime_ = endTime;\n }\n\n TcpServer server_;\n AtomicInt64 transferred_;\n AtomicInt64 receivedMessages_;\n int64_t oldCounter_;\n Timestamp startTime_;\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid() << \", tid = \" << CurrentThread::tid();\n if (argc > 1)\n {\n numThreads = atoi(argv[1]);\n }\n EventLoop loop;\n InetAddress listenAddr(2007);\n EchoServer server(&loop, listenAddr);\n\n server.start();\n\n loop.loop();\n}\n\n" }, { "path": "examples/netty/echo/server2.cc", "content": "#include \"muduo/net/TcpServer.h\"\n\n#include \"muduo/base/Atomic.h\"\n#include \"muduo/base/FileUtil.h\"\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/ProcessInfo.h\"\n#include \"muduo/base/Thread.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/InetAddress.h\"\n\n#include \n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nint numThreads = 0;\n\nclass EchoServer\n{\n public:\n EchoServer(EventLoop* loop, const InetAddress& listenAddr)\n : server_(loop, listenAddr, \"EchoServer\"),\n startTime_(Timestamp::now())\n {\n server_.setConnectionCallback(\n std::bind(&EchoServer::onConnection, this, _1));\n server_.setMessageCallback(\n std::bind(&EchoServer::onMessage, this, _1, _2, _3));\n server_.setThreadNum(numThreads);\n loop->runEvery(5.0, std::bind(&EchoServer::printThroughput, this));\n }\n\n void start()\n {\n LOG_INFO << \"starting \" << numThreads << \" threads.\";\n server_.start();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_TRACE << conn->peerAddress().toIpPort() << \" -> \"\n << conn->localAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n conn->setTcpNoDelay(true);\n if (conn->connected())\n {\n connections_.increment();\n }\n else\n {\n connections_.decrement();\n }\n }\n\n void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)\n {\n size_t len = buf->readableBytes();\n transferredBytes_.addAndGet(len);\n receivedMessages_.incrementAndGet();\n conn->send(buf);\n }\n\n void printThroughput()\n {\n Timestamp endTime = Timestamp::now();\n double bytes = static_cast(transferredBytes_.getAndSet(0));\n int msgs = receivedMessages_.getAndSet(0);\n double bytesPerMsg = msgs > 0 ? bytes/msgs : 0;\n double time = timeDifference(endTime, startTime_);\n printf(\"%.3f MiB/s %.2f Kilo Msgs/s %.2f bytes per msg, \",\n bytes/time/1024/1024,\n static_cast(msgs)/time/1000,\n bytesPerMsg);\n\n printConnection();\n fflush(stdout);\n startTime_ = endTime;\n }\n\n void printConnection()\n {\n string procStatus = ProcessInfo::procStatus();\n printf(\"%d conn, files %d , VmSize %ld KiB, RSS %ld KiB, \",\n connections_.get(),\n ProcessInfo::openedFiles(),\n getLong(procStatus, \"VmSize:\"),\n getLong(procStatus, \"VmRSS:\"));\n\n string meminfo;\n FileUtil::readFile(\"/proc/meminfo\", 65536, &meminfo);\n long total_kb = getLong(meminfo, \"MemTotal:\");\n long free_kb = getLong(meminfo, \"MemFree:\");\n long buffers_kb = getLong(meminfo, \"Buffers:\");\n long cached_kb = getLong(meminfo, \"Cached:\");\n printf(\"system memory used %ld KiB\\n\",\n total_kb - free_kb - buffers_kb - cached_kb);\n }\n\n long getLong(const string& procStatus, const char* key)\n {\n long result = 0;\n size_t pos = procStatus.find(key);\n if (pos != string::npos)\n {\n result = ::atol(procStatus.c_str() + pos + strlen(key));\n }\n return result;\n }\n\n TcpServer server_;\n AtomicInt32 connections_;\n AtomicInt32 receivedMessages_;\n AtomicInt64 transferredBytes_;\n Timestamp startTime_;\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid()\n << \", tid = \" << CurrentThread::tid()\n << \", max files = \" << ProcessInfo::maxOpenFiles();\n Logger::setLogLevel(Logger::WARN);\n if (argc > 1)\n {\n numThreads = atoi(argv[1]);\n }\n EventLoop loop;\n InetAddress listenAddr(2007);\n EchoServer server(&loop, listenAddr);\n\n server.start();\n\n loop.loop();\n}\n\n" }, { "path": "examples/netty/uptime/CMakeLists.txt", "content": "add_executable(netty_uptime uptime.cc)\ntarget_link_libraries(netty_uptime muduo_net)\n\n" }, { "path": "examples/netty/uptime/uptime.cc", "content": "#include \"muduo/net/TcpClient.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Thread.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/InetAddress.h\"\n\n#include \n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nclass UptimeClient : noncopyable\n{\n public:\n UptimeClient(EventLoop* loop, const InetAddress& listenAddr)\n : client_(loop, listenAddr, \"UptimeClient\")\n {\n client_.setConnectionCallback(\n std::bind(&UptimeClient::onConnection, this, _1));\n client_.setMessageCallback(\n std::bind(&UptimeClient::onMessage, this, _1, _2, _3));\n //client_.enableRetry();\n }\n\n void connect()\n {\n client_.connect();\n }\n\n private:\n void onConnection(const TcpConnectionPtr& conn)\n {\n LOG_TRACE << conn->localAddress().toIpPort() << \" -> \"\n << conn->peerAddress().toIpPort() << \" is \"\n << (conn->connected() ? \"UP\" : \"DOWN\");\n }\n\n void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp time)\n {\n }\n\n TcpClient client_;\n};\n\nint main(int argc, char* argv[])\n{\n LOG_INFO << \"pid = \" << getpid() << \", tid = \" << CurrentThread::tid();\n if (argc > 2)\n {\n EventLoop loop;\n uint16_t port = static_cast(atoi(argv[2]));\n InetAddress serverAddr(argv[1], port);\n\n UptimeClient client(&loop, serverAddr);\n client.connect();\n loop.loop();\n }\n else\n {\n printf(\"Usage: %s host_ip port\\n\", argv[0]);\n }\n}\n\n" }, { "path": "examples/pingpong/CMakeLists.txt", "content": "add_executable(pingpong_client client.cc)\ntarget_link_libraries(pingpong_client muduo_net)\n\nadd_executable(pingpong_server server.cc)\ntarget_link_libraries(pingpong_server muduo_net)\n\nadd_executable(pingpong_bench bench.cc)\ntarget_link_libraries(pingpong_bench muduo_net)\n\n" }, { "path": "examples/pingpong/bench.cc", "content": "// Benchmark inspired by libevent/test/bench.c\n// See also: http://libev.schmorp.de/bench.html\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Thread.h\"\n#include \"muduo/net/Channel.h\"\n#include \"muduo/net/EventLoop.h\"\n\n#include \n#include \n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nstd::vector g_pipes;\nint numPipes;\nint numActive;\nint numWrites;\nEventLoop* g_loop;\nstd::vector> g_channels;\n\nint g_reads, g_writes, g_fired;\n\nvoid readCallback(Timestamp, int fd, int idx)\n{\n char ch;\n\n g_reads += static_cast(::recv(fd, &ch, sizeof(ch), 0));\n if (g_writes > 0)\n {\n int widx = idx+1;\n if (widx >= numPipes)\n {\n widx -= numPipes;\n }\n ::send(g_pipes[2 * widx + 1], \"m\", 1, 0);\n g_writes--;\n g_fired++;\n }\n if (g_fired == g_reads)\n {\n g_loop->quit();\n }\n}\n\nstd::pair runOnce()\n{\n Timestamp beforeInit(Timestamp::now());\n for (int i = 0; i < numPipes; ++i)\n {\n Channel& channel = *g_channels[i];\n channel.setReadCallback(std::bind(readCallback, _1, channel.fd(), i));\n channel.enableReading();\n }\n\n int space = numPipes / numActive;\n space *= 2;\n for (int i = 0; i < numActive; ++i)\n {\n ::send(g_pipes[i * space + 1], \"m\", 1, 0);\n }\n\n g_fired = numActive;\n g_reads = 0;\n g_writes = numWrites;\n Timestamp beforeLoop(Timestamp::now());\n g_loop->loop();\n\n Timestamp end(Timestamp::now());\n\n int iterTime = static_cast(end.microSecondsSinceEpoch() - beforeInit.microSecondsSinceEpoch());\n int loopTime = static_cast(end.microSecondsSinceEpoch() - beforeLoop.microSecondsSinceEpoch());\n return std::make_pair(iterTime, loopTime);\n}\n\nint main(int argc, char* argv[])\n{\n numPipes = 100;\n numActive = 1;\n numWrites = 100;\n int c;\n while ((c = getopt(argc, argv, \"n:a:w:\")) != -1)\n {\n switch (c)\n {\n case 'n':\n numPipes = atoi(optarg);\n break;\n case 'a':\n numActive = atoi(optarg);\n break;\n case 'w':\n numWrites = atoi(optarg);\n break;\n default:\n fprintf(stderr, \"Illegal argument \\\"%c\\\"\\n\", c);\n return 1;\n }\n }\n\n struct rlimit rl;\n rl.rlim_cur = rl.rlim_max = numPipes * 2 + 50;\n if (::setrlimit(RLIMIT_NOFILE, &rl) == -1)\n {\n perror(\"setrlimit\");\n //return 1; // comment out this line if under valgrind\n }\n g_pipes.resize(2 * numPipes);\n for (int i = 0; i < numPipes; ++i)\n {\n if (::socketpair(AF_UNIX, SOCK_STREAM, 0, &g_pipes[i*2]) == -1)\n {\n perror(\"pipe\");\n return 1;\n }\n }\n\n EventLoop loop;\n g_loop = &loop;\n\n for (int i = 0; i < numPipes; ++i)\n {\n Channel* channel = new Channel(&loop, g_pipes[i*2]);\n g_channels.emplace_back(channel);\n }\n\n for (int i = 0; i < 25; ++i)\n {\n std::pair t = runOnce();\n printf(\"%8d %8d\\n\", t.first, t.second);\n }\n\n for (const auto& channel : g_channels)\n {\n channel->disableAll();\n channel->remove();\n }\n g_channels.clear();\n}\n\n" }, { "path": "examples/pingpong/client.cc", "content": "#include \"muduo/net/TcpClient.h\"\n\n#include \"muduo/base/Logging.h\"\n#include \"muduo/base/Thread.h\"\n#include \"muduo/net/EventLoop.h\"\n#include \"muduo/net/EventLoopThreadPool.h\"\n#include \"muduo/net/InetAddress.h\"\n\n#include \n\n#include \n#include \n\nusing namespace muduo;\nusing namespace muduo::net;\n\nclass Client;\n\nclass Session : noncopyable\n{\n public:\n Session(EventLoop* loop,\n const InetAddress& serverAddr,\n const string& name,\n Client* owner)\n : client_(loop, serverAddr, name),\n owner_(owner),\n bytesRead_(0),\n bytesWritten_(0),\n messagesRead_(0)\n {\n client_.setConnectionCallback(\n std::bind(&Session::onConnection, this, _1));\n client_.setMessageCallback(\n std::bind(&Session::onMessage, this, _1, _2, _3));\n }\n\n void start()\n {\n client_.connect();\n }\n\n void stop()\n {\n client_.disconnect();\n }\n\n int64_t bytesRead() const\n {\n return bytesRead_;\n }\n\n int64_t messagesRead() const\n {\n return messagesRead_;\n }\n\n private:\n\n void onConnection(const TcpConnectionPtr& conn);\n\n void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)\n {\n ++messagesRead_;\n bytesRead_ += buf->readableBytes();\n bytesWritten_ += buf->readableBytes();\n conn->send(buf);\n }\n\n TcpClient client_;\n Client* owner_;\n int64_t bytesRead_;\n int64_t bytesWritten_;\n int64_t messagesRead_;\n};\n\nclass Client : noncopyable\n{\n public:\n Client(EventLoop* loop,\n const InetAddress& serverAddr,\n int blockSize,\n int sessionCount,\n int timeout,\n int threadCount)\n : loop_(loop),\n threadPool_(loop, \"pingpong-client\"),\n sessionCount_(sessionCount),\n timeout_(timeout)\n {\n loop->runAfter(timeout, std::bind(&Client::handleTimeout, this));\n if (threadCount > 1)\n {\n threadPool_.setThreadNum(threadCount);\n }\n threadPool_.start();\n\n for (int i = 0; i < blockSize; ++i)\n {\n message_.push_back(static_cast(i % 128));\n }\n\n for (int i = 0; i < sessionCount; ++i)\n {\n char buf[32];\n snprintf(buf, sizeof buf, \"C%05d\", i);\n Session* session = new Session(threadPool_.getNextLoop(), serverAddr, buf, this);\n session->start();\n sessions_.emplace_back(session);\n }\n }\n\n const string& message() const\n {\n return message_;\n }\n\n void onConnect()\n {\n if (numConnected_.incrementAndGet() == sessionCount_)\n {\n LOG_WARN << \"all connected\";\n }\n }\n\n void onDisconnect(const TcpConnectionPtr& conn)\n {\n if (numConnected_.decrementAndGet() == 0)\n {\n LOG_WARN << \"all disconnected\";\n\n int64_t totalBytesRead = 0;\n int64_t totalMessagesRead = 0;\n for (const auto& session : sessions_)\n {\n totalBytesRead += session->bytesRead();\n totalMessagesRead += session->messagesRead();\n }\n LOG_WARN << totalBytesRead << \" total bytes read\";\n LOG_WARN << totalMessagesRead << \" total messages read\";\n LOG_WARN << static_cast(totalBytesRead) / static_cast(totalMessagesRead)\n << \" average message size\";\n LOG_WARN << static_cast(totalBytesRead) / (timeout_ * 1024 * 1024)\n << \" MiB/s throughput\";\n conn->getLoop()->queueInLoop(std::bind(&Client::quit, this));\n }\n }\n\n private:\n\n void quit()\n {\n loop_->queueInLoop(std::bind(&EventLoop::quit, loop_));\n }\n\n void handleTimeout()\n {\n LOG_WARN << \"stop\";\n for (auto& session : sessions_)\n {\n session->stop();\n }\n }\n\n EventLoop* loop_;\n EventLoopThreadPool threadPool_;\n int sessionCount_;\n int timeout_;\n std::vector> sessions_;\n string message_;\n AtomicInt32 numConnected_;\n};\n\nvoid Session::onConnection(const TcpConnectionPtr& conn)\n{\n if (conn->connected())\n {\n conn->setTcpNoDelay(true);\n conn->send(owner_->message());\n owner_->onConnect();\n }\n else\n {\n owner_->onDisconnect(conn);\n }\n}\n\nint main(int argc, char* argv[])\n{\n if (argc != 7)\n {\n fprintf(stderr, \"Usage: client \");\n fprintf(stderr, \"