C++ SocketServer类代码示例

/*
 * This method has two functionalities
 * -It waits for incoming connections if local port is defined
 * -It tries to connect to remote host if local host is not defined
 */
void IPCommMonitorThread::Connect(Socket*& s)
{
	// This trickery here is because if there are no sockets (Socket::nofSockets_)
	// WSACleanup gets called and then SOAP gets messed up.
	// And creating a new socket for a new connection seems to work better
	// than using the old when re-connecting / re-listening.
	Socket* new_s = new Socket();
	delete s;
	s = new_s;

	// If local port is defined start open listening socket
	SocketServer ss;
	if( m_LocalPort )
	{
		Util::Info("[IPComm] Listen for incoming connection...");
		String remoteHost( "[IPComm] Connected! Remote host : " );
		ss.Accept( s, m_LocalPort, 1, remoteHost );
		Util::Info(remoteHost);
	}
	// If not start connecting
	else
	{
		Util::Info("[IPComm] Connecting...");
		ss.Connect( s, m_RemoteHost.c_str(), m_RemotePort );
		Util::Info("[IPComm] Connected!");
	}
}

void* SocketServer::sReadLoop(void* data){
	
	SocketServer* pthis = (SocketServer*)data;
	pthis->ReadLoop();
	
	return NULL;
}

int main ()
{
    Log l("server ");

    Registry::add("Test", new TestImpl());

    // server
    EventDriver ed;
    SocketServer srv;
    srv.start(8091, &ed);
    ed.run();
    return 0;
}

/*
 * Main Entry function
 */
int main(int argc, char** argv) {
	Order::init();

	Currency *usd = new Currency("usd");
	Currency *btc = new Currency("btc");
	Currency *ltc = new Currency("ltc");

	new Market(BTC_USD, usd, btc);
	new Market(LTC_USD, ltc, usd);
	new Market(BTC_LTC, btc, ltc);

	SocketServer *server = new SocketServer("/tmp/BitcoinTradeEngine.sock");
	server->start();
	Order::unInit();
	return 0;
}

bool
TransporterRegistry::start_service(SocketServer& socket_server)
{
  DBUG_ENTER("TransporterRegistry::start_service");
  if (m_transporter_interface.size() > 0 && !nodeIdSpecified)
  {
    g_eventLogger.error("TransporterRegistry::startReceiving: localNodeId not specified");
    DBUG_RETURN(false);
  }

  for (unsigned i= 0; i < m_transporter_interface.size(); i++)
  {
    Transporter_interface &t= m_transporter_interface[i];

    unsigned short port= (unsigned short)t.m_s_service_port;
    if(t.m_s_service_port<0)
      port= -t.m_s_service_port; // is a dynamic port
    TransporterService *transporter_service =
      new TransporterService(new SocketAuthSimple("ndbd", "ndbd passwd"));
    if(!socket_server.setup(transporter_service,
			    &port, t.m_interface))
    {
      DBUG_PRINT("info", ("Trying new port"));
      port= 0;
      if(t.m_s_service_port>0
	 || !socket_server.setup(transporter_service,
				 &port, t.m_interface))
      {
	/*
	 * If it wasn't a dynamically allocated port, or
	 * our attempts at getting a new dynamic port failed
	 */
	g_eventLogger.error("Unable to setup transporter service port: %s:%d!\n"
		 "Please check if the port is already used,\n"
		 "(perhaps the node is already running)",
		 t.m_interface ? t.m_interface : "*", t.m_s_service_port);
	delete transporter_service;
	DBUG_RETURN(false);
      }
    }
    t.m_s_service_port= (t.m_s_service_port<=0)?-port:port; // -`ve if dynamic
    DBUG_PRINT("info", ("t.m_s_service_port = %d",t.m_s_service_port));
    transporter_service->setTransporterRegistry(this);
  }
  DBUG_RETURN(true);
}

