This is a client used for benchmarking the server capacity. Currently sending ~3kb message

async_client_new.cpp

#include <iostream>
#include <boost/array.hpp>
#include <boost/asio.hpp>
#include <boost/filesystem.hpp>
#include <stdlib.h>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <time.h>
#include <sys/timeb.h>
using boost::asio::ip::tcp;


void SaveFileInDirectory(std::string filename, std::string directory, std::string *file_content)
		{
			try
			{
				//std::cout << "Current Dir: " << boost::filesystem::current_path().string() << std::endl;
				//boost::filesystem::create_directories( "TempFolder" );
				if(!(boost::filesystem::exists(directory)))
				{
					//std::cout<<"Doesn't Exists"<<std::endl;
					if (boost::filesystem::create_directory(directory))
					{
						std::cout << "Successfully Created !" << std::endl;
					}
				}
				std::string full_path = directory+filename;
#if defined(_MSC_VER)
	full_path += ".dll";
#elif defined(__GNUC__)
	full_path += ".so";
#endif
				
				boost::system::error_code ec;
				try
				{
					if(boost::filesystem::exists(full_path, ec))
						boost::filesystem::remove(full_path);
				}
				catch(boost::filesystem::filesystem_error& er)
				{
					//??
					//WriteToLogForDebug(er.what());
				}
				std::ofstream ofs(full_path.c_str(), std::ios::out | std::ios::binary); 
				
				if (ofs) 
				{ 
					ofs << *file_content; 
					//std::cout << full_path << " received" << std::endl; 
				} 
				else 
				{
					std::cerr << full_path << " couldn't be created" << std::endl;
				}

			}
			catch(const boost::filesystem::filesystem_error& err)
			{
				std::cerr << err.what() << std::endl;
			}
		}
class Connection
{
	boost::asio::ip::tcp::socket socket_;
	boost::asio::io_service &io_service_;
	std::string ip_;
	std::string port_;
public:
	Connection(boost::asio::io_service &io_service, std::string ip, std::string port);
	void Connect();
	void SendData(std::string);
	std::string ReceiveData();
	void Close();
	bool DownloadFile(std::string filename);
	bool isConnected();
};

void Connection::Connect()
{
	try
	{
		tcp::resolver resolver(io_service_);
		tcp::resolver::query query(ip_, port_);
		tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
		socket_.connect(*endpoint_iterator);
	}
	catch(boost::system::system_error &ec)
	{
		std::cout << ec.code() << " " << ec.what() << std::endl;
	}
    
}
bool Connection::isConnected()
{
	bool response = socket_.is_open();
	return response;
}

void Connection::Close()
{
	try
	{
		socket_.close();
	}
	catch(boost::system::system_error &ec)
	{
		std::cout << ec.code() << " " << ec.what() << std::endl;
	}
	
}

void Connection::SendData(std::string message)
{
	try
	{
		socket_.send(boost::asio::buffer(message));
	}
	catch(boost::system::system_error &ec)
	{
		std::cout << ec.code() << " " << ec.what() << std::endl;
	}
}

std::string Connection::ReceiveData()
{
	std::string message;
	try
	{
		boost::asio::streambuf buf;
		size_t len;
		boost::asio::streambuf::mutable_buffers_type mbuf = buf.prepare(512);
		do {
			len = socket_.receive(mbuf);
			//std::cout << len << std::endl;
			std::string str(boost::asio::buffers_begin(mbuf), boost::asio::buffers_begin(mbuf) + len);
			message = message + str;
		} while (len>=512); 
	}
	catch(boost::system::system_error &ec)
	{
		std::cout << ec.code() << " " << ec.what() << std::endl;
	}
	return message;
}

Connection::Connection(boost::asio::io_service &io_service, std::string ip, std::string port):io_service_(io_service),socket_(io_service)
{
	//Constructor
	port_ = port;
	ip_ = ip;;
}

