Diffusion Phabricator (feature/testing) Browse

testing

PhabricatorAphlictManagementWorkflow.php
View Options

			<?php

			abstract class PhabricatorAphlictManagementWorkflow
			extends PhabricatorManagementWorkflow {

			private $debug = false;
			private $clientHost;
			private $clientPort;

			protected function didConstruct() {
			$this
			->setArguments(
			array(
			array(
			'name' => 'client-host',
			'param' => 'hostname',
			'help' => pht('Hostname to bind to for the client server.'),
			),
			array(
			'name' => 'client-port',
			'param' => 'port',
			'help' => pht('Port to bind to for the client server.'),
			),
			));
			}

			public function execute(PhutilArgumentParser $args) {
			$this->clientHost = $args->getArg('client-host');
			$this->clientPort = $args->getArg('client-port');
			return 0;
			}

			final public function getPIDPath() {
			return PhabricatorEnv::getEnvConfig('notification.pidfile');
			}

			final public function getLogPath() {
			$path = PhabricatorEnv::getEnvConfig('notification.log');

			try {
			$dir = dirname($path);
			if (!Filesystem::pathExists($dir)) {
			Filesystem::createDirectory($dir, 0755, true);
			}
			} catch (FilesystemException $ex) {
			throw new Exception(
			pht(
			"Failed to create '%s'. You should manually create this directory.",
			$dir));
			}

			return $path;
			}

			final public function getPID() {
			$pid = null;
			if (Filesystem::pathExists($this->getPIDPath())) {
			$pid = (int)Filesystem::readFile($this->getPIDPath());
			}
			return $pid;
			}

			final public function cleanup($signo = '?') {
			global $g_future;
			if ($g_future) {
			$g_future->resolveKill();
			$g_future = null;
			}

			Filesystem::remove($this->getPIDPath());

			exit(1);
			}

			protected final function setDebug($debug) {
			$this->debug = $debug;
			}

			public static function requireExtensions() {
			self::mustHaveExtension('pcntl');
			self::mustHaveExtension('posix');
			}

			private static function mustHaveExtension($ext) {
			if (!extension_loaded($ext)) {
			echo "ERROR: The PHP extension '{$ext}' is not installed. You must ".
			"install it to run aphlict on this machine.\n";
			exit(1);
			}

			$extension = new ReflectionExtension($ext);
			foreach ($extension->getFunctions() as $function) {
			$function = $function->name;
			if (!function_exists($function)) {
			echo "ERROR: The PHP function {$function}() is disabled. You must ".
			"enable it to run aphlict on this machine.\n";
			exit(1);
			}
			}
			}

			final protected function willLaunch() {
			$console = PhutilConsole::getConsole();

			$pid = $this->getPID();
			if ($pid) {
			throw new PhutilArgumentUsageException(
			pht(
			'Unable to start notifications server because it is already '.
			'running. Use `aphlict restart` to restart it.'));
			}

			if (posix_getuid() == 0) {
			throw new PhutilArgumentUsageException(
			pht(
			// TODO: Update this message after a while.
			'The notification server should not be run as root. It no '.
			'longer requires access to privileged ports.'));
			}

			// Make sure we can write to the PID file.
			if (!$this->debug) {
			Filesystem::writeFile($this->getPIDPath(), '');
			}

			// First, start the server in configuration test mode with --test. This
			// will let us error explicitly if there are missing modules, before we
			// fork and lose access to the console.
			$test_argv = $this->getServerArgv();
			$test_argv[] = '--test=true';

			execx(
			'%s %s %Ls',
			$this->getNodeBinary(),
			$this->getAphlictScriptPath(),
			$test_argv);
			}

			private function getServerArgv() {
			$ssl_key = PhabricatorEnv::getEnvConfig('notification.ssl-key');
			$ssl_cert = PhabricatorEnv::getEnvConfig('notification.ssl-cert');

			$server_uri = PhabricatorEnv::getEnvConfig('notification.server-uri');
			$server_uri = new PhutilURI($server_uri);

			$client_uri = PhabricatorEnv::getEnvConfig('notification.client-uri');
			$client_uri = new PhutilURI($client_uri);

			$log = $this->getLogPath();

			$server_argv = array();
			$server_argv[] = '--client-port='.coalesce(
			$this->clientPort,
			$client_uri->getPort());
			$server_argv[] = '--admin-port='.$server_uri->getPort();
			$server_argv[] = '--admin-host='.$server_uri->getDomain();

			if ($ssl_key) {
			$server_argv[] = '--ssl-key='.$ssl_key;
			}

			if ($ssl_cert) {
			$server_argv[] = '--ssl-cert='.$ssl_cert;
			}

			$server_argv[] = '--log='.$log;

			if ($this->clientHost) {
			$server_argv[] = '--client-host='.$this->clientHost;
			}

			return $server_argv;
			}

			private function getAphlictScriptPath() {
			$root = dirname(phutil_get_library_root('phabricator'));
			return $root.'/support/aphlict/server/aphlict_server.js';
			}

			final protected function launch() {
			$console = PhutilConsole::getConsole();

			if ($this->debug) {
			$console->writeOut(pht("Starting Aphlict server in foreground...\n"));
			} else {
			Filesystem::writeFile($this->getPIDPath(), getmypid());
			}

			$command = csprintf(
			'%s %s %Ls',
			$this->getNodeBinary(),
			$this->getAphlictScriptPath(),
			$this->getServerArgv());

			if (!$this->debug) {
			declare(ticks = 1);
			pcntl_signal(SIGINT, array($this, 'cleanup'));
			pcntl_signal(SIGTERM, array($this, 'cleanup'));
			}
			register_shutdown_function(array($this, 'cleanup'));

			if ($this->debug) {
			$console->writeOut("Launching server:\n\n $ ".$command."\n\n");

			$err = phutil_passthru('%C', $command);
			$console->writeOut(">>> Server exited!\n");
			exit($err);
			} else {
			while (true) {
			global $g_future;
			$g_future = new ExecFuture('exec %C', $command);
			$g_future->resolve();

			// If the server exited, wait a couple of seconds and restart it.
			unset($g_future);
			sleep(2);
			}
			}
			}


			/* -( Commands )----------------------------------------------------------- */


			final protected function executeStartCommand() {
			$console = PhutilConsole::getConsole();
			$this->willLaunch();

			$pid = pcntl_fork();
			if ($pid < 0) {
			throw new Exception('Failed to fork()!');
			} else if ($pid) {
			$console->writeErr(pht("Aphlict Server started.\n"));
			exit(0);
			}

			// When we fork, the child process will inherit its parent's set of open
			// file descriptors. If the parent process of bin/aphlict is waiting for
			// bin/aphlict's file descriptors to close, it will be stuck waiting on
			// the daemonized process. (This happens if e.g. bin/aphlict is started
			// in another script using passthru().)
			fclose(STDOUT);
			fclose(STDERR);


			$this->launch();
			return 0;
			}


			final protected function executeStopCommand() {
			$console = PhutilConsole::getConsole();

			$pid = $this->getPID();
			if (!$pid) {
			$console->writeErr(pht("Aphlict is not running.\n"));
			return 0;
			}

			$console->writeErr(pht("Stopping Aphlict Server (%s)...\n", $pid));
			posix_kill($pid, SIGINT);

			$start = time();
			do {
			if (!PhabricatorDaemonReference::isProcessRunning($pid)) {
			$console->writeOut(
			"%s\n",
			pht('Aphlict Server (%s) exited normally.', $pid));
			$pid = null;
			break;
			}
			usleep(100000);
			} while (time() < $start + 5);

			if ($pid) {
			$console->writeErr(pht('Sending %s a SIGKILL.', $pid)."\n");
			posix_kill($pid, SIGKILL);
			unset($pid);
			}

			Filesystem::remove($this->getPIDPath());
			return 0;
			}

			private function getNodeBinary() {
			if (Filesystem::binaryExists('nodejs')) {
			return 'nodejs';
			}

			if (Filesystem::binaryExists('node')) {
			return 'node';
			}

			throw new PhutilArgumentUsageException(
			pht(
			'No `nodejs` or `node` binary was found in $PATH. You must install '.
			'Node.js to start the Aphlict server.'));
			}

			}

phab/src/applications/aphlict/management/PhabricatorAphlictManagementWorkflow.phpdaadf955378cfeature/testing

PhabricatorAphlictManagementWorkflow.phpView Options

phab/src/applications/aphlict/management/PhabricatorAphlictManagementWorkflow.php
daadf955378cfeature/testing

PhabricatorAphlictManagementWorkflow.php
View Options