int PsCacheSetHandler::handle(PcMsg * msg , SocketServer & server , int peer)
{
  PcMsgSetReq * set = (PcMsgSetReq *)msg;
  PcMsgSetRes res;

  COMMON_LOGGER_DEBUG("set command , %s %s\n" , set->getKey().c_str() , set->getValue().c_str());

  int len = 0;

#ifndef __STORAGE_FASTDB__
  PsData * data = PsDataMgr::instance()->set(const_cast<char *>(set->getKey().c_str()) , 
  	const_cast<char *>(set->getValue().c_str()) , strlen(set->getValue().c_str()));
  if (data)
  {
    res.setCode(0); 
    res.setDesc("success");  
    res.setValue(data->value);
    len += strlen(data->value);
	len += 4;
  }
  else
  {
    res.setCode(1);
    res.setDesc("failed");
  }
#else
  bool ret = PsDataMgr::instance()->set(const_cast<char *>(set->getKey().c_str()) , 
  	const_cast<char *>(set->getValue().c_str()) , strlen(set->getValue().c_str()) , -1);
  if (ret)
  {
    res.setCode(0); 
    res.setDesc("success");  
    res.setValue(set->getValue());
    len += strlen(set->getValue().c_str());
	len += 4;
  }
  else
  {
    res.setCode(1);
    res.setDesc("failed");
  }  
#endif
  
  res.setType(PSCACHE_MSG_SET_RES);
  res.setLength(80 + len);  
  res.setVersion(msg->getVersion());
  
  PscacheMsgResParser parser;
  char * buffer = new char[80 + len];
  (void)memset(buffer , 0x00 , 80 + len);
  parser.compile(res , buffer);
    
  server.write(peer , buffer , 80 + len);

  delete [] buffer;
  
  return 0;
}

static void* serverCallback(void* arg)
{
  try
    {
      ServerData* data = static_cast<ServerData*>(arg);
      SocketServer* server = new SocketServer;
      std::string host = "127.0.0.1";
      if (!data->isServer)
	  host = "127.0.0.2";

      server->run(serverHandleCallback, host);
      delete server;
      data->serverThread->exit();
    }
  catch (ISocket::Exception& e)
    {
      std::cerr << e.what() << std::endl; 
    }

  return NULL;
}

int main(void)
{
    try
    {
        std::vector<DylThread*> vectorOfThreads;
        SocketServer servSock = SocketServer (2000);
        while (1) 
        {
            std::cout << "I am a server!" << std::endl;

            //create a new socket
            
            Socket s = servSock.Accept(); // blocking call - waits for request

            //put that new socket into a thread
            DylThread *dThr =  new DylThread(s, true);
            vectorOfThreads.push_back(dThr);

            std::cout << "hm +" << vectorOfThreads << std::endl;

          for (DylThread* i: vectorOfThreads)
              {
                std::cout << "hm " << i << std::endl;
              }

        }




    }


    // catch(...)
    catch(std::string e)
    {
        std::cout << e << " Caught unexpected exception" << std::endl;
    }
}

void Monitor::CreateSocketServer(MonitorConfiguration *config)
{
	static SocketServer socketServer(config,0) ;

	static SocketServer fms32ProServer(config,1000) ;
	fms32ProServer.m_ServerModus = SocketThread::fms32pro ;

	static SocketServer crusaderServer(config,2000) ;
	crusaderServer.m_ServerModus = SocketThread::crusader ;

	socketServer.Start() ;
	fms32ProServer.Start() ;
	crusaderServer.Start() ;
}

