CWebChannelServer::CWebChannelServer(const QHostAddress &anAddress, quint16 nPort, QObject *pParent)
: QObject(pParent),
m_server("King James Pure Bible Search WebChannel Server", QWebSocketServer::NonSecureMode),
m_clientWrapper(&m_server),
m_HostAddress(anAddress),
m_nHostPort(nPort)
{
m_pGeoLocater = new CWebChannelGeoLocate(this);
connect(m_pGeoLocater, SIGNAL(locationInfo(const CWebChannelClient *, const QString &, const QString &)), this, SLOT(setClientLocation(const CWebChannelClient *, const QString &, const QString &)));
// setup the QWebSocketServer
m_server.listen(anAddress, nPort);
// create the CWebChannelAdminObjects
m_pWebChannelAdminObjects = new CWebChannelAdminObjects(this);
connect(m_pWebChannelAdminObjects.data(), SIGNAL(broadcast(const QString &)), this, SLOT(sendBroadcast(const QString &)));
// Handle connections:
connect(&m_clientWrapper, SIGNAL(clientConnected(WebSocketTransport*)), this, SLOT(en_clientConnected(WebSocketTransport*)));
#ifdef IS_CONSOLE_APP
if (m_server.isListening()) {
std::cout << QString("%1 UTC : KJPBS-WebChannel (pid=%2) started on interface \"%3\" port %4\n")
.arg(QDateTime::currentDateTimeUtc().toString(Qt::ISODate))
.arg(QCoreApplication::applicationPid())
.arg(serverAddress().toString())
.arg(serverPort())
.toUtf8().data();
std::cout.flush();
}
#endif
}
int main(int argc, char** argv)
{
sWorkingThread = new SWorkingThread();
sCommunicationThread = new SCommunicationThread();
sOutputThread = new SOutputThread();
//sResourceThread = new SResourceThread();
sOutputThread->run();
sWorkingThread->run();
sCommunicationThread->run();
//sResourceThread->run();
SNetAddress serverAddress((const char*)NULL, SUtil::Host2NetInt16(10000));
SSocketServer ss(STREAM, serverAddress);
if(ss.getError() != S_NO_ERROR)
{
SLog::msg("#### server init error : %d ####\n", ss.getError());
return -1;
}
while(true)
{
SClientProp cp = ss.accept();
SLog::msg("## new client ##\n");
if(ss.getError() != S_NO_ERROR)
{
SLog::msg("## accept error ###\n");
continue;
}
SEvent* e = new SCreateClientEvent(cp.address, cp.socket);
SWorkingThreadManager::getInstance()->postEvent(NULL, e, SPostEvent::HIGH_PRIORITY);
}
}
void HttpSocket::handleNewConnection()
{
DBUG;
while (hasPendingConnections()) {
QTcpSocket *socket = nextPendingConnection();
// prevent clients from sending too much data
socket->setReadBufferSize(constMaxBuffer);
static const QLatin1String constIpV6Prefix("::ffff:");
QString peer=socket->peerAddress().toString();
QString ifaceAddress=serverAddress().toString();
const bool hostOk=peer==ifaceAddress || peer==mpdAddr || peer==(constIpV6Prefix+mpdAddr) ||
peer==QLatin1String("127.0.0.1") || peer==(constIpV6Prefix+QLatin1String("127.0.0.1"));
DBUG << "peer:" << peer << "mpd:" << mpdAddr << "iface:" << ifaceAddress << "ok:" << hostOk;
if (!hostOk) {
sendErrorResponse(socket, 400);
socket->close();
DBUG << "Not from valid host";
return;
}
connect(socket, SIGNAL(readyRead()), this, SLOT(readClient()));
connect(socket, SIGNAL(disconnected()), this, SLOT(discardClient()));
}
}
const std::string Settings::dump() const
{
std::stringstream ss;
ss << "Settings: " << std::endl;
ss << "\tusername: "******"\t address: " << serverAddress() << std::endl;
ss << "\t server?: " << (isServer() ? "true":"false") << std::endl;
ss << "\t port: " << port() << std::endl;
return ss.str();
}
QString KDSoapServer::endPoint() const {
const QHostAddress address = serverAddress();
if (address == QHostAddress::Null)
return QString();
const QString addressStr = address == QHostAddress::Any ? QString::fromLatin1("127.0.0.1") : address.toString();
return QString::fromLatin1("%1://%2:%3%4")
.arg(QString::fromLatin1((d->m_features & Ssl)?"https":"http"))
.arg(addressStr)
.arg(serverPort())
.arg(d->m_path);
}
void MoralityServer::StartServer(int myport)
{
if (this->listen(QHostAddress::Any, myport))
{
qDebug() << "Server Started... at " << serverAddress() << " and port: " << this->serverPort();
}
else
{
qDebug() << "Server did NOT start...";
}
}
void Manager::reportStatus()
{
if(tcpServer->isListening()) {
Q_EMIT statusChanged(tr("The server is running on\n\nIP: %1\nport: %2\n\n"
"%3 clients connected.")
.arg(serverAddress())
.arg(tcpServer->serverPort()).arg(clientsConnected));
} else {
Q_EMIT statusChanged(tr("Server not running."));
}
}
static QString maliitServerAddress()
{
org::maliit::Server::Address serverAddress(QStringLiteral("org.maliit.server"), QStringLiteral("/org/maliit/server/address"), QDBusConnection::sessionBus());
QString address(serverAddress.address());
// Fallback to old socket when org.maliit.server service is not available
if (address.isEmpty())
return QStringLiteral("unix:path=/tmp/meego-im-uiserver/imserver_dbus");
return address;
}
void KDSoapServer::suspend()
{
d->m_portBeforeSuspend = serverPort();
d->m_addressBeforeSuspend = serverAddress();
close();
// Disconnect connected sockets, otherwise they could still make calls
if (d->m_threadPool) {
d->m_threadPool->disconnectSockets(this);
} else if (d->m_mainThreadSocketList) {
d->m_mainThreadSocketList->disconnectAll();
}
}
Client::Client()
{
GameObjectRegistry::sInstance->RegisterCreationFunction( 'SHIP', ShipClient::StaticCreate );
GameObjectRegistry::sInstance->RegisterCreationFunction( 'COIN', TommyCoinClient::StaticCreate );
wstring destination = StringUtils::GetCommandLineArg( 1 );
wstring name = StringUtils::GetCommandLineArg( 2 );
SocketAddress serverAddress( destination );
NetworkManagerClient::StaticInit( serverAddress, name );
NetworkManagerClient::sInstance->SetDropPacketChance( 0.6f );
}
void GameScene::runLogic(float deltaTime, Game& game) {
if(game.server) {
// SERVER
cooldown -= deltaTime;
enemySpawnCooldown -= deltaTime;
enemyCooldown -= deltaTime;
difficulty += deltaTime * 30.0f;
bgMotion += deltaTime * bgSpeed;
if(bgMotion > 256.0f)
bgMotion -= 256.0f;
bgSprite->setPosition(0.0f, -600.0f + bgMotion);
shooting(deltaTime, game);
spawningEnemies(deltaTime, game);
flyEnemyPlasma(deltaTime, game);
player.runLogic(deltaTime, game);
std::string scoreString = std::to_string(score);
scoreText.setString("Score: " + scoreString);
scoreText.setFont(*game.font);
escText.setFont(*game.font);
std::string scoreString2 = std::to_string(score2);
scoreText2.setString("Score: " + scoreString2);
scoreText2.setFont(*game.font);
sf::Packet packet;
packet << player.position.x << player.position.y;
sf::IpAddress clientAddress(game.clientAddress);
game.socket->send(packet, clientAddress, game.udpPortClient);
} else {
// CLIENT
sf::Packet packet;
float x, y;
sf::IpAddress serverAddress(game.serverAddress);
game.socket->receive(packet, serverAddress, game.udpPortClient);
if(packet >> x >> y) {
player.position.x = x;
player.position.y = y;
}
}
}
void Server::start()
{
listen();
cout << "Starting server..." << endl;
cout << "note: server will shutdown automatically after an inactivity period of " << INACTIVITY_TIMEOUT / 1000 << " seconds" << endl;
//cout << " -> active threads: " << threadpool_->activeThreadCount() << endl;
cout << endl;
cout << "Server starting to listen on address " << serverAddress().toString().toStdString();
cout << " and port " << serverPort() << endl;
inactivity_timer_.start( INACTIVITY_TIMEOUT );
}
bool RpcServer::registerService(::google::protobuf::Service *service,
QHostAddress address, quint16 tcpPortNum)
{
this->service = service;
if (!listen(address, tcpPortNum))
{
qDebug("Unable to start the server on <%s>: %s",
qPrintable(address.toString()),
errorString().toAscii().constData());
return false;
}
qDebug("The server is running on %s: %d",
serverAddress().toString().toAscii().constData(),
serverPort());
return true;
}
/****************************************************************
* Purpose: Starts the server, and notifies user that it is
* listening for connections.
*
* Entry: Called after an instances of a CG_Server object is
* created.
*
* Exit: Starts the server.
****************************************************************/
void CG_Server::StartServer()
{
// Possibly use QHostAddress add("192.168.1.100"); in the future
// Tell server to listen to incoming connections on the following port
QHostAddress add("192.168.0.118");
if(!this->listen(QHostAddress(add), 9556))
{
// Could not set listener on localhost, so echo could not start server
qDebug() << "Could not start server";
}
else
{
// Listener has been set on localhost, which means the server started
qDebug() << "Chessgames server started!";
qDebug() << "Listening on: " << serverAddress().toString() << " ...\r\n";
}
}
bool LoginWidget::checkServerAddress(){
QString serverHostAddress = serverAddress();
if(serverHostAddress.isEmpty()){
QMessageBox::critical(this, tr("Error"), tr("Server Address Required!"));
localServer->close();
if(ui.groupBoxConfiguration->isHidden()){
ui.toolButtonConfig->setChecked(true);
ui.groupBoxConfiguration->setVisible(true);
}
if(!ui.comboBoxServerIP->count()){
ui.toolButtonServersManager->click();
}
return false;
}
return true;
}
void LoginWidget::verifyUser(){
if(canLogin()){
QString serverHostAddress = serverAddress();
// if(serverHostAddress.isEmpty()){
// QMessageBox::critical(this, tr("Error"), tr("Server Address Required!"));
// localServer->close();
// ui.toolButtonConfig->click();
// if(!ui.comboBoxServerIP->count()){
// ui.toolButtonServersManager->click();
// }
// return;
// }
switchUI(VERIFYING);
emit signalRequestLogin(QHostAddress(serverHostAddress), serverPort());
//QTimer::singleShot(30000, this, SLOT(loginTimeout()));
}
// Login login(user,this);
// if(canLogin() && login.isVerified()){
// //发射验证成功的消息
// emit signalUserVerified();
// qDebug()<<"----LoginWidget::verifyUser()~~User Verified!";
// return true;
// }else{
// user->setUserID("");
// user->setPassword("");
// user->setVerified(false);
// localServer->close();
// switchUI(NORMAL);
// qDebug()<<"XXXXLoginWidget::verifyUser()~~User Verify Failed!";
// }
// return false;
}
static void initializeInspectorServer()
{
#if ENABLE(INSPECTOR_SERVER)
static bool initialized = false;
if (initialized)
return;
// It should be set to true always.
// Because it is to ensure initializeInspectorServer() is executed only once,
// even if the server fails to run.
initialized = true;
String serverAddress(getenv("WEBKIT_INSPECTOR_SERVER"));
if (!serverAddress.isNull()) {
String bindAddress = ASCIILiteral("127.0.0.1");
unsigned short port = 2999;
Vector<String> result;
serverAddress.split(':', result);
if (result.size() == 2) {
bindAddress = result[0];
bool ok = false;
port = result[1].toUInt(&ok);
if (!ok) {
port = 2999;
LOG_ERROR("Couldn't parse the port. Using 2999 instead.");
}
} else
LOG_ERROR("Couldn't parse %s, wrong format? Using 127.0.0.1:2999 instead.", serverAddress.utf8().data());
if (!WebInspectorServer::shared().listen(bindAddress, port))
LOG_ERROR("Couldn't start listening on: IP address=%s, port=%d.", bindAddress.utf8().data(), port);
return;
}
LOG(InspectorServer, "To start inspector server set WEBKIT_INSPECTOR_SERVER to 127.0.0.1:2999 for example.");
#endif
}
int main(int argc, char** argv)
{
Poco::Net::SocketAddress serverAddress("127.0.0.1:36911");
GameMessageHandler handler;
const int client_count = 100;
g_tcpClient = new TcpClient(handler);
try
{
std::cout << "starting.." << std::endl;
for (int i = 0; i < 1; i++)
{
g_tcpClient->connect(serverAddress);
Protocol::CSRegisterReq registerRequest;
registerRequest.username = "******";
registerRequest.password = "******";
g_tcpClient->sendMessage(Opcodes::CSRegisterReq, registerRequest);
Protocol::CSLoginReq loginRequest;
loginRequest.account = "*****@*****.**";
loginRequest.password = "******";
g_tcpClient->sendMessage(Opcodes::CSLoginReq, loginRequest);
}
std::cout << "finished." << std::endl;
}
catch (const Poco::Exception& e)
{
std::cout << e.displayText() << std::endl;
}
getchar();
delete g_tcpClient;
return 0;
}
static void initInspectorServer()
{
#if ENABLE(INSPECTOR_SERVER)
static bool initialized = false;
if (initialized)
return;
initialized = true;
String serverAddress(g_getenv("WEBKIT_INSPECTOR_SERVER"));
if (!serverAddress.isNull()) {
String bindAddress = "127.0.0.1";
unsigned short port = 2999;
Vector<String> result;
serverAddress.split(":", result);
if (result.size() == 2) {
bindAddress = result[0];
bool ok = false;
port = result[1].toInt(&ok);
if (!ok) {
port = 2999;
LOG_ERROR("Couldn't parse the port. Use 2999 instead.");
}
} else
LOG_ERROR("Couldn't parse %s, wrong format? Use 127.0.0.1:2999 instead.", serverAddress.utf8().data());
if (!WebInspectorServer::shared().listen(bindAddress, port))
LOG_ERROR("Couldn't start listening on: IP address=%s, port=%d.", bindAddress.utf8().data(), port);
return;
}
LOG(InspectorServer, "To start inspector server set WEBKIT_INSPECTOR_SERVER to 127.0.0.1:2999 for example.");
#endif
}
//loop through command line arguments and extract settings
void Settings::parse(const int argc, const char** argv)
{
bool hasUserName = false; //assume user hasn't entered a username
//loops through arguments, reads in each argument and decides what to do with it
for(int ii = 0; ii < argc; ++ii)
{
std::string arg(argv[ii]);
if (arg[0] != '-')
{
continue; //not a switch, skip it
}
if(arg.find("-username="******"-address=") == 0) //are we setting a server IP?
{
std::string address(getArgValue(arg));
try
{
(void)serverAddress(address); //set and validate requested server address
}
catch (BeeChatException bce)
{
throw; //rethrow the same exception
}
}
else if(arg.find("-server") == 0)
{
(void)isServer(true); //request to bee a server
}
else if(arg.find("-port=") == 0)
{
std::string portStr(getArgValue(arg));
try
{
(void)port((unsigned short)atoi(portStr.c_str())); //set and validate requested port
}
catch(BeeChatException e)
{
std::stringstream ss;
ss << "Could not set port: " << e.type() << ":" << e.message();
throw BeeChatException(eET_invalid_port, ss.str());
}
}
else
{
std::stringstream ss;
ss << "Unknown argument: " << arg;
throw BeeChatException(eET_unknown_arg, ss.str());
}
}
if(!hasUserName)
{
throw BeeChatException(eET_empty_username, "No username supplied");
}
}
int main(int argc, char ** argv)
{
int status = EXIT_FAILURE;
try
{
avatar::AppEnvironment env(argc, argv);
avatar::cmdline_utils::Parser cmdlineParser;
std::unique_ptr<avatar::RiftApp> app;
auto cmdlineParserResult = cmdlineParser.parseOptions();
switch (cmdlineParserResult.first)
{
case avatar::cmdline_utils::Parser::Status::LaunchColorCubeDemo:
{
std::wcout << L"Info >> description: launching color cube demo" << std::endl;
app.reset(new avatar::ColorCubeApp);
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchTextureCubeDemo:
{
std::wcout << L"Info >> description: launching texture cube demo" << std::endl;
app.reset(new avatar::TexCubeApp);
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchMonoWebcamDemo:
{
std::wcout << L"Info >> description: launching mono webcam demo" << std::endl;
app.reset(new avatar::WebcamMonoApp);
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchStereoWebcamDemo:
{
std::wcout << L"Info >> description: launching stereo webcam demo" << std::endl;
app.reset(new avatar::WebcamStereoApp);
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchClientDemo:
{
QString const serverAddressString = cmdlineParser.value(avatar::cmdline_utils::launchClientDemo);
QHostAddress serverAddress(serverAddressString);
std::wcout << L"Info >> description: launching client demo with server IP address " << serverAddressString.toStdWString() << std::endl;
app.reset(new avatar::VideoStreamClientApp(serverAddress));
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchServerDemo:
{
std::wcout << L"Info >> description: launching server demo" << std::endl;
app.reset(new avatar::VideoStreamServerApp);
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchFirstPersonViewDemo:
{
std::wcout << L"Info >> description: launching FPV demo" << std::endl;
//
// Find arduino serial port.
//
QList<QSerialPortInfo> const ports = QSerialPortInfo::availablePorts();
QList<QSerialPortInfo>::const_iterator arduinoPort = ports.cend();
for (auto it = ports.cbegin(); it != ports.cend(); ++it)
{
QString const description = it->description();
if (description.contains("arduino", Qt::CaseInsensitive))
{
arduinoPort = it;
break;
}
}
if (arduinoPort == ports.cend())
{
std::wcout << L"Error >> description: failed to find arduino serial port" << std::endl;
return EXIT_FAILURE;
}
//
// Find a webcam.
//
auto const cameras = QCameraInfo::availableCameras();
if (cameras.empty())
{
std::wcout << L"Error >> description: failed to find webcam devices" << std::endl;
return EXIT_FAILURE;
}
//
// Setup both the interpreter for the arduino port and the camera.
//
auto commandInterpreter = avatar::FirstPersonViewSerialCli::create(*arduinoPort, QSerialPort::Baud115200, QByteArray("Servo>"), 50);
auto imageSystem = avatar::ImageSystem::create(std::make_unique<avatar::WebcamImageReader>(cameras[0]), std::make_unique<avatar::WebcamImageProcessor>());
app.reset(new avatar::FirstPersonViewApp(std::move(commandInterpreter), std::move(imageSystem)));
}
break;
case avatar::cmdline_utils::Parser::Status::ShowHelp:
{
cmdlineParser.showHelp(EXIT_SUCCESS); // showHelp() will exit the application
}
break;
case avatar::cmdline_utils::Parser::Status::Error:
{
std::wcout << cmdlineParserResult.second.toStdWString() << std::endl;
cmdlineParser.showHelp(EXIT_FAILURE); // showHelp() will exit the application
}
break;
default:
{
Q_ASSERT(false);
cmdlineParser.showHelp(EXIT_FAILURE); // showHelp() will exit the application
}
}
app->show();
status = env.exec();
}
catch (avatar::Exception const & e)
{
std::wcout << e.what().toStdWString() << std::endl;
}
return status;
}
bool MyApp::OnInit()
{
gAppHandler = this;
wxString sFullModleName = ::wxGetFullModuleName();
wxString sAppName = this->GetAppName();
size_t nFind = sFullModleName.rfind(sAppName);
gAppPath = sFullModleName.substr(0, nFind-1).c_str();
setAutorun(BIWOO_NAME.c_str(), sFullModleName.c_str());
wxString xmlFile(gAppPath);
xmlFile.Append(wxT("/default/setting.xml"));
gSetting.load(xmlFile.c_str());
setlocale(LC_ALL, gSetting.locale().c_str());
//setlocale(LC_ALL,"Chinese-simplified");
//std::locale::global(std::locale("Chinese-simplified"));
CCgcAddress serverAddress(gSetting.address(), CCgcAddress::ST_UDP);
if (!m_biwoo.start(serverAddress, (CbiwooHandler*)this))
{
//m_biwoo.stop();
//return false;
}
xmlFile = gAppPath.c_str();
xmlFile.Append(wxT("/default/"));
xmlFile.Append(gSetting.langtext());
gLangText.load(xmlFile.c_str());
/////////////////////////////////////
// test
//CDlgSetting dlgSetting(NULL);
//dlgSetting.ShowModal();
if ( !wxApp::OnInit() )
{
m_biwoo.stop();
return false;
}
CDlglogin dlgLogin(NULL, false);
int ret = dlgLogin.ShowModal();
if (ret != wxID_OK)
{
m_biwoo.stop();
wxApp::OnExit();
return false;
}
gMyAccount = dlgLogin.accountInfo();
BOOST_ASSERT (gMyAccount.get() != 0);
// create the main application window
MyFrame * frame = new MyFrame(_T("BIWOO App"), wxSize(700, 450));
m_biwoo.setHandler(gAppHandler);
m_biwoo.accountLoad();
wxString title = wxString::Format("%s - %s(%s)", BIWOO_NAME.c_str(), gMyAccount->getUserinfo()->getUserName().c_str(), gMyAccount->getUserinfo()->getAccount().c_str());
frame->SetTitle(title);
frame->setTaskBarIcon(wxT("mainframe.ico"), title);
#if defined(__WXMOTIF__)
int width, height;
frame->GetSize(& width, & height);
frame->SetSize(wxDefaultCoord, wxDefaultCoord, width, height);
#endif
// and show it (the frames, unlike simple controls, are not shown when
// created initially)
frame->SetMinSize(wxSize(700, 450));
frame->Show(true);
//SetTopWindow(frame);
// success: wxApp::OnRun() will be called which will enter the main message
// loop and the application will run. If we returned false here, the
// application would exit immediately.
return true;
}
int main(int argc, char **argv)
{
ESFUInt16 multiplexerCount = 4;
const char *dottedIp = "127.0.0.1";
ESFUInt16 port = 8080;
ESFInt16 sockets = 1;
bool reuseConnections = false;
int logLevel = ESFLogger::Notice;
{
int result = 0;
while (true)
{
result = getopt(argc, argv, "l:m:a:p:s:r");
if (0 > result)
{
break;
}
switch (result)
{
case 'l':
/*
None = 0,
Emergency = 1, System-wide non-recoverable error.
Alert = 2, System-wide non-recoverable error imminent.
Critical = 3, System-wide potentially recoverable error.
Error = 4, Localized non-recoverable error.
Warning = 5, Localized potentially recoverable error.
Notice = 6, Important non-error event.
Info = 7, Non-error event.
Debug = 8 Debugging event.
*/
logLevel = atoi(optarg);
break;
case 'm':
multiplexerCount = atoi(optarg);
break;
case 'a':
dottedIp = optarg;
break;
case 'p':
port = atoi(optarg);
break;
case 's':
sockets = atoi(optarg);
break;
case 'r':
reuseConnections = true;
break;
default:
printHelp();
return 2;
}
}
}
ESFConsoleLogger::Initialize((ESFLogger::Severity) logLevel);
ESFLogger *logger = ESFConsoleLogger::Instance();
if (logger->isLoggable(ESFLogger::Notice))
{
logger->log(ESFLogger::Notice, __FILE__, __LINE__,
"[main] starting. logLevel: %d, threads: %d, server: %s, port: %d, sockets: %d, reuseConnections: %s",
logLevel, multiplexerCount, dottedIp, port, sockets, reuseConnections ? "true" : "false");
}
AWSClientSocket::SetReuseConnections(reuseConnections);
ESFSocketAddress serverAddress( dottedIp, port, ESFSocketAddress::TCP );
//
// Install signal handlers
//
signal(SIGHUP, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, AWSRawEchoClientSignalHandler);
signal(SIGQUIT, AWSRawEchoClientSignalHandler);
signal(SIGTERM, AWSRawEchoClientSignalHandler);
ESFDiscardAllocator discardAllocator(4000, ESFSystemAllocator::GetInstance());
ESFSharedAllocator rootAllocator(&discardAllocator);
ESFAllocatorCleanupHandler rootAllocatorCleanupHandler(&rootAllocator);
ESFError error = rootAllocator.initialize();
if (ESF_SUCCESS != error)
{
if (logger->isLoggable(ESFLogger::Critical))
{
char buffer[100];
ESFDescribeError(error, buffer, sizeof(buffer));
logger->log(ESFLogger::Critical, __FILE__, __LINE__,
"[main] Cannot initialize root allocator: %s", buffer);
}
return error;
}
ESFEpollMultiplexerFactory epollFactory("EpollMultiplexer",
logger,
&rootAllocator);
ESFUInt16 maxSockets = ESFSocketMultiplexerDispatcher::GetMaximumSockets();
if (sockets > maxSockets)
{
if (logger->isLoggable(ESFLogger::Critical))
{
logger->log(ESFLogger::Critical, __FILE__, __LINE__,
"Raise ulimit -n, only %d sockets can be created\n", maxSockets);
}
return 1;
}
if (logger->isLoggable(ESFLogger::Notice))
{
logger->log(ESFLogger::Notice, __FILE__, __LINE__,
"[main] Maximum sockets %d", maxSockets);
}
ESFSocketMultiplexerDispatcher dispatcher(maxSockets,
multiplexerCount,
&epollFactory,
&rootAllocator,
"EpollDispatcher",
logger);
error = dispatcher.start();
if (ESF_SUCCESS != error)
{
if (logger->isLoggable(ESFLogger::Critical))
{
char buffer[100];
ESFDescribeError(error, buffer, sizeof(buffer));
logger->log(ESFLogger::Critical, __FILE__, __LINE__,
"[main] Cannot start multiplexer dispatcher: %s", buffer);
}
return error;
}
AWSClientSocketFactory factory(maxSockets,
&SuccessCounter,
&dispatcher,
logger);
sleep(1); // give the worker threads a chance to start - cleans up perf testing numbers a bit
struct timeval startTime;
AWSPerformanceCounter::GetTime(&startTime);
for (int i = 0; i < sockets; ++i)
{
error = factory.addNewConnection(serverAddress);
if (ESF_SUCCESS != error)
{
if (logger->isLoggable(ESFLogger::Critical))
{
char buffer[100];
ESFDescribeError(error, buffer, sizeof(buffer));
logger->log(ESFLogger::Critical, __FILE__, __LINE__,
"[main] Cannot add new connection: %s", buffer);
}
return error;
}
}
if (logger->isLoggable(ESFLogger::Notice))
{
logger->log(ESFLogger::Notice, __FILE__, __LINE__, "[main] started");
}
while (IsRunning)
{
sleep(60);
}
if (logger->isLoggable(ESFLogger::Notice))
{
logger->log(ESFLogger::Notice, __FILE__, __LINE__, "[main] stopping");
}
dispatcher.stop();
if (logger->isLoggable(ESFLogger::Notice))
{
logger->log(ESFLogger::Notice, __FILE__, __LINE__, "[main] stopped");
}
ESFConsoleLogger::Destroy();
ESFUInt32 seconds = StopTime.tv_sec - startTime.tv_sec;
ESFUInt32 microseconds = 0;
if (StopTime.tv_usec < startTime.tv_usec)
{
--seconds;
microseconds = StopTime.tv_usec - (ESF_UINT32_C(1000000) - startTime.tv_usec);
}
else
{
microseconds = StopTime.tv_usec - startTime.tv_usec;
}
SuccessCounter.printSummary();
fprintf(stdout, "\tTotal Sec: %u.%u\n", seconds, microseconds);
return ESF_SUCCESS;
}
void LoginWidget::updateUserLoginServerInfo(){
qDebug()<<"--LoginWidget::updateUserLoginServerInfo() serverAddress:"<<serverAddress();
user->setLoginServerAddress(serverAddress());
user->setLoginServerPort(serverPort());
}
int main(int argc, char** argv) {
if (argc != 3 && argc != 5 && argc != 6) {
cout << VERSION << endl;
cout << "USAGE FOR STANDALONE: qsspn qsspn_file ctrl_file" << endl;
cout << "USAGE FOR SERVER: qsspn qsspn_file ctrl_file address port cache_size" << endl;
cout << "USAGE FOR CLIENT: qsspn qsspn_file ctrl_file address port" << endl;
cout << "The qsspn_file file with extension .json is read as Json file" << endl;
cout << "The qsspn file without .json extension is assumed to be in old qsspn format" << endl;
cout << "Example cache size is 100000000" << endl;
exit(1);
}
if (argc == 3) {//standalone
PetriNet *pn = new PetriNet();
string path(argv[1]);
string path1(argv[2]);
if (isJason(path)) {
pn->readModel(path);
} else {
pn->readPetriNet(path);
}
pn->runWorkflowStandalone(path1);
exit(0);
} else if (argc == 5) {//client
PetriNet *pn = new PetriNet();
string path(argv[1]);
string path1(argv[2]);
string serverAddress(argv[3]);
string serverPort(argv[4]);
if (isJason(path)) {
pn->readModel(path);
} else {
pn->readPetriNet(path);
}
pn->runWorkflowClient(path1, serverAddress, serverPort);
exit(0);
} else try {//server
string path(argv[1]);
string path1(argv[2]);
string address(argv[3]);
string port(argv[4]);
int cache_size = atoi(argv[5]);
Cache *cache = new Cache(cache_size);
PetriNet *pn = new PetriNet();
if (isJason(path)) {
pn->readModel(path);
} else {
pn->readPetriNet(path);
}
fstream infile;
string word;
vector<string> text;
infile.open(path1.c_str());
if (!infile) {
cerr << "Could not open file:" << path1 << endl;
exit(0);
}
while (infile >> word) text.push_back(word);
infile.close();
asio::io_service io_service;
MetabolismServer server(address, port, io_service, 1, pn, cache, text);
server.run();
delete pn;
delete cache;
} catch (std::exception& e) {
std::cerr << "Error: " << e.what() << std::endl;
return 1;
}
return 0;
}
void HttpSocket::readClient()
{
if (terminated) {
return;
}
QTcpSocket *socket = static_cast<QTcpSocket *>(sender());
if (socket->canReadLine()) {
QList<QByteArray> tokens = split(socket->readLine()); // QRegExp("[ \r\n][ \r\n]*"));
if (tokens.length()>=2 && "GET"==tokens[0]) {
QStringList params = QString(socket->readAll()).split(QRegExp("[\r\n][\r\n]*"));
DBUG << "params" << params << "tokens" << tokens;
if (!isFromMpd(params)) {
sendErrorResponse(socket, 400);
socket->close();
DBUG << "Not from MPD";
return;
}
QString peer=socket->peerAddress().toString();
QString ifaceAddress=serverAddress().toString();
bool hostOk=peer==ifaceAddress || peer==mpdAddr || peer==QLatin1String("127.0.0.1");
DBUG << "peer:" << peer << "mpd:" << mpdAddr << "iface:" << ifaceAddress << "ok:" << hostOk;
if (!hostOk) {
sendErrorResponse(socket, 400);
socket->close();
DBUG << "Not from valid host";
return;
}
QUrl url(QUrl::fromEncoded(tokens[1]));
#if QT_VERSION < 0x050000
QUrl &q=url;
#else
QUrlQuery q(url);
#endif
bool ok=false;
qint32 readBytesFrom=0;
qint32 readBytesTo=0;
getRange(params, readBytesFrom, readBytesTo);
DBUG << "readBytesFrom" << readBytesFrom << "readBytesTo" << readBytesTo;
if (q.hasQueryItem("cantata")) {
Song song=HttpServer::self()->decodeUrl(url);
if (!isCantataStream(song.file)) {
sendErrorResponse(socket, 400);
socket->close();
DBUG << "Not cantata stream file";
return;
}
if (song.isCdda()) {
#if defined CDDB_FOUND || defined MUSICBRAINZ5_FOUND
QStringList parts=song.file.split("/", QString::SkipEmptyParts);
if (parts.length()>=3) {
QString dev=QLatin1Char('/')+parts.at(1)+QLatin1Char('/')+parts.at(2);
CdParanoia cdparanoia(dev, false, false, true);
if (cdparanoia) {
int firstSector = cdparanoia.firstSectorOfTrack(song.id);
int lastSector = cdparanoia.lastSectorOfTrack(song.id);
qint32 totalSize = ((lastSector-firstSector)+1)*CD_FRAMESIZE_RAW;
int count = 0;
bool writeHeader=0==readBytesFrom; // Only write header if we are not seeking...
// int bytesToDiscard = 0; // Number of bytes to discard in first read sector due to range request in HTTP header
// if (readBytesFrom>=ExtractJob::constWavHeaderSize) {
// readBytesFrom-=ExtractJob::constWavHeaderSize;
// }
// if (readBytesFrom>0) {
// int sectorsToSeek=readBytesFrom/CD_FRAMESIZE_RAW;
// firstSector+=sectorsToSeek;
// bytesToDiscard=readBytesFrom-(sectorsToSeek*CD_FRAMESIZE_RAW);
// }
cdparanoia.seek(firstSector, SEEK_SET);
ok=true;
writeMimeType(QLatin1String("audio/x-wav"), socket, readBytesFrom, totalSize+ExtractJob::constWavHeaderSize, false);
if (writeHeader) {
ExtractJob::writeWavHeader(*socket, totalSize);
}
bool stop=false;
while (!terminated && (firstSector+count) <= lastSector && !stop) {
qint16 *buf = cdparanoia.read();
if (!buf) {
break;
}
char *buffer=(char *)buf;
qint32 writePos=0;
qint32 toWrite=CD_FRAMESIZE_RAW;
// if (bytesToDiscard>0) {
// int toSkip=qMin(toWrite, bytesToDiscard);
// writePos=toSkip;
// toWrite-=toSkip;
// bytesToDiscard-=toSkip;
// }
if (toWrite>0 && !write(socket, &buffer[writePos], toWrite, stop)) {
break;
}
count++;
}
}
}
#endif
} else if (!song.file.isEmpty()) {
#ifdef Q_OS_WIN
if (tokens[1].startsWith("//") && !song.file.startsWith(QLatin1String("//")) && !QFile::exists(song.file)) {
QString share=QLatin1String("//")+url.host()+song.file;
if (QFile::exists(share)) {
song.file=share;
DBUG << "fixed share-path" << song.file;
}
}
#endif
QFile f(song.file);
if (f.open(QIODevice::ReadOnly)) {
qint32 totalBytes = f.size();
writeMimeType(detectMimeType(song.file), socket, readBytesFrom, totalBytes, true);
ok=true;
qint32 readPos = 0;
qint32 bytesRead = 0;
if (0!=readBytesFrom) {
if (!f.seek(readBytesFrom)) {
ok=false;
}
bytesRead+=readBytesFrom;
}
if (0!=readBytesTo && readBytesTo>readBytesFrom && readBytesTo!=totalBytes) {
totalBytes-=(totalBytes-readBytesTo);
}
if (ok) {
static const int constChunkSize=32768;
char buffer[constChunkSize];
bool stop=false;
do {
bytesRead = f.read(buffer, constChunkSize);
readPos+=bytesRead;
if (!write(socket, buffer, bytesRead, stop) || f.atEnd()) {
break;
}
} while (readPos<totalBytes && !stop && !terminated);
}
} else {
DBUG << "Filed to open" << song.file;
}
}
}
if (!ok) {
sendErrorResponse(socket, 404);
}
socket->close();
if (QTcpSocket::UnconnectedState==socket->state()) {
delete socket;
}
}
}
}
// Virtual functions
void NtpTest::Run( std::ostream & p_Trace )
{
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Starting NTP test." << std::endl;
// Open a ntp client
Bit::Ntp ntp( 0, 123 );
// Assert a ntp header
Bit::Ntp::Header header1( Bit::Ntp::Header::NoWarning, 4, Bit::Ntp::Header::Client );
TestAssert( header1.GetLeapIndicator( ) == Bit::Ntp::Header::NoWarning );
TestAssert( header1.GetVersion( ) == 4 );
TestAssert( header1.GetMode( ) == Bit::Ntp::Header::Client );
// Assert the ntp set and get functions
Bit::Ntp::Header header2;
header2.SetLeapIndicator( Bit::Ntp::Header::Remove );
header2.SetVersion( 5 );
header2.SetMode( Bit::Ntp::Header::Server );
TestAssert( header2.GetLeapIndicator( ) == Bit::Ntp::Header::Remove );
TestAssert( header2.GetVersion( ) == 5 );
TestAssert( header2.GetMode( ) == Bit::Ntp::Header::Server );
// Send request to NTP server
Bit::Address serverAddress( "0.europe.pool.ntp.org" );
ntp.SendRequest( header1, serverAddress );
std::cout << "Sent request." << std::endl;
// Assert Receive response from NTP server
Bit::Ntp::Header header3( Bit::Ntp::Header::NoWarning, 4, Bit::Ntp::Header::Client );
TestAssert( ntp.ReceiveResponse( header3, serverAddress ) == true );
std::cout << "Received response:" << std::endl;
// Print the response
std::cout << " Leap: " << (Bit::Uint32)header3.GetLeapIndicator( ) << std::endl;
std::cout << " Version: " << (Bit::Uint32)header3.GetVersion( ) << std::endl;
std::cout << " Mode: " << (Bit::Uint32)header3.GetMode( ) << std::endl;
std::cout << " Stratum: " << (Bit::Uint32)header3.GetStratum( ) << std::endl;
std::cout << " Polling interval: " << (Bit::Uint32)header3.GetPollInterval( ) << std::endl;
std::cout << " Precision: " << (Bit::Uint32)header3.GetPrecision( ) << std::endl;
std::cout << " Root delay: " << header3.GetRootDelay( ) << std::endl;
std::cout << " Root dispersion: " << header3.GetRootDispersion( ) << std::endl;
Bit::Address address( header3.GetReferenceClock( ) );
std::cout << " Referense address: " << (int)address.GetA( ) << "."
<< (int)address.GetB( ) << "."
<< (int)address.GetC( ) << "."
<< (int)address.GetD( ) << std::endl;
std::cout << std::endl;
std::cout << " Reference time : " << header3.GetReferenceTimestamp( ).GetTimeString( )
<< " (" << static_cast<Bit::Float64>( header3.GetReferenceTimestamp( ).GetFractions( ) ) / static_cast<Bit::Float64>( 0xFFFFFFFF ) << ")" << std::endl;
std::cout << " Reference local time : " << header3.GetTransmitTimestamp( ).GetLocalTimeString( )
<< " (" << static_cast<Bit::Float64>( header3.GetReferenceTimestamp( ).GetFractions( ) ) / static_cast<Bit::Float64>( 0xFFFFFFFF ) << ")" << std::endl;
std::cout << std::endl;
std::cout << " Origin time : " << header3.GetOriginateTimestamp( ).GetTimeString( )
<< " (" << static_cast<Bit::Float64>( header3.GetOriginateTimestamp( ).GetFractions( ) ) / static_cast<Bit::Float64>( 0xFFFFFFFF ) << ")" << std::endl;
std::cout << " Origin local time : " << header3.GetOriginateTimestamp( ).GetLocalTimeString( )
<< " (" << static_cast<Bit::Float64>( header3.GetOriginateTimestamp( ).GetFractions( ) ) / static_cast<Bit::Float64>( 0xFFFFFFFF ) << ")" << std::endl;
std::cout << std::endl;
std::cout << " Receive time : " << header3.GetReceiveTimestamp( ).GetTimeString( )
<< " (" << static_cast<Bit::Float64>( header3.GetReceiveTimestamp( ).GetFractions( ) ) / static_cast<Bit::Float64>( 0xFFFFFFFF ) << ")" << std::endl;
std::cout << " Receive local time : " << header3.GetReceiveTimestamp( ).GetLocalTimeString( )
<< " (" << static_cast<Bit::Float64>( header3.GetReceiveTimestamp( ).GetFractions( ) ) / static_cast<Bit::Float64>( 0xFFFFFFFF ) << ")" << std::endl;
std::cout << std::endl;
std::cout << " Transmit time : " << header3.GetTransmitTimestamp( ).GetTimeString( )
<< " (" << static_cast<Bit::Float64>( header3.GetTransmitTimestamp( ).GetFractions( ) ) / static_cast<Bit::Float64>( 0xFFFFFFFF ) << ")" << std::endl;
std::cout << " Transmit local time : " << header3.GetTransmitTimestamp( ).GetLocalTimeString( )
<< " (" << static_cast<Bit::Float64>( header3.GetTransmitTimestamp( ).GetFractions( ) ) / static_cast<Bit::Float64>( 0xFFFFFFFF ) << ")" << std::endl;
std::cout << std::endl;
// Close the ntp client
ntp.Close( );
// Print the finish text
std::cout << "Finished NTP Test." << std::endl;
std::cout << "-------------------------------------------" << std::endl;
}
void connectToServer(const std::string& address) {
NetAddress serverAddress(address + format(":%d", PORT));
m_conversationArray.append(shared_ptr<Conversation>(new Conversation(this, NetConnection::connectToServer(serverAddress))));
}
int ClientServerMain()
{
LocalMatcher matcher;
uint64_t clientId = 1;
uint8_t connectTokenData[ConnectTokenBytes];
uint8_t connectTokenNonce[NonceBytes];
uint8_t clientToServerKey[KeyBytes];
uint8_t serverToClientKey[KeyBytes];
int numServerAddresses;
Address serverAddresses[MaxServersPerConnectToken];
memset( connectTokenNonce, 0, NonceBytes );
if ( !matcher.RequestMatch( clientId, connectTokenData, connectTokenNonce, clientToServerKey, serverToClientKey, numServerAddresses, serverAddresses ) )
{
printf( "error: request match failed\n" );
return 1;
}
ClientServerPacketFactory packetFactory;
Address clientAddress( "::1", ClientPort );
Address serverAddress( "::1", ServerPort );
GameNetworkTransport clientTransport( packetFactory, clientAddress );
GameNetworkTransport serverTransport( packetFactory, serverAddress );
if ( clientTransport.GetError() != SOCKET_ERROR_NONE || serverTransport.GetError() != SOCKET_ERROR_NONE )
{
printf( "error: failed to initialize sockets\n" );
return 1;
}
const int NumIterations = 20;
double time = 0.0;
GameClient client( GetDefaultAllocator(), clientTransport );
GameServer server( GetDefaultAllocator(), serverTransport );
server.SetServerAddress( serverAddress );
server.Start();
client.Connect( serverAddress, connectTokenData, connectTokenNonce, clientToServerKey, serverToClientKey );
for ( int i = 0; i < NumIterations; ++i )
{
client.SendPackets();
server.SendPackets();
clientTransport.WritePackets();
serverTransport.WritePackets();
clientTransport.ReadPackets();
serverTransport.ReadPackets();
client.ReceivePackets();
server.ReceivePackets();
client.CheckForTimeOut();
server.CheckForTimeOut();
if ( client.ConnectionFailed() )
{
printf( "error: client connect failed!\n" );
break;
}
if ( client.IsConnected() && server.GetNumConnectedClients() == 1 )
client.Disconnect();
time += 0.1f;
if ( !client.IsConnecting() && !client.IsConnected() && server.GetNumConnectedClients() == 0 )
break;
client.AdvanceTime( time );
server.AdvanceTime( time );
clientTransport.AdvanceTime( time );
serverTransport.AdvanceTime( time );
}
client.Disconnect();
server.Stop();
return 0;
}
int main(int argc, char ** argv)
{
int status = EXIT_FAILURE;
try
{
avatar::AppEnvironment env(argc, argv);
avatar::cmdline_utils::Parser cmdlineParser;
std::unique_ptr<avatar::RiftApp> app;
auto cmdlineParserResult = cmdlineParser.parseOptions();
switch (cmdlineParserResult.first)
{
case avatar::cmdline_utils::Parser::Status::LaunchColorCubeDemo:
{
std::wcout << L"Info >> description: launching color cube demo" << std::endl;
app.reset(new avatar::ColorCubeApp);
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchTextureCubeDemo:
{
std::wcout << L"Info >> description: launching texture cube demo" << std::endl;
app.reset(new avatar::TexCubeApp);
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchMonoWebcamDemo:
{
std::wcout << L"Info >> description: launching mono webcam demo" << std::endl;
app.reset(new avatar::WebcamMonoApp);
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchStereoWebcamDemo:
{
std::wcout << L"Info >> description: launching stereo webcam demo" << std::endl;
app.reset(new avatar::WebcamStereoApp);
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchClientDemo:
{
QString const serverAddressString = cmdlineParser.value(avatar::cmdline_utils::launchClientDemo);
QHostAddress serverAddress(serverAddressString);
std::wcout << L"Info >> description: launching client demo with server IP address " << serverAddressString.toStdWString() << std::endl;
app.reset(new avatar::VideoStreamClientApp(serverAddress));
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchServerDemo:
{
std::wcout << L"Info >> description: launching server demo" << std::endl;
app.reset(new avatar::VideoStreamServerApp);
}
break;
case avatar::cmdline_utils::Parser::Status::LaunchFirstPersonViewDemo:
{
std::wcout << L"Info >> description: launching FPV demo" << std::endl;
app.reset(new avatar::FirstPersonViewApp());
}
break;
case avatar::cmdline_utils::Parser::Status::ShowHelp:
{
cmdlineParser.showHelp(EXIT_SUCCESS); // showHelp() will exit the application
}
break;
case avatar::cmdline_utils::Parser::Status::Error:
{
std::wcout << cmdlineParserResult.second.toStdWString() << std::endl;
cmdlineParser.showHelp(EXIT_FAILURE); // showHelp() will exit the application
}
break;
default:
{
Q_ASSERT(false);
cmdlineParser.showHelp(EXIT_FAILURE); // showHelp() will exit the application
}
}
app->show();
status = env.exec();
}
catch (avatar::Exception const & e)
{
std::wcout << e.what().toStdWString() << std::endl;
}
return status;
}