~MyServer()
{
if (sigterm_.is_active()) {
ev_ref(loop_);
sigterm_.stop();
}
}
void XzeroHttpDaemon::onChild(ev::child&, int)
{
// the child exited before we receive a SUCCESS from it. so resume normal operation again.
server_->log(x0::Severity::error, "New process exited with %d. Resuming normal operation.");
child_.stop();
// reenable HUP-signal
if (!hupSignal_.is_active()) {
server_->log(x0::Severity::error, "Reenable HUP-signal.");
hupSignal_.start();
ev_unref(loop_);
}
server_->log(x0::Severity::debug, "Reactivating listeners.");
for (x0::ServerSocket* listener: server_->listeners()) {
// reenable O_CLOEXEC on listener socket
listener->setCloseOnExec(true);
// start accepting new connections
listener->start();
}
server_->log(x0::Severity::debug, "Resuming workers.");
for (x0::HttpWorker* worker: server_->workers()) {
worker->resume();
}
}
void
sig_handlers::sig_term (ev::sig &w, int revents)
{
rxvt_emergency_cleanup ();
w.stop ();
kill (getpid (), w.signum);
}
EchoServer(int port) {
printf("Mendengarkan pada port %d\n", port);
struct sockaddr_in addr;
s = socket(PF_INET, SOCK_STREAM, 0);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = INADDR_ANY;
if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
perror("bind");
}
fcntl(s, F_SETFL, fcntl(s, F_GETFL, 0) | O_NONBLOCK);
listen(s, 5);
io.set<EchoServer, &EchoServer::io_accept>(this);
io.start(s, ev::READ);
sio.set<&EchoServer::signal_cb>();
sio.start(SIGINT);
}
void terminate_handler(ev::sig& sig, int)
{
std::clog << "Terminate signal received ..." << std::endl;
ev_ref(loop_);
sig.stop();
http_->stop();
}
int run()
{
std::clog << "Initializing ..." << std::endl;
sigterm_.set<MyServer, &MyServer::terminate_handler>(this);
sigterm_.start(SIGTERM);
ev_unref(loop_);
http_.reset(new x0::HttpServer(loop_));
http_->requestHandler = std::bind(&MyServer::requestHandler, this, std::placeholders::_1);
http_->setupListener("0.0.0.0", 3000);
std::clog << "Running ..." << std::endl;
int rv = http_->run();
std::clog << "Quitting ..." << std::endl;
return rv;
}
bool Server::setup()
{
auto inet = std::make_shared<InetServer>(loop_);
inet->callback = std::bind(&Server::accept, this, std::placeholders::_1, std::placeholders::_2);
if (!inet->open(IPAddress("0.0.0.0"), 3000, O_NONBLOCK | O_CLOEXEC)) {
fprintf(stderr, "Failed to setup server socket. %s\n", strerror(errno));
return false;
}
printf("Listening on %s:%d\n", "0.0.0.0", 3000);
listener_ = inet;
sigint_.set<Server, &Server::sig>(this);
sigint_.start(SIGINT);
loop_.unref();
return true;
}
// stage-2 termination handler
void XzeroHttpDaemon::quickShutdownHandler(ev::sig& sig, int)
{
log(x0::Severity::info, "%s received. shutting down NOW.", sig2str(sig.signum).c_str());
if (!child_.pid) {
// we are no garbage parent process
sd_notify(0, "STATUS=Shutting down.");
}
// default to standard signal-handler
ev_ref(loop_);
sig.stop();
// install shutdown timeout handler
terminationTimeout_.set<XzeroHttpDaemon, &XzeroHttpDaemon::quickShutdownTimeout>(this);
terminationTimeout_.start(10, 0);
ev_unref(loop_);
// kill active HTTP connections
server_->kill();
}
Server(FileDescriptor feedbackFd, const AgentOptions &_options)
: options(_options),
requestLoop(true),
serverInstanceDir(_options.serverInstanceDir, false),
resourceLocator(options.passengerRoot)
{
TRACE_POINT();
this->feedbackFd = feedbackFd;
UPDATE_TRACE_POINT();
generation = serverInstanceDir.getGeneration(options.generationNumber);
startListening();
accountsDatabase = boost::make_shared<AccountsDatabase>();
accountsDatabase->add("_passenger-status", options.adminToolStatusPassword, false,
Account::INSPECT_BASIC_INFO | Account::INSPECT_SENSITIVE_INFO |
Account::INSPECT_BACKTRACES | Account::INSPECT_REQUESTS);
accountsDatabase->add("_web_server", options.exitPassword, false, Account::EXIT);
messageServer = boost::make_shared<MessageServer>(
parseUnixSocketAddress(options.adminSocketAddress), accountsDatabase);
createFile(generation->getPath() + "/helper_agent.pid",
toString(getpid()), S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (geteuid() == 0 && !options.userSwitching) {
lowerPrivilege(options.defaultUser, options.defaultGroup);
}
UPDATE_TRACE_POINT();
randomGenerator = boost::make_shared<RandomGenerator>();
// Check whether /dev/urandom is actually random.
// https://code.google.com/p/phusion-passenger/issues/detail?id=516
if (randomGenerator->generateByteString(16) == randomGenerator->generateByteString(16)) {
throw RuntimeException("Your random number device, /dev/urandom, appears to be broken. "
"It doesn't seem to be returning random data. Please fix this.");
}
UPDATE_TRACE_POINT();
loggerFactory = boost::make_shared<UnionStation::LoggerFactory>(options.loggingAgentAddress,
"logging", options.loggingAgentPassword);
spawnerFactory = boost::make_shared<SpawnerFactory>(poolLoop.safe,
resourceLocator, generation, boost::make_shared<SpawnerConfig>(randomGenerator));
pool = boost::make_shared<Pool>(poolLoop.safe.get(), spawnerFactory, loggerFactory,
randomGenerator);
pool->initialize();
pool->setMax(options.maxPoolSize);
//pool->setMaxPerApp(maxInstancesPerApp);
pool->setMaxIdleTime(options.poolIdleTime * 1000000);
requestHandler = boost::make_shared<RequestHandler>(requestLoop.safe,
requestSocket, pool, options);
messageServer->addHandler(boost::make_shared<RemoteController>(requestHandler, pool));
messageServer->addHandler(ptr(new ExitHandler(exitEvent)));
sigquitWatcher.set(requestLoop.loop);
sigquitWatcher.set(SIGQUIT);
sigquitWatcher.set<Server, &Server::onSigquit>(this);
sigquitWatcher.start();
UPDATE_TRACE_POINT();
writeArrayMessage(feedbackFd,
"initialized",
getRequestSocketFilename().c_str(),
messageServer->getSocketFilename().c_str(),
NULL);
boost::function<void ()> func = boost::bind(prestartWebApps,
resourceLocator,
options.defaultRubyCommand,
options.prestartUrls
);
prestarterThread = ptr(new oxt::thread(
boost::bind(runAndPrintExceptions, func, true)
));
}
Server(FileDescriptor feedbackFd, const AgentOptions &_options)
: options(_options),
requestLoop(true),
serverInstanceDir(options.webServerPid, options.tempDir, false),
resourceLocator(options.passengerRoot)
{
TRACE_POINT();
this->feedbackFd = feedbackFd;
UPDATE_TRACE_POINT();
generation = serverInstanceDir.getGeneration(options.generationNumber);
startListening();
accountsDatabase = AccountsDatabase::createDefault(generation,
options.userSwitching, options.defaultUser, options.defaultGroup);
accountsDatabase->add("_web_server", options.messageSocketPassword, false, Account::EXIT);
messageServer = ptr(new MessageServer(generation->getPath() + "/socket", accountsDatabase));
createFile(generation->getPath() + "/helper_agent.pid",
toString(getpid()), S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (geteuid() == 0 && !options.userSwitching) {
lowerPrivilege(options.defaultUser, options.defaultGroup);
}
UPDATE_TRACE_POINT();
loggerFactory = make_shared<UnionStation::LoggerFactory>(options.loggingAgentAddress,
"logging", options.loggingAgentPassword);
randomGenerator = make_shared<RandomGenerator>();
spawnerFactory = make_shared<SpawnerFactory>(poolLoop.safe,
resourceLocator, generation, randomGenerator);
pool = make_shared<Pool>(poolLoop.safe.get(), spawnerFactory, loggerFactory,
randomGenerator);
pool->setMax(options.maxPoolSize);
//pool->setMaxPerApp(maxInstancesPerApp);
pool->setMaxIdleTime(options.poolIdleTime * 1000000);
messageServer->addHandler(make_shared<RemoteController>(pool));
messageServer->addHandler(make_shared<BacktracesServer>());
messageServer->addHandler(ptr(new ExitHandler(exitEvent)));
requestHandler = make_shared<RequestHandler>(requestLoop.safe,
requestSocket, pool, options);
sigquitWatcher.set(requestLoop.loop);
sigquitWatcher.set(SIGQUIT);
sigquitWatcher.set<Server, &Server::onSigquit>(this);
sigquitWatcher.start();
UPDATE_TRACE_POINT();
writeArrayMessage(feedbackFd,
"initialized",
getRequestSocketFilename().c_str(),
messageServer->getSocketFilename().c_str(),
NULL);
function<void ()> func = boost::bind(prestartWebApps,
resourceLocator,
options.prestartUrls
);
prestarterThread = ptr(new oxt::thread(
boost::bind(runAndPrintExceptions, func, true)
));
}