int main(int argc, char* argv[])
{
ngrest::ElapsedTimer timer(true);
ngrest::StringMap args;
for (int i = 1; i < argc; i += 2) {
if (argv[i][0] != '-' || argv[i][1] == '\0' || (i + 1) == argc) {
return help();
}
args[argv[i] + 1] = argv[i + 1];
}
static ngrest::Server server;
ngrest::ServiceDispatcher dispatcher;
ngrest::Deployment deployment(dispatcher);
ngrest::HttpTransport transport;
ngrest::Engine engine(dispatcher);
ngrest::ClientHandler clientHandler(engine, transport);
server.setClientCallback(&clientHandler);
if (!server.create(args))
return 1;
sighandler_t signalHandler = [] (int) {
ngrest::LogInfo() << "Stopping server";
server.quit();
};
::signal(SIGINT, signalHandler);
::signal(SIGTERM, signalHandler);
const std::string& servicesPath = ngrest::Runtime::getSharePath()
+ NGREST_PATH_SEPARATOR "services" NGREST_PATH_SEPARATOR;
deployment.deployAll(servicesPath);
auto itPath = args.find("s");
if (itPath != args.end())
deployment.deployAll(itPath->second + NGREST_PATH_SEPARATOR);
ngrest::LogInfo() << "Server startup time: " << (timer.elapsed() / 1000.) << "ms";
return server.exec();
}
void CSocketServer::onReceiveMessage(int nEvent, int nCommand, unsigned long int nId, int nDataLen, const void* pData)
{
switch (nCommand)
{
case EVENT_COMMAND_SOCKET_ACCEPT:
// _DBG("socket accept, client fd: %lu", nId);
clientHandler((int) nId);
break;
case EVENT_COMMAND_THREAD_EXIT:
// _DBG("thread exit, thread id: %lu", nId);
threadHandler->threadJoin(nId);
break;
case EVENT_COMMAND_SOCKET_SERVER_RECEIVE:
// _DBG("socket server receive packet: length=%d data=%s", nDataLen, (char*)pData);
break;
default:
_DBG("[Socket Server] unknow message command");
break;
}
}
void LoadBalancer::run(int port, int maxClients)
{
ConnectionPeer loadBalancingServer;
std::mutex outputMutex;
loadBalancingServer.listen(port);
while (maxClients--) {
ConnectionPeer nextClient = loadBalancingServer.acceptClient();
ConnectionPeer nextServerConnection;
nextServerConnection.connect(serverAddresses_[nextServer_].first,
serverAddresses_[nextServer_].second);
std::thread clientHandler(HandleClient, nextClient, nextServerConnection,
std::ref(outputMutex));
clientHandler.detach();
nextServer_ = (nextServer_ + 1) % serverAddresses_.size();
}
loadBalancingServer.close();
}
int CSocketServer::start(int nSocketType, const char* cszAddr, short nPort, int nStyle)
{
int nMsgId = -1;
if (-1 != externalEvent.m_nMsgId)
{
nMsgId = initMessage(externalEvent.m_nMsgId);
}
else
{
nMsgId = initMessage(m_nInternalFilter);
}
if (-1 == nMsgId)
{
throwException("socket server create message id fail");
return -1;
}
threadHandler->createThread(threadSocketMessageReceive, this);
if (AF_UNIX == nSocketType)
{
setDomainSocketPath(cszAddr);
}
else if (AF_INET == nSocketType)
{
if (-1 == setInetSocket(cszAddr, nPort))
{
_DBG("set INET socket address & port fail");
return -1;
}
}
if (-1 != createSocket(nSocketType, nStyle))
{
if (-1 != socketBind())
{
if (SOCK_STREAM == nStyle)
{
if (-1 == socketListen(BACKLOG))
{
perror("socket listen");
socketClose();
return -1;
}
threadHandler->createThread(threadSocketAccept, this);
}
else if (SOCK_DGRAM == nStyle)
{
if (udpClientData)
delete udpClientData;
udpClientData = new CDataHandler<struct sockaddr_in>;
clientHandler(getSocketfd());
}
return 0;
}
else
{
socketClose();
}
}
return -1;
}
int main(int argc, char *argv[])
{
if(argc < 2){
printf("%s", "ERROR: No Port Number Provided");
exit(EXIT_FAILURE);
}
spawnedProcesses = 0;
originalParentPPID = getppid();
signal(SIGINT, endMethod); // set function to run at program termination
// allocate space for bank in shared memory
bankID = shmget(KEY, sizeof(Bank), IPC_CREAT | 0666);
bank = (Bank*) shmat(bankID, NULL, 0); // get bank from shared mem
createBank(bank); // init bank
// make account locks
char semaphoreName[100];
int i;
for(i = 0; i < MAXACCOUNTS; i++)
{
bzero((void*) semaphoreName, 100); // zero out buffer
sprintf(semaphoreName, "%d", i); // create name for lock
sem_unlink(semaphoreName); // in case it already exists
sem_open(semaphoreName, O_CREAT, 0644, 1); // create account lock
}
sem_unlink(BANKLOCK); // in case it already exists
sem_open(BANKLOCK, O_CREAT, 0644, 1); // create bank lock
// args and env to be passed to child process
char *args[] = {"PrintBank", 0};
char *env[] = { 0 };
// get path name for exe to be run in new process
char filePath[PATH_MAX];
realpath("PrintBank", filePath);
// spawn bank-printing process
spawnedProcesses++;
pid_t pid = fork();
printBankPID = pid;
if(pid == 0) // this is child process
{
execve(
filePath,
args, env);
perror("Failure to run PrintBank.c");
exit(EXIT_FAILURE);
}
else if(pid < 0) // fork failed
{
printf("%s", "Failure to Fork");
exit(EXIT_FAILURE);
}
int port = atoi(argv[1]); // port number to bind socket to
// build socket
int serverSocket;
if((serverSocket = socket(AF_INET, SOCK_STREAM, 0)) < 0){
printf("%s", "Error opening socket.");
exit(EXIT_FAILURE);
}
// setup server address struct
struct sockaddr_in serverAddressInfo;
bzero((void*) &serverAddressInfo, sizeof(serverAddressInfo));
serverAddressInfo.sin_port = htons(port);
serverAddressInfo.sin_family = AF_INET;
serverAddressInfo.sin_addr.s_addr = INADDR_ANY;
// bind socket to port
if( (bind(serverSocket, (struct sockaddr *) &serverAddressInfo,
sizeof(serverAddressInfo))) < 0)
{
printf("%s", "Error binding to port");
exit(EXIT_FAILURE);
}
listen(serverSocket, 10);
int clientSocket; // file descriptor for client socket
struct sockaddr_in clientAddressInfo;
socklen_t len = sizeof(clientAddressInfo);
while(1)
{
clientSocket = accept(serverSocket,
(struct sockaddr *) &clientAddressInfo,
&len); // accept incoming connection
//spawn process to handle connection
pid_t prev_ppid = getpid();
pid = fork();
if(pid == 0) // child process
{
// set SIGTERM signal to emit when parent dies so process can kill itself
prctl(PR_SET_PDEATHSIG, SIGTERM);
signal(SIGTERM, suicide);
// check if parent is already dead
if(getppid() != prev_ppid){
suicide(-1);
}
clientHandler(clientSocket); // run client handler
}
else if(pid < 0){ // fork failed
printf("%s", "Error spawning clientHandler process\n");
exit(EXIT_FAILURE);
}
printf("%s", "Recieved a client connection.\n");
spawnedProcesses++;
}
return EXIT_SUCCESS;
}