void Monitor::MainLoop()
{
	// Soundkarte initialisieren
	InitSndCard() ;

	/********************************************************/


	static SocketServer socketServer(&m_MonitorConfig,m_MonitorConfig.m_socketFilterFileName ,0) ;
	socketServer.Start() ;
	FILE_LOG(logINFO) << "monitord socketserver started" ;


	static SocketServer fms32ProServer(&m_MonitorConfig,m_MonitorConfig.m_socketFilterFileName ,1000) ;
	fms32ProServer.m_ServerModus=SocketThread::fms32pro ;
	fms32ProServer.Start() ;
	FILE_LOG(logINFO) << "fms32pro socketserver started" ;

	static SocketServer crusaderServer(&m_MonitorConfig,m_MonitorConfig.m_socketFilterFileName ,2000) ;
	crusaderServer.m_ServerModus=SocketThread::crusader ;
	crusaderServer.Start() ;
	FILE_LOG(logINFO) << "crusader socketserver started" ;


	/*******************************************************/

	#ifdef PLUGINS
	//GetPluginsManager().loadPlugin("plugins/.libs/libmplugin_mysql-0.dll",NULL);
	GetPluginsManager().loadScriptFilter(m_MonitorConfig.m_pluginFilterFileName) ;
	GetPluginsManager().loadPluginsFromConfigNode(&m_MonitorConfig.m_configDataPlugins);
	FILE_LOG(logDEBUG) << "PluginManager started" ;
	#endif
	/*********************************************************/

	while (!m_bWantStop)
	{
		/**
		 * Wer sich fragt, wo eigentlich denn die Arbeit gemacht wird:
		 * Die drei SocketServer sind eigenstaendige Threads. Die bedienen
		 * die TCP/IP Verbindungen und laufen unabhaegig.
		 *
		 * Die eigentliche (Ton) Auswertung erfolgt in jeweils einem Thread
		 * pro Soundkarte. Diese Threads werden im InitSndCard gestartet.
		 *
		 * Dann gibt es noch den GlobalDispatcher. Er ist auch ein eigenstaendiger
		 * Thread. Er wird von dem Auswerten mit ResultSets versorgt. Die Auswerter
		 * haben damit Ihren Teil erledigt.
		 * Der Dispatcher verteilt dann die Results an alle Sockets und Plugins (ohne die
		 * Auswerter zu blockieren)
		 *
		 */

		usleep(100);
		// Wie man sieht: hier gibt es im Moment nichts zu tun :-
	}

	FILE_LOG(logINFO) << PACKAGE_NAME << " shutting down..."  ;
	StopSndCard() ;

	FILE_LOG(logINFO) << "stopping socketserver monitord";
	socketServer.m_bWantStop=true ;
	FILE_LOG(logINFO) << "stopping socketserver FMS32";
	fms32ProServer.m_bWantStop=true ;
	FILE_LOG(logINFO) << "stopping socketserver Crusader";
	crusaderServer.m_bWantStop=true ;

	usleep(1000) ;
	m_SignalStopped->SetSignal() ;
	usleep(500) ;
	FILE_LOG(logINFO) << "all done. " << PACKAGE_NAME << " exiting";
}

void* SocketServer::acceptHandler(void* param)
{
	SocketServer* instance = (SocketServer*)param;

	instance->doAcceptLoop();
}

void* SocketServer::readHandler(void* param)
{
	SocketServer* instance = (SocketServer*)param;

	instance->doReadLoop();
}

void* 
socketServerThread_C(void* _ss){
  SocketServer * ss = (SocketServer *)_ss;
  ss->doRun();
  return 0;
}

int main(int argc, char *argv[]) 
{
	SocketServer* socketServer = new SocketServer();
	socketServer->Start(MAX_CLIENT_COUNT);
	while (getch()!=27)	{}
}

void clientThread(int clientsock)
{
    while (1) {
        if(g_server.getClient(clientsock).wantClose)
            break;
        std::string raw_buff;
        
        char buff[1024] = {0};
        if(recv(clientsock, buff, sizeof(buff), 0)<=0){
            break;
        }
        raw_buff += buff;
        
        do{
            size_t endpos = raw_buff.find("$");
            if (endpos==-1)
                break;
            const std::string msg = raw_buff.substr(0, endpos);
            raw_buff = raw_buff.substr(endpos+1);
            
            g_server.mtx.lock();
            g_server.ondata(clientsock, msg);
            g_server.mtx.unlock();
        }while(1);
    }
    g_server.rmClient(clientsock);
}