/** * Constructor. * @param string $filePath The file that is going to store the pipe. * @param bool $isReadMode Indicates if the param is going to be read only * @param bool $autoDeletion If it is set during the destruction of the GPhpThreadIntercom instance the pipe file will be also removed. */ public function __construct($filePath, $isReadMode = true, $autoDeletion = false) { // {{{ $this->ownerPid = getmypid(); if (!file_exists($filePath)) { if (!posix_mkfifo($filePath, 0644)) { $this->success = false; return; } } $commChanFd = fopen($filePath, $isReadMode ? 'r+' : 'w+'); // + mode makes it non blocking too if ($commChanFd === false) { $this->success = false; return; } if (!stream_set_blocking($commChanFd, false)) { $this->success = false; fclose($commChanFd); if ($autoDeletion) { @unlink($filePath); } return; } $this->commChanFdArr[] = $commChanFd; $this->commFilePath = $filePath; $this->autoDeletion = $autoDeletion; $this->isReadMode = $isReadMode; }
public function __construct($name, $read_cb = null) { $pipes_folder = JAXL_CWD . '/.jaxl/pipes'; if (!is_dir($pipes_folder)) { mkdir($pipes_folder); } $this->ev = new JAXLEvent(); $this->name = $name; $this->read_cb = $read_cb; $pipe_path = $this->get_pipe_file_path(); if (!file_exists($pipe_path)) { posix_mkfifo($pipe_path, $this->perm); $this->fd = fopen($pipe_path, 'r+'); if (!$this->fd) { _error("unable to open pipe"); } else { _debug("pipe opened using path {$pipe_path}"); _notice("Usage: \$ echo 'Hello World!' > {$pipe_path}"); $this->client = new JAXLSocketClient(); $this->client->connect($this->fd); $this->client->set_callback(array(&$this, 'on_data')); } } else { _error("pipe with name {$name} already exists"); } }
/** * @param string $name * @param callable $read_cb TODO: Currently not used */ public function __construct($name, $read_cb = null) { // TODO: see JAXL->cfg['priv_dir'] $this->pipes_folder = getcwd() . '/.jaxl/pipes'; if (!is_dir($this->pipes_folder)) { mkdir($this->pipes_folder, 0777, true); } $this->ev = new JAXLEvent(); $this->name = $name; // TODO: If someone's need the read callback and extends the JAXLPipe // to obtain it, one can't because this property is private. $this->read_cb = $read_cb; $pipe_path = $this->get_pipe_file_path(); if (!file_exists($pipe_path)) { posix_mkfifo($pipe_path, $this->perm); $this->fd = fopen($pipe_path, 'r+'); if (!$this->fd) { JAXLLogger::error("unable to open pipe"); } else { JAXLLogger::debug("pipe opened using path {$pipe_path}"); JAXLLogger::notice("Usage: \$ echo 'Hello World!' > {$pipe_path}"); $this->client = new JAXLSocketClient(); $this->client->connect($this->fd); $this->client->set_callback(array(&$this, 'on_data')); } } else { JAXLLogger::error("pipe with name {$name} already exists"); } }
public function __construct($file) { $this->file = $file; if (!file_exists($file)) { posix_mkfifo($file, 0700); } }
/** * Constructor. * * @param Master $master The master object * @param integer $pid The child process id or null if this is the child * * @throws \Exception * @throws \RuntimeException */ public function __construct(Master $master, $pid = null) { $this->master = $master; $directions = array('up', 'down'); if (null === $pid) { // child $pid = posix_getpid(); $pPid = posix_getppid(); $modes = array('write', 'read'); } else { // parent $pPid = null; $modes = array('read', 'write'); } $this->pid = $pid; $this->ppid = $pPid; foreach (array_combine($directions, $modes) as $direction => $mode) { $fifo = $this->getPath($direction); if (!file_exists($fifo) && !posix_mkfifo($fifo, 0600) && 17 !== ($error = posix_get_last_error())) { throw new \Exception(sprintf('Error while creating FIFO: %s (%d)', posix_strerror($error), $error)); } $this->{$mode} = fopen($fifo, $mode[0]); if (false === ($this->{$mode} = fopen($fifo, $mode[0]))) { throw new \RuntimeException(sprintf('Unable to open %s FIFO.', $mode)); } } }
public function open($fifoFile) { $this->fifoFile = $fifoFile; $dir = pathinfo($this->fifoFile, PATHINFO_DIRNAME); umask(0); $this->selfCreated = false; if (!is_dir($dir)) { if (!mkdir($dir, 0777, true)) { throw new \Exception("Could not create directory {$dir}"); } } // If pipe was not create on another side if (!file_exists($this->fifoFile)) { if (!posix_mkfifo($this->fifoFile, 0777)) { throw new \Exception("Could not create {$this->fifoFile}: " . posix_strerror(posix_get_last_error())); } else { $this->selfCreated = true; } } log::debug("Creating stream for {$this->fifoFile}"); $stream = fopen($this->fifoFile, "c+"); log::debug("Stream {$stream} = {$this->fifoFile}"); $this->valid = (bool) $stream; parent::open($stream); $this->setBlocking(false); }
/** * Create the file if needed * * @return Pipe */ public function create() { if (!is_file($this->name)) { return; } posix_mkfifo($this->name, 0777); return $this; }
static function init_pipes() { for ($i = 1; $i <= Config::$queue_number; $i++) { $queue_file = Config::$queue_dir . "/websnap_queue_{$i}"; if (!file_exists($queue_file)) { posix_mkfifo($queue_file, 0644); } } }
public function __construct($pathname, $mod = 0660) { if (!is_file($pathname)) { if (!posix_mkfifo($pathname, $mod)) { // throw } } $this->pathname = $pathname; }
/** * @param string $filename fifo filename * @param int $mode * @param bool $block if blocking */ public function __construct($filename = '/tmp/simple-fork.pipe', $mode = 0666, $block = false) { if (!file_exists($filename) && !posix_mkfifo($filename, $mode)) { throw new \RuntimeException("create pipe failed"); } if (filetype($filename) != "fifo") { throw new \RuntimeException("file exists and it is not a fifo file"); } $this->filename = $filename; $this->block = $block; }
public function __construct($port = 4444, $address = '127.0.0.1') { parent::__construct($port, $address); $this->pid = posix_getpid(); if (!file_exists(self::PIPENAME)) { umask(0); if (!posix_mkfifo(self::PIPENAME, 0666)) { die('Cant create a pipe: "' . self::PIPENAME . '"'); } } $this->pipe = fopen(self::PIPENAME, 'r+'); }
/** * Create a new pipeline. */ public function __construct() { $tmp_path = tempnam(sys_get_temp_dir(), "spawn."); // Initialise FIFO pipes. $this->request_path = $tmp_path . '.i'; $this->response_path = $tmp_path . '.o'; if (!file_exists($this->request_path)) { posix_mkfifo($this->request_path, 0644); } if (!file_exists($this->response_path)) { posix_mkfifo($this->response_path, 0644); } }
public function createStream() { if ('Linux' !== PHP_OS) { return parent::createStream(); } $this->fifoPath = tempnam(sys_get_temp_dir(), 'react-'); unlink($this->fifoPath); // Use a FIFO on linux to get around lack of support for disk-based file // descriptors when using the EPOLL back-end. posix_mkfifo($this->fifoPath, 0600); $stream = fopen($this->fifoPath, 'r+'); return $stream; }
/** * 创建fifo * @return [type] [description] */ protected function createFifo() { if (file_exists($this->name) && filetype($this->name) != 'fifo') { copy($this->name, $this->name . '.backup'); unlink($this->name); } if (!file_exists($this->name) && true !== posix_mkfifo($this->name, $this->mode)) { throw new \Exception('create fifo fail'); } if (filetype($this->name) != 'fifo') { throw new \Exception('fifo type error'); } }
/** Initialize the named pipe @param pipefile Name of the new named pipe to create @param mode Numeric permission indicator for the new pipe */ function _pipeInit($pipefile, $mode) { if (!file_exists($pipefile)) { // create the pipe umask(0); posix_mkfifo($pipefile, $mode); } // save the pipe to instance var $this->pipe = fopen($pipefile, "r+"); // turn off blocking stream_set_blocking($this->pipe, 0); //fwrite($this->pipe, "cfDebug Init\n\n"); }
function __construct($fifoPath, $mode = 0666) { //posix_getpid 返回进程ID号 // $fifoPath = "/home//$name.".posix_getpid(); if (!file_exists($fifoPath)) { if (!posix_mkfifo($fifoPath, $mode)) { error('create new pipe ($name) error.'); return false; } } else { error("pipe ({$name}) has exist."); return false; } $this->fifoPath = $fifoPath; }
public function __construct($file, $create = true) { $this->file = $file; if (!$this->exists() && $create) { touch($this->file); posix_mkfifo($this->file, 0666); $this->creator = true; $this->fh = fopen($this->file, "r+"); } else { if ($this->exists()) { $this->fh = fopen($this->file, "r+"); } else { throw new \Exception("Could not open FIFO for reading: Node does not exist."); } } stream_set_blocking($this->fh, 0); }
public function __construct($name, $perm = 0600) { $this->name = $name; $this->perm = $perm; $pipe_path = $this->get_pipe_file_path(); if (!file_exists($pipe_path)) { posix_mkfifo($pipe_path, $this->perm); $this->fd = fopen($pipe_path, 'r+'); if (!$this->fd) { _error("unable to open pipe"); } stream_set_blocking($this->fd, false); // watch for incoming data on pipe JAXLLoop::watch($this->fd, array('read' => array(&$this, 'on_read_ready'))); } else { _error("pipe with name {$name} already exists"); } }
/** * Runs the command and returns the command output and the separated STDERR in the outgoing parameter. * * Uses the "system.commandOutputHelper.work.path" config, what is describes the directory where the temporary * file pointer will be added. (default => /tmp) * * @param CommandExecutor $command The command executor object. * @param string $stdErr The error messages [Outgoing] * * @return \YapepBase\Shell\CommandOutput The output of the command. * @throws \Exception */ public function runCommandWithStdErr(CommandExecutor $command, &$stdErr) { $dir = Config::getInstance()->get('system.commandOutputHelper.work.path', '/tmp'); $pipePath = tempnam($dir, 'stderr-'); $fileHandler = Application::getInstance()->getDiContainer()->getFileHandler(); try { posix_mkfifo($pipePath, 0755); $command->setOutputRedirection(CommandExecutor::OUTPUT_REDIRECT_STDERR, $pipePath); $result = $command->run(); $stdErr = $fileHandler->getAsString($pipePath); $fileHandler->remove($pipePath); } catch (\Exception $e) { if ($fileHandler->checkIsPathExists($pipePath)) { $fileHandler->remove($pipePath); } throw $e; } return $result; }
/** * Ensure the fifo is created. */ private function ensureFifo() { if (file_exists($this->fileName)) { $type = filetype($this->fileName); if ($type != "fifo") { throw new Exception("File already exists, but it is not a fifo"); } return; } if (function_exists("posix_mkfifo")) { if (!posix_mkfifo($this->fileName, 0644)) { throw new Exception("Unable to create fifo using posix_mkfifo"); } return; } exec("/usr/bin/mkfifo " . escapeshellarg($this->fileName), $ret, $err); if ($err) { throw new Exception("Unable to create fifo using exec(mkfifo)"); } }
/** * 解析 autoload_classmap.php 生成类的继承关系和接口的实现关系 * * @param bool $is_force 是否强制重新刷新索引 */ public function index($is_force = false) { if (is_dir($this->getIndexDir()) && !$is_force) { return; } $this->initIndexDir(); exec('composer dump-autoload -o -d ' . $this->root); $this->class_map = (require $this->class_map_file); $pipe_path = sys_get_temp_dir() . '/' . uniqid(); posix_mkfifo($pipe_path, 0600); $class_num = count($this->class_map); $cmd = 'let g:pb = vim#widgets#progressbar#NewSimpleProgressBar("Indexing:", ' . $class_num . ')'; $this->callRpc('vim_command', $cmd); while ($this->class_map) { $pid = pcntl_fork(); if ($pid == -1) { die('could not fork'); } elseif ($pid > 0) { // 父进程 $pipe = fopen($pipe_path, 'r'); $data = fgets($pipe); $this->class_map = json_decode(trim($data), true); pcntl_waitpid($pid, $status); } else { // 子进程 $pipe = fopen($pipe_path, 'w'); register_shutdown_function(function () use($pipe) { $data = json_encode($this->class_map, true); fwrite($pipe, "{$data}\n"); fclose($pipe); }); $this->_index(); fwrite($pipe, "[]\n"); fclose($pipe); exit; } } fclose($pipe); unlink($pipe_path); $this->callRpc('vim_command', 'call g:pb.restore()'); }
/** * Fetch and save class's interface and parent info * according the autoload_classmap.php file * * @param bool $is_force overwrite the exists index */ public function index($is_force = false) { if (is_dir($this->getIndexDir()) && !$is_force) { return; } $this->initIndexDir(); exec('composer dump-autoload -o -d ' . $this->root . ' 2>&1 >/dev/null'); $this->class_map = (require $this->root . '/vendor/composer/autoload_classmap.php'); $pipe_path = sys_get_temp_dir() . '/' . uniqid(); posix_mkfifo($pipe_path, 0600); $this->vimOpenProgressBar(count($this->class_map)); while ($this->class_map) { $pid = pcntl_fork(); if ($pid == -1) { die('could not fork'); } elseif ($pid > 0) { // 父进程 $pipe = fopen($pipe_path, 'r'); $data = fgets($pipe); $this->class_map = json_decode(trim($data), true); pcntl_waitpid($pid, $status); } else { // 子进程 $pipe = fopen($pipe_path, 'w'); register_shutdown_function(function () use($pipe) { $data = json_encode($this->class_map, true); fwrite($pipe, "{$data}\n"); fclose($pipe); }); $this->_index(); fwrite($pipe, "[]\n"); fclose($pipe); exit; } } fclose($pipe); unlink($pipe_path); $this->vimCloseProgressBar(); }
public function createStream() { // Use a FIFO on linux to get around lack of support for disk-based file // descriptors when using the EPOLL back-end. if ('Linux' === PHP_OS) { $this->fifoPath = tempnam(sys_get_temp_dir(), 'react-'); unlink($this->fifoPath); posix_mkfifo($this->fifoPath, 0600); $stream = fopen($this->fifoPath, 'r+'); // ext-event (as of 1.8.1) does not yet support in-memory temporary // streams. Setting maxmemory:0 and performing a write forces PHP to // back this temporary stream with a real file. // // This problem is mentioned at https://bugs.php.net/bug.php?id=64652&edit=3 // but remains unresolved (despite that issue being closed). } else { $stream = fopen('php://temp/maxmemory:0', 'r+'); fwrite($stream, 'x'); ftruncate($stream, 0); } return $stream; }
function faceForIDs($ids) { if (!is_array($ids)) { $ids = array($ids); } $transfer = array('ids' => $ids); $jsonTransfer = json_encode($transfer); // #input pipe // $pipe_in ="/tmp/pipe_faceIDs_back"; // if(!file_exists($pipe_in)){ // umask(0); // posix_mkfifo( $pipe, 0666 ); // } #input pipe $pipe_out = "/tmp/pipe_faceIDs"; if (!file_exists($pipe_out)) { umask(0); posix_mkfifo($pipe, 0666); } $handle = fopen("/tmp/pipe_faceIDs", "w"); fwrite($handle, $jsonTransfer); fclose($handle); }
/** * check, create and validate the fifo file/folder * * @param string $file * @param string|null $folder * * @throws TransportException */ protected function intializeFile($file, $folder = null) { if (is_null($folder)) { $folder = sys_get_temp_dir(); } if (!is_dir($folder)) { if (false === mkdir($folder, 0777, true)) { throw TransportException::couldNotCreateFolder($folder); } } if (strrev($folder)[0] === '/') { $folder = substr($folder, 0, -1); } $this->fifo = sprintf('%s/%s', $folder, $file); if (!file_exists($this->fifo)) { if (false === posix_mkfifo($this->fifo, 0600)) { throw TransportException::posixError(); } } if (false == (stat($this->fifo)['mode'] & 010000)) { throw TransportException::fileIsNotANamedPipe($this->fifo); } }
function play($file, $viddir) { $err = ''; exec('pgrep omxplayer', $pids); //omxplayer is running? if (empty($pids)) { //NO @unlink(FIFO); posix_mkfifo(FIFO, 0777); chmod(FIFO, 0777); // Update Status file to PLAYING $statfd = fopen(STATFILE, "w"); fwrite($statfd, "PLAYING\n"); fclose($statfd); // Run omx_play.sh with arguments shell_exec(getcwd() . '/omx_play.sh ' . escapeshellarg($file) . ' ' . escapeshellarg($viddir)); $out = 'playing ' . basename($file); } else { //YES $out = ''; $err = 'omxplayer is already runnning'; } return array('res' => $out, 'err' => $err); }
/** * setupPipeFile : setup the file pipe (removing the old one) * * @param mixed $_pipe_file * @return php file handler */ public function setupPipeFile($_pipe_file) { if (file_exists($_pipe_file)) { if (!unlink($_pipe_file)) { die('unable to remove stale file'); } } umask(0); if (!posix_mkfifo($_pipe_file, $this->pipe_permissions_octal)) { die('unable to create named pipe'); } if ($this->pipe_owning_user != NULL) { chown($_pipe_file, $this->pipe_owning_user); } if ($this->pipe_owning_group != NULL) { chgrp($_pipe_file, $this->pipe_owning_group); } $pipe = fopen($_pipe_file, 'r+'); if (!$pipe) { die('unable to open the named pipe'); } stream_set_blocking($pipe, false); return $pipe; }
VERIFY(posix_getpgrp()); VERIFY(posix_getpid()); VERIFY(posix_getppid()); $ret = posix_getpwnam("root"); VERIFY($ret != false); VERIFY(count((array) $ret) != 0); VS(posix_getpwnam(""), false); VS(posix_getpwnam(-1), false); $ret = posix_getpwuid(0); VERIFY($ret != false); VERIFY(count((array) $ret) != 0); VS(posix_getpwuid(-1), false); $ret = posix_getrlimit(); VERIFY($ret != false); VERIFY(count((array) $ret) != 0); VERIFY(posix_getsid(posix_getpid())); $tmpfifo = tempnam('/tmp', 'vmmkfifotest'); unlink($tmpfifo); VERIFY(posix_mkfifo($tmpfifo, 0)); $tmpnod = tempnam('/tmp', 'vmmknodtest'); unlink($tmpnod); VERIFY(posix_mknod($tmpnod, 0)); VERIFY(posix_setpgid(0, 0)); VERIFY(posix_setsid()); VERIFY(strlen(posix_strerror(1))); $ret = posix_times(); VERIFY($ret != false); VERIFY(count((array) $ret) != 0); $ret = posix_uname(); VERIFY($ret != false); VERIFY(count((array) $ret) != 0);
unset($opts[CURLOPT_POSTFIELDS]); curl_setopt_array($ch, $opts); $result = curl_exec($ch); curl_close($ch); //Get playlist file from webpage $result = preg_match("/PARAM NAME=\"FileName\" VALUE=\"(.*)\"/", $result, $matches); //Download playlist file $ch = curl_init($matches[1]); curl_setopt_array($ch, $opts); $result = curl_exec($ch); curl_close($ch); //Find stream $result = preg_match("/Ref href=\"(.*)\"/", $result, $matches); //Change transport from mms to http $url = preg_replace("/mms:/", "http:", $matches[1]); //FIFO from mplayer to lame $wav_file = "/tmp/xms_streaming" . posix_getpid() . ".wav"; posix_mkfifo($wav_file, 0666); $descriptorspec = array(0 => array("pipe", "r"), 1 => array("pipe", "w"), 2 => array("file", "/tmp/error-output.txt", "a")); //Start mplayer $handle = proc_open($XMSTREAM_MPLAYER . " -quiet -really-quiet -vc null -vo null -ao pcm:file={$wav_file} {$url} ", $descriptorspec, $pipes); //Start lame $handle2 = proc_open($XMSTREAM_LAME . " {$wav_file} - ", $descriptorspec, $pipes2); $file2 = $pipes2[1]; while (1) { $data = fread($file2, 1024); if ($data === FALSE) { exit; } echo $data; }
public static function start_new($wid, $test_id, $debug = false) { $session = new TestSession(); $session->Test_id = $test_id; $session->debug = $debug ? 1 : 0; $session->UserWorkspace_id = $wid; $lid = $session->mysql_save(); $session = TestSession::from_mysql_id($lid); if (!$debug) { $sql = sprintf("UPDATE `%s` SET `session_count`=`session_count`+1 WHERE `%s`.`id`=%d", Test::get_mysql_table(), Test::get_mysql_table(), $test_id); mysql_query($sql); } $test = $session->get_Test(); if ($test != null) { posix_mkfifo($session->get_RSession_fifo_path(), 0774); } if ($debug) { $session->register(); } return $session; }