Ye_Ol_Pi_Shack
/
CppCMS
2
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 1 Wiki Activity
ChipMaster's trial hacks on C++CMS starting with v1.2.1. Not sure I'll follow on with the v2 since it looks to be breaking and mostly frivolous.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
463 Commits
2 Branches
13 MiB
 
 
 
 
 
 
Tree: 08a10832f3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '08a10832f3'
${ noResults }
CppCMS/acceptor.patch

421 lines
10 KiB
Raw Blame History 

  1. Index: proc_acceptor.cpp

  2. ===================================================================

  3. --- proc_acceptor.cpp	(revision 1153)

  4. +++ proc_acceptor.cpp	(working copy)

  5. @@ -1,5 +1,6 @@

  6.  #define CPPCMS_SOURCE

  7.  #include "proc_acceptor.h"

  8. +#include <iostream>

  9.  namespace cppcms { namespace impl {

  10.  

  11.  	process_shared_acceptor::process_shared_acceptor(cppcms::service &srv)

  12. @@ -12,15 +13,30 @@

  13.  		service_=&srv.impl().get_io_service();

  14.  		srv.after_fork(boost::bind(&process_shared_acceptor::on_fork,this));

  15.  	}

  16. +	

  17. +	void process_shared_acceptor::start()

  18. +	{

  19. +		worker_.reset(new boost::thread(boost::bind(&process_shared_acceptor::run,this)));

  20. +	}

  21. +	

  22. +	void process_shared_acceptor::stop()

  23. +	{

  24. +		stop_ = true;

  25. +		wake();

  26. +		worker_->join();

  27. +	}

  28.  

  29.  	void process_shared_acceptor::on_fork()

  30.  	{

  31.  		int fds[2];

  32. -		pipe(fds);

  33. +		if(::pipe(fds) < 0) {

  34. +			throw cppcms_error(errno,"Creation of pipe failed");

  35. +		}

  36.  		break_fd_=fds[0];

  37.  		wake_fd_=fds[1];

  38.  		max_1_=std::max(break_fd_,wake_fd_)+1;

  39.  		FD_SET(break_fd_,&wait_set);

  40. +		start();

  41.  	}

  42.  	void process_shared_acceptor::wake()

  43.  	{

  44. @@ -32,6 +48,26 @@

  45.  		}

  46.  	}

  47.  

  48. +	struct assigner_and_caller {

  49. +		function<void(int)> assigner;

  50. +		function<void(boost::system::error_code const &e)> callback;

  51. +		int fd;

  52. +		boost::system::error_code e;

  53. +		void operator()()

  54. +		{

  55. +			std::cout << "Assigning and calling" << std::endl;

  56. +			try {

  57. +				if(!assigner.empty())

  58. +					assigner(fd);

  59. +				callback(e);

  60. +			}

  61. +			catch(std::exception const &e)

  62. +			{

  63. +				std::cerr << "Assigning and calling failed " << e.what() << std::endl;

  64. +			}

  65. +		}

  66. +	};

  67. +

  68.  	bool process_shared_acceptor::run_one()

  69.  	{

  70.  		fd_set rd;

  71. @@ -42,7 +78,9 @@

  72.  		int n;

  73.  		{

  74.  			mutex::guard guard(process_mutex_);

  75. +			std::cout << "Selecting " << getpid() << std::endl;

  76.  			n=::select(max_1_,&rd,0,0,0);

  77. +			std::cout << "Selected " << n << std::endl;

  78.  			if(n < 0 && errno==EINTR)

  79.  				return true;

  80.  			if(n < 0)

  81. @@ -63,19 +101,22 @@

  82.  					int fd=::accept(afd,0,0);

  83.  					int err=errno;

  84.  

  85. +					std::cout << "Accepted " << afd << " as " << fd << " in " << getpid() <<std::endl;

  86. +

  87.  					thread_guard tguard(thread_mutex_);

  88.  

  89. -					boost::system::error_code e;

  90. -					if(fd > 0) {

  91. -						assigners_[afd](fd);

  92. -						assigners_[afd]=assign_function();

  93. +					assigner_and_caller anc;

  94. +					if(fd >= 0) {

  95. +						anc.assigner.swap(assigners_[afd]);

  96. +						anc.fd=fd;

  97.  					}

  98.  					else {

  99. -						e=boost::system::error_code(err,boost::system::errno_ecat);

  100. +						anc.e=boost::system::error_code(err,boost::system::errno_ecat);

  101.  					}

  102. -					service_->post(boost::bind(callbacks_[afd],e));

  103. -					callbacks_[afd]=on_accept_function();

  104. +					anc.callback.swap(callbacks_[afd]);

  105.  					FD_CLR(afd,&wait_set);

  106. +					std::cout << "Posting " << std::endl;

  107. +					service_->post(anc);

  108.  				}

  109.  			}

  110.  		}

  111. @@ -83,8 +124,10 @@

  112.  	}

  113.  	void process_shared_acceptor::run()

  114.  	{

  115. +		std::cout << "Running " << getpid() << std::endl;

  116.  		while(run_one())

  117.  			;

  118. +		std::cout << "Done " << getpid() << std::endl;

  119.  	}

  120.  

  121.  	process_shared_acceptor::~process_shared_acceptor()

  122. Index: service.cpp

  123. ===================================================================

  124. --- service.cpp	(revision 1153)

  125. +++ service.cpp	(working copy)

  126. @@ -49,7 +49,11 @@

  127.  #include "views_pool.h"

  128.  #include "session_pool.h"

  129.  

  130. +#ifndef CPPCMS_WIN32

  131. +#include "proc_acceptor.h"

  132. +#endif

  133.  

  134. +

  135.  #ifdef CPPCMS_POSIX

  136.  #include <sys/wait.h>

  137.  #endif

  138. @@ -304,6 +308,17 @@

  139.  #endif

  140.  }

  141.  

  142. +void service::reset_service()

  143. +{

  144. +	#ifndef CPPCMS_WIN32

  145. +	std::auto_ptr<boost::asio::io_service> new_service(new boost::asio::io_service());

  146. +	for(unsigned i=0;i<impl_->acceptors_.size();i++)

  147. +		impl_->acceptors_[i]=impl_->acceptors_[i]->clone(*new_service);

  148. +	impl_->io_service_ = new_service;

  149. +

  150. +	#endif

  151. +}

  152. +

  153.  void service::after_fork(function<void()> const &cb)

  154.  {

  155.  	impl_->on_fork_.push_back(cb);

  156. @@ -313,27 +328,46 @@

  157.  {

  158.  	generator();

  159.  	session_pool().init();

  160. +

  161. +	#ifndef CPPCMS_WIN32

  162. +	//if(procs_no() > 1) {

  163. +		impl_->process_shared_acceptor_.reset(new impl::process_shared_acceptor(*this));

  164. +	//}

  165. +	#endif

  166. +

  167.  	start_acceptor();

  168.  

  169.  	if(settings().get("file_server.enable",false))

  170.  		applications_pool().mount(applications_factory<cppcms::impl::file_server>(),"");

  171.  

  172. +	std::cout << "FORKING" << std::endl;

  173. +

  174.  	if(prefork()) {

  175.  		return;

  176.  	}

  177.  	thread_pool(); // make sure we start it

  178.  	

  179. +	

  180.  	for(unsigned i=0;i<impl_->on_fork_.size();i++)

  181.  		impl_->on_fork_[i]();

  182.  

  183.  	impl_->on_fork_.clear();

  184. +	

  185. +	#ifndef CPPCMS_WIN32

  186. +	//if(procs_no() > 1) {

  187. +		reset_service();

  188. +	//}

  189. +	#endif

  190.  

  191.  	for(unsigned i=0;i<impl_->acceptors_.size();i++)

  192.  		impl_->acceptors_[i]->async_accept();

  193.  

  194.  	setup_exit_handling();

  195. +	

  196. +	std::cout << "LOOPING" << std::endl;

  197.  

  198.  	impl_->get_io_service().run();

  199. +	std::cout << "Exitting " << std::endl;

  200.  }

  201.  

  202.  int service::procs_no()

  203. @@ -668,6 +702,12 @@

  204.  	service::~service()

  205.  	{

  206.  		acceptors_.clear();

  207. +		#ifndef CPPCMS_WIN32

  208. +		if(process_shared_acceptor_.get()) {

  209. +			process_shared_acceptor_->stop();

  210. +			process_shared_acceptor_.reset();

  211. +		}

  212. +		#endif

  213.  		thread_pool_.reset();

  214.  		sig_.reset();

  215.  		breaker_.reset();

  216. Index: cgi_api.h

  217. ===================================================================

  218. --- cgi_api.h	(revision 1153)

  219. +++ cgi_api.h	(working copy)

  220. @@ -24,6 +24,7 @@

  221.  #include "intrusive_ptr.h"

  222.  #include <vector>

  223.  #include <map>

  224. +#include <memory>

  225.  #include "function.h"

  226.  #include "config.h"

  227.  #ifdef CPPCMS_USE_EXTERNAL_BOOST

  228. @@ -58,6 +59,7 @@

  229.  	public:

  230.  		virtual void async_accept() = 0;

  231.  		virtual void stop() = 0;

  232. +		virtual std::auto_ptr<acceptor> clone(boost::asio::io_service &) = 0;

  233.  		virtual ~acceptor(){}

  234.  	};

  235.  

  236. Index: cgi_acceptor.h

  237. ===================================================================

  238. --- cgi_acceptor.h	(revision 1153)

  239. +++ cgi_acceptor.h	(working copy)

  240. @@ -32,7 +32,13 @@

  241.  #   include <cppcms_boost/bind.hpp>

  242.      namespace boost = cppcms_boost;

  243.  #endif

  244. +#ifndef CPPCMS_WIN32

  245. +#include "proc_acceptor.h"

  246. +#include <unistd.h>

  247. +#endif

  248.  

  249. +

  250. +

  251.  namespace cppcms {

  252.  namespace impl {

  253.  	namespace cgi {

  254. @@ -40,12 +46,33 @@

  255.  		template<typename Proto,class ServerAPI>

  256.  		class socket_acceptor : public acceptor {

  257.  		public:

  258. +			socket_acceptor(cppcms::service &srv,boost::asio::io_service &iosrv) :

  259. +				srv_(srv),

  260. +				acceptor_(iosrv),

  261. +				stopped_(false)

  262. +			{

  263. +			}

  264.  			socket_acceptor(cppcms::service &srv) :

  265.  				srv_(srv),

  266.  				acceptor_(srv_.impl().get_io_service()),

  267.  				stopped_(false)

  268.  			{

  269.  			}

  270. +			virtual std::auto_ptr<acceptor> clone(boost::asio::io_service &iosrv) 

  271. +			{

  272. +				#ifdef CPPCMS_WIN32

  273. +				throw cppcms_error("Internal error - cloning should not be done under Windows platform");

  274. +				#else

  275. +				std::auto_ptr<socket_acceptor<Proto,ServerAPI> > tmp(new socket_acceptor<Proto,ServerAPI>(srv_,iosrv));

  276. +				int newfd = ::dup(acceptor_.native());

  277. +				if(newfd < 0)

  278. +					throw cppcms_error(errno,"Dup failed");

  279. +				tmp->acceptor_.assign(acceptor_.local_endpoint().protocol(),newfd);

  280. +				std::auto_ptr<acceptor> tmp2;

  281. +				tmp2 = tmp;

  282. +				return tmp2;

  283. +				#endif

  284. +			}

  285.  			virtual void async_accept()

  286.  			{

  287.  				if(stopped_)

  288. @@ -53,11 +80,24 @@

  289.  				ServerAPI *api=new ServerAPI(srv_);

  290.  				api_=api;

  291.  				asio_socket_ = &api->socket_;

  292. -				acceptor_.async_accept(

  293. -					*asio_socket_,

  294. -					boost::bind(	&socket_acceptor::on_accept,

  295. -							this,

  296. -							boost::asio::placeholders::error));

  297. +#ifndef CPPCMS_WIN32

  298. +				if(srv_.impl().process_shared_acceptor_.get()) {

  299. +					srv_.impl().process_shared_acceptor_->async_accept(

  300. +						acceptor_,

  301. +						*asio_socket_,

  302. +						boost::bind(	&socket_acceptor::on_accept,

  303. +								this,

  304. +								boost::asio::placeholders::error));

  305. +				}

  306. +				else

  307. +#endif

  308. +				{

  309. +					acceptor_.async_accept(

  310. +						*asio_socket_,

  311. +						boost::bind(	&socket_acceptor::on_accept,

  312. +								this,

  313. +								boost::asio::placeholders::error));

  314. +				}

  315.  			}

  316.  			virtual void stop()

  317.  			{

  318. Index: service.h

  319. ===================================================================

  320. --- service.h	(revision 1153)

  321. +++ service.h	(working copy)

  322. @@ -80,6 +80,7 @@

  323.  		void start_acceptor();

  324.  		void setup_exit_handling();

  325.  		bool prefork();

  326. +		void reset_service();

  327.  		util::hold_ptr<impl::service> impl_;

  328.  	};

  329.  

  330. Index: service_impl.h

  331. ===================================================================

  332. --- service_impl.h	(revision 1153)

  333. +++ service_impl.h	(working copy)

  334. @@ -31,6 +31,7 @@

  335.  class session_pool;

  336.  

  337.  namespace impl {

  338. +	class process_shared_acceptor;

  339.  	namespace cgi {

  340.  		class acceptor;

  341.  	}

  342. @@ -44,6 +45,9 @@

  343.  			return *io_service_;

  344.  		}

  345.  

  346. +		#ifndef CPPCMS_WIN32

  347. +		std::auto_ptr<process_shared_acceptor> process_shared_acceptor_;

  348. +		#endif

  349.  

  350.  	private:

  351.  		friend class cppcms::service;

  352. Index: CMakeLists.txt

  353. ===================================================================

  354. --- CMakeLists.txt	(revision 1153)

  355. +++ CMakeLists.txt	(working copy)

  356. @@ -520,7 +520,7 @@

  357.  if(WIN32 AND NOT CYGWIN)

  358.  	set(CPPCMS_SOURCES ${CPPCMS_SOURCES} session_win32_file_storage.cpp)

  359.  else(WIN32 AND NOT CYGWIN)

  360. -	set(CPPCMS_SOURCES ${CPPCMS_SOURCES} session_posix_file_storage.cpp)

  361. +	set(CPPCMS_SOURCES ${CPPCMS_SOURCES} session_posix_file_storage.cpp proc_acceptor.cpp)

  362.  endif(WIN32 AND NOT CYGWIN)

  363.  

  364.  if(NOT DISABLE_SHARED)

  365. Index: proc_acceptor.h

  366. ===================================================================

  367. --- proc_acceptor.h	(revision 1153)

  368. +++ proc_acceptor.h	(working copy)

  369. @@ -29,7 +29,7 @@

  370.  			~process_shared_acceptor();

  371.  

  372.  			template<typename Socket1,typename Socket2>

  373. -			void async_accept(Socket1 acc,Socket2 sock,on_accept_function const &on_accepted)

  374. +			void async_accept(Socket1 &acc,Socket2 &sock,on_accept_function const &on_accepted)

  375.  			{

  376.  				int fd = acc.native();

  377.  				{

  378. @@ -38,16 +38,28 @@

  379.  					if(fd + 1 > max_1_ )

  380.  						max_1_ = fd+1;

  381.  					callbacks_[fd]=on_accepted;

  382. -					assigners_[fd]=boost::bind(&Socket2::assign,&sock,_1);

  383. +					assigner<Socket2> as = { &sock, acc.local_endpoint().protocol() };

  384. +					assigners_[fd]=as;

  385.  				}

  386.  				wake();

  387.  			}

  388. -			void stop()

  389. +			void start();

  390. +			void stop();

  391. +		private:

  392. +

  393. +			template<typename Socket>

  394. +			struct assigner

  395.  			{

  396. -				stop_ = true;

  397. -				wake();

  398. -			}

  399. -		private:

  400. +				typedef typename Socket::protocol_type protocol_type;

  401. +				Socket *sock;

  402. +				protocol_type proto;

  403. +				void operator()(int fd) const

  404. +				{

  405. +					sock->assign(proto,fd);

  406. +				}

  407. +			};

  408. +

  409. +

  410.  			void on_fork();

  411.  			void wake();

  412.  			bool run_one();

  413. @@ -64,6 +76,7 @@

  414.  			std::vector<on_accept_function> callbacks_;

  415.  			std::vector<assign_function> assigners_;

  416.  			boost::asio::io_service *service_;

  417. +			std::auto_ptr<boost::thread> worker_;

  418.  		}

  419.  ;

  420.  	}