bool Connection::DownloadFile(std::string json)
{
	try
	{
		uintmax_t file_size;
		boost::array<char, 512*1024> buffer;
		std::string file;
		boost::system::error_code ec_write;
		size_t bytes_written = socket_.write_some(boost::asio::buffer(json),ec_write);
		if(bytes_written == 0)
			std::cout << "Error Occured\n";
		boost::system::error_code ec;
		uintmax_t total_bytes_of_file_transferred =0;
		std::string filename = "";
		while(ec==0) 
		{ 
			size_t bytes_transferred= socket_.read_some(boost::asio::buffer(buffer),ec);
			if(bytes_transferred <= 0)
				break;
			total_bytes_of_file_transferred = total_bytes_of_file_transferred + bytes_transferred;
			std::string data(buffer.data(), bytes_transferred);
			if (filename.empty())
			{ 
				boost::iterator_range<std::string::iterator> r1 = boost::find_nth(data, "\n", 0);
				filename = std::string(data.begin(),r1.begin());
				boost::iterator_range<std::string::iterator> r2 = boost::find_nth(data, "\n", 1);
				std::string file_sizestr = std::string(r1.begin()+1,r2.begin());
				file_size = boost::lexical_cast<uintmax_t>(file_sizestr);
				std::string remaining_data = std::string(r2.end(),data.end());
				file+=remaining_data;
				total_bytes_of_file_transferred = total_bytes_of_file_transferred-(filename.length()+file_sizestr.length()+1);
			}
			else
			{
				file += data;
			}
			if(total_bytes_of_file_transferred>=file_size){
				break;
			}
		} 
		if(ec==0 || ec== boost::asio::error::eof)
		{
			if(total_bytes_of_file_transferred>=file_size){
				SaveFileInDirectory(filename,"asdf\\",&file);
				return true;
			}else{
				return false;
			}
		}
		else
		{
			return false;
		}
		
	}
	catch (boost::system::system_error err)
	{

	}
}

int main(int argc, char* argv[])
{
  try
  {
	  srand( (unsigned)time( NULL ) );
	  boost::asio::io_service io_service;
	  Connection *connection = new Connection(io_service, "127.0.0.1", "1936");
	  connection->Connect();
	  int first_fetch = 1;
	  int count(0);
	  double elapsed_time;
	  time_t start_time, end_time;
	  int done = 0;
	  int countloop = 50000;
	  while(true)
	  {
		  //int random = rand() % 2 + 1;
		  //int random = boost::lexical_cast<int>(argv[1]);
		  int random = 2;
		  switch(random)
		  {
			  case 1:
				  {
					  ++count;
					  if(count == 1)
					  {
						  time(&start_time);
					  }
					  std::string message;
					  if(first_fetch)
					  {
						 message = "{\"heartbeat\":\"true\", \"first_fetch\":\"1\"}\\q\\q";
						 first_fetch = 0;
					  }
					  else
					  {
						   message = "{\"heartbeat\":\"true\", \"first_fetch\":\"0\"}\\q\\q";
					  }
					  if(connection->isConnected())
					  {
						  connection->SendData(message);
						  std::string messageReceived = connection->ReceiveData();
					  }
					  else
					  {
						  std::cout << "Seems like connection is closed\n";
					  }
					  if(count == countloop)
					  {
						  time(&end_time);
						  elapsed_time = difftime(end_time, start_time);
						  done = 1;
					  }
					  
				  }

				  break;

			  case 2:
				  {
					  ++count;
					  if(count == 1)
					  {
						  time(&start_time);
					  }
					  std::string message = "{\"message\":{\"msg\":\"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque elementum in ex et rutrum. Praesent sollicitudin lectus felis, ac faucibus ante condimentum sed. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis mattis imperdiet quam, vel elementum neque consectetur id. Nullam vehicula laoreet nisl, ac consectetur purus egestas a. Nullam ut urna eu turpis lacinia aliquam scelerisque id massa. Suspendisse vehicula neque ac arcu gravida, ac semper orci feugiat. Lorem ipsum dolor sit amet, consectetur adipiscing elit. In blandit tempor cursus. Etiam commodo a felis nec sollicitudin. Pellentesque tincidunt porttitor orci a gravida.Cras vestibulum elementum lorem, non pellentesque neque pretium a. Fusce interdum vulputate turpis, ac venenatis diam sagittis ac. Pellentesque vitae lacus quis mauris vulputate tristique. Praesent vitae volutpat purus. Aliquam eget elementum mauris, ac tincidunt dui. Donec maximus, libero ac ullamcorper imperdiet, purus enim sodales nibh, vehicula volutpat ante orci eu lectus. Phasellus porttitor leo vitae justo iaculis sodales. Aliquam lectus ligula, ullamcorper nec pretium vel, luctus in ante. Nulla congue pharetra varius.Duis pellentesque faucibus rhoncus. In hac habitasse platea dictumst. Mauris dui felis, consectetur non nisl vel, eleifend tempus elit. Proin tincidunt nisl in magna varius, non hendrerit velit finibus. Mauris pulvinar efficitur nibh, nec tincidunt nunc varius non. Sed felis enim, pharetra vitae eros at, sodales finibus lacus. Nunc dapibus neque vehicula tellus viverra, id dapibus orci ullamcorper. Ut odio diam, feugiat vel laoreet quis, fermentum eu elit. Proin et ex ac nisl interdum euismod. Aenean porta cursus purus eget dictum. Mauris finibus dui leo, id commodo diam condimentum vel. Pellentesque ut auctor dolor.Etiam pellentesque id magna nec faucibus. Aliquam id neque ex. Vestibulum lorem urna, aliquam et feugiat in, fermentum vel ante. Sed lacinia semper malesuada. Phasellus laoreet tempor lacus, a tempus libero vehicula in. Nunc gravida congue est sed hendrerit. Interdum et malesuada fames ac ante ipsum primis in faucibus. Suspendisse et quam mauris. Integer vitae finibus massa. Cras in tortor luctus, congue turpis lobortis, laoreet neque. Nullam magna justo, semper vitae eleifend eget, interdum vitae tortor.Quisque ut lectus eu erat pretium tempus. Proin vestibulum luctus purus, quis maximus tellus porta in. Sed aliquet libero sit amet metus posuere convallis. Fusce dignissim condimentum massa, nec mattis dui tempor at. Nullam non nunc convallis, vehicula enim id, euismod ligula. Nam in enim dignissim urna fringilla suscipit ac nec turpis. Mauris placerat dignissim semper. Vivamus interdum interdum fringilla. Etiam porttitor nisl velit, eget lacinia leo blandit vitae. Ut ornare mauris felis, eu posuere ligula pretium vitae. Pellentesque pharetra lectus ac lobortis placerat.Phasellus rutrum sem diam, in convallis sem lobortis a. Suspendisse leo sem, luctus quis neque nec turpis duis.\",\"extra_info\":{\"asdf\":\"dsaf\"}},\"original_length\":\"1234\"}\\q\\q";
					  connection->SendData(message);
					  std::string messageReceived = connection->ReceiveData();
					  if(count == countloop)
					  {
						  time(&end_time);
						  elapsed_time = difftime(end_time, start_time);
						  done = 1;
					  }
				  }

				  break;
			 case 3:
				  {
					  std::string message = "{\"app\":\"filesystem_collector\"}";
					  connection->DownloadFile(message);
					  
				  }

				  break;

			  default:
				  break;

		   }
		  if(done)
			  break;
	   }

	  std::cout << "Sent " << countloop << " messages in " << elapsed_time << " seconds" << std::endl;
	
  }
  catch(std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }
  std::getchar();
  return 0;
}