/**
* Writes a message to the shared memory.
*
* @param mixed $message The message to send
* @param integer $signal The signal to send afterward
* @param integer $pause The number of microseconds to pause after signalling
*/
public function send($message, $signal = null, $pause = 500)
{
$messageArray = array();
if (($shmId = @shmop_open($this->pid, 'a', 0, 0)) > 0) {
// Read any existing messages in shared memory
$readMessage = shmop_read($shmId, 0, shmop_size($shmId));
$messageArray[] = unserialize($readMessage);
shmop_delete($shmId);
shmop_close($shmId);
}
// Add the current message to the end of the array, and serialize it
$messageArray[] = $message;
$serializedMessage = serialize($messageArray);
// Write new serialized message to shared memory
$shmId = shmop_open($this->pid, 'c', 0644, strlen($serializedMessage));
if (!$shmId) {
throw new ProcessControlException(sprintf('Not able to create shared memory segment for PID: %s', $this->pid));
} else {
if (shmop_write($shmId, $serializedMessage, 0) !== strlen($serializedMessage)) {
throw new ProcessControlException(sprintf('Not able to write message to shared memory segment for segment ID: %s', $shmId));
}
}
if (false === $signal) {
return;
}
$this->signal($signal ?: $this->signal);
usleep($pause);
}
function MonClose()
{
if (!shmop_delete($this->{$shm_id})) {
debug("No se pudo borrar el segmento de memoria compartida.", "red");
}
shmop_close($this->{$shm_id});
}
/**
* Resize memory block
* @param int $size
* @return bool
*/
protected function resize($size)
{
if ($size > $this->max_size) {
return false;
}
//should be called AFTER reading memory (to not loose changing of variables)
if (empty($this->mem)) {
return false;
}
ignore_user_abort(true);
set_time_limit(180);
if (is_array($this->mem)) {
$this->mem[self::map_info][self::map_info_resized] = $this->mem[self::map_info][self::map_info_resized] + 1;
$this->mem[self::map_info][self::map_info_resizetime] = time();
}
shmop_delete($this->shm);
shmop_close($this->shm);
$t = serialize($this->mem);
$memsize = strlen($t);
if ($memsize > $size) {
$size = $memsize + 1000;
}
$this->shm = shmop_open($this->shmkey, "n", 0777, $size);
if (!$this->shm) {
return false;
}
//mmm... oops.
unset($this->mem);
$w = shmop_write($this->shm, str_pad($t, shmop_size($this->shm), ' ', STR_PAD_RIGHT), 0);
if (!$w) {
return false;
}
return true;
}
/**
* @param $key
* @param int $mode
* @param int $size
* @return mixed|null
* @throws OpenSharedMemoryException
* @throws ReadSharedMemoryException
* @throws SupportSharedMemoryException
*/
public static function read($key, $mode = 0644, $size = 100)
{
if (!self::checkSHMOPSupport()) {
return null;
}
@($shm_id = shmop_open($key, "a", $mode, $size));
//read only
if (!$shm_id) {
throw new OpenSharedMemoryException("The shared memory block could not be opened");
}
@($cached_string = shmop_read($shm_id, 0, $size));
if (!$cached_string) {
shmop_delete($shm_id);
shmop_close($shm_id);
throw new ReadSharedMemoryException("The shared memory block could not be read");
}
$data = json_decode($cached_string, true);
if (isset($data['expiration']) && time() > $data['expiration'] || !isset($data['expiration'])) {
shmop_delete($shm_id);
shmop_close($shm_id);
return null;
}
shmop_close($shm_id);
return unserialize($data['value']);
}
public function create($key, $buckets = 12281, $size = 10000000)
{
if ($key == 0) {
$this->errmsg = "key is 0";
return false;
}
$this->shmId = @shmop_open($key, 'a', 0, 0);
if ($this->shmId != false) {
if (!shmop_delete($this->shmId)) {
$this->errmsg = 'delete exist shm 0x' . dechex($key) . ' error';
return false;
}
}
$this->shmId = shmop_open($key, 'c', 0777, $size);
if ($this->shmId == false) {
$this->errmsg = 'create shm 0x' . dechex($key) . ' error';
return false;
}
$head['bsize'] = $size;
$head['size'] = 0;
$head['buckets'] = $buckets;
$head['start'] = 24;
$head['data'] = $buckets * 8 + 24;
$head['free'] = $buckets * 8 + 24;
return $this->setHead($head);
}
function rm($key)
{
$this->shmop_key = ftok($this->pre . $key);
$this->shmop_id = shmop_open($this->shmop_key, 'c', 0644, 0);
$result = shmop_delete($this->shmop_id);
shmop_close($this->shmop_id);
return $result;
}
/**
* Get all the exceptions added to the shared memory.
*
* @return \Throwable[]
*/
public function getExceptions() : array
{
$memory = shmop_open($this->key, "a", 0, 0);
$exceptions = $this->unserialize($memory);
shmop_delete($memory);
shmop_close($memory);
return $exceptions;
}
function __unlock()
{
if (isset($_SERVER['sync'])) {
shmop_delete($_SERVER['sync']);
shmop_close($_SERVER['sync']);
unset($_SERVER['sync']);
}
}
/**
* @return boolean
*/
public function delete()
{
if (!$this->exists()) {
return true;
}
$shmId = shmop_open($this->shmKey, 'w', 0, 0);
$result = (bool) shmop_delete($shmId);
shmop_close($shmId);
return $result;
}
public function delete($id, $size)
{
$shm = $this->open($id, $size);
if (shmop_delete($shm)) {
$keyfile = $this->getKeyFile($id);
if (file_exists($keyfile)) {
unlink($keyfile);
}
}
return true;
}
public function getCallbackParams()
{
$shmId = @shmop_open($this->pid, 'a', 0644, 0);
if (empty($shmId)) {
return false;
}
$datas = unserialize(shmop_read($shmId, 0, shmop_size($shmId)));
shmop_delete($shmId);
shmop_close($shmId);
return $datas;
}
/**
* delete shared memory
*
* @return void
* @throws RuntimeException
*/
public function delete()
{
$s = @shmop_open($this->genKey(), 'a', 0, 0);
if ($s === false) {
return;
}
if (!shmop_delete($s)) {
throw new RuntimeException('could not delete shared memory');
}
shmop_close($s);
unlink('/tmp/' . sha1($this->pid));
}
public function __destruct()
{
if ($this->changed) {
$serialized = serialize($this->data);
if (strlen($serialized) > shmop_size($this->res)) {
shmop_delete($this->res);
$this->res = shmop_open($id, 'c', 0644, ceil(strlen($serialized) * 1.25));
}
shmop_write($this->res, $serialized, 0);
}
shmop_close($this->res);
}
protected function tearDown()
{
if ($shmid = @shmop_open(self::SHMOP_ID, 'w', 0644, 0)) {
/*
* Fill memory block for fix bug
* @link https://bugs.php.net/bug.php?id=71921
*/
shmop_write($shmid, str_pad('', strlen(self::WORD), ' '), 0);
shmop_delete($shmid);
shmop_close($shmid);
}
}
function stream_write($data)
{
$p = $this->path;
$fp = fopen($p, 'w');
fwrite($fp, $data);
fclose($fp);
$this->id = ftok($this->path, 'M');
if ($t = @shmop_open($this->id, 'a', 0, 0)) {
shmop_delete($t);
}
$t = shmop_open($this->id, 'c', 0755, strlen($data));
shmop_write($t, $data, 0);
}
public function deletemem($shmkey)
{
$size = shmop_size($shmkey);
if ($size > 0) {
$this->updatestats($size, "del");
}
if (!shmop_delete($shmkey)) {
shmop_close($shmkey);
return false;
} else {
shmop_close($shmkey);
return true;
}
}
public function delete()
{
if ($this->status == self::STATUS_DELETED) {
return true;
}
// Reopen segment if not already opened
if ($this->status != self::STATUS_OPENED) {
$this->open();
}
$result = shmop_delete($this->shmId);
$this->shmId = null;
$this->status = self::STATUS_DELETED;
return $result;
}
private function write($data = null)
{
if (is_null($data)) {
$db = STORAGE_PATH . DS . 'memory' . sha1($this->ns . $this->entity) . '.db';
$data = $this->data();
File::delete($db);
File::put($db, $data);
}
shmop_delete($this->db);
shmop_close($this->db);
$size = $this->size > strlen($data) ? $this->size : strlen($data);
$this->size = $size;
$this->db = shmop_open($this->key, 'c', 0755, $size);
return shmop_write($this->db, $data, 0);
}
/**
*
* @param type $file
* @throws \Exception
*/
public function geoip_load_shared_mem($file)
{
$fp = fopen($file, "rb");
if (!$fp) {
throw new \Exception("error opening {$file}: {$php_errormsg}");
}
$s_array = fstat($fp);
$size = $s_array['size'];
if ($shmid = @shmop_open(GEOIP_SHM_KEY, "w", 0, 0)) {
shmop_delete($shmid);
shmop_close($shmid);
}
$shmid = shmop_open(GEOIP_SHM_KEY, "c", 0644, $size);
shmop_write($shmid, fread($fp, $size), 0);
shmop_close($shmid);
}
public function geoip_load_shared_mem($file)
{
$fp = fopen($file, "rb");
if (!$fp) {
print "error opening {$file}: {$php_errormsg}\n";
exit;
}
$s_array = fstat($fp);
$size = $s_array['size'];
if ($this->shmid = @shmop_open(self::GEOIP_SHM_KEY, "w", 0, 0)) {
shmop_delete($this->shmid);
shmop_close($this->shmid);
}
$this->shmid = shmop_open(self::GEOIP_SHM_KEY, "c", 0644, $size);
shmop_write($this->shmid, fread($fp, $size), 0);
shmop_close($this->shmid);
}
private function _getData()
{
// get length of data in shared memory
$dataLength = $this->_getDataLength();
if (!$dataLength) {
return array();
}
// read data from shared memory
$dataShm = shmop_open($this->_dataShmKey, 'c', 0644, $dataLength);
$serializedData = shmop_read($dataShm, 0, $dataLength);
$data = @unserialize($serializedData);
// destroy old data storage
shmop_delete($dataShm);
shmop_close($dataShm);
// data broken
if (!$data) {
return array();
}
return $data;
}
/**
* @depends testGetTubes
*/
public function testDoWork()
{
$expected = ['test-tube-1' => '1', 'test-tube-2' => '2'];
foreach ($expected as $tube => $value) {
$this->client->addWorker($tube, function (Job $job) {
// Store string «test-tube-%JOB_BODY%» in shared memory
$memory = shmop_open(self::$shmKey, 'c', 0644, self::$shmLimit);
$output = trim(shmop_read($memory, 0, self::$shmLimit));
$output .= sprintf("\ntest-tube-%s", $job->getBody());
shmop_write($memory, $output, 0);
shmop_close($memory);
exit(1);
});
$this->client->putInTube($tube, $value);
}
$this->client->doWork();
$memory = shmop_open(self::$shmKey, 'a', 0, 0);
$output = shmop_read($memory, 0, self::$shmLimit);
$this->assertTrue(shmop_delete($memory));
shmop_close($memory);
$this->assertNotEmpty($output);
// Compare number of items in expected list with lines in shared memory
$this->assertEquals(count($expected), count(array_unique(explode("\n", trim($output)))));
}
/**
* Delete a block from memory
*
* @param int $id memory block id
*/
function delete_mem($id)
{
if ((int) $id) {
if (!shmop_delete($id)) {
//$this->log_this("Couldn't mark shared memory block for deletion.\n");
}
}
}
/**
* Remove
*/
public function remove()
{
$exists = $this->exists($this->id);
if ($exists) {
shmop_delete($this->shmId);
shmop_close($this->shmId);
}
}
echo "failed\n";
} else {
echo "ok\n";
}
echo "data in memory is: " . shmop_read($shm_id, 0, $written) . "\n";
/* try to append data to the shared memory segment, this should fail */
@shmop_write($shm_id, $write_d1, $written);
echo $php_errormsg . "\n";
shmop_close($shm_id);
echo "shm open for read only: ";
$shm_id = shmop_open($hex_shm_id, "w", 0644, 1024);
if (!$shm_id) {
echo "failed\n";
} else {
echo "ok\n";
}
echo "shm write test #1: ";
$written = shmop_write($shm_id, $write_d2, $written);
if ($written != strlen($write_d2)) {
die("failed\n");
} else {
echo "ok\n";
}
echo "data in memory is: " . shmop_read($shm_id, 0, strlen($write_d1 . $write_d2)) . "\n";
echo "deletion of shm segment: ";
if (!shmop_delete($shm_id)) {
echo "failed\n";
} else {
echo "ok\n";
}
shmop_close($shm_id);
/**
* Loads the database file into shared memory.
*
* @param string $filename Path to database file to read into shared memory.
*
* @return void
*
* @throws CException - if unable to read the db file.
*/
protected function loadSharedMemory($filename)
{
$fp = fopen($filename, "rb");
if (!$fp) {
throw new CException("Unable to open file: {$filename}");
}
$s_array = fstat($fp);
$size = $s_array['size'];
if ($shmid = @shmop_open(self::SHM_KEY, "w", 0, 0)) {
shmop_delete($shmid);
shmop_close($shmid);
}
if ($shmid = @shmop_open(self::SHM_KEY, "c", 0644, $size)) {
$offset = 0;
while ($offset < $size) {
$buf = fread($fp, 524288);
shmop_write($shmid, $buf, $offset);
$offset += 524288;
}
shmop_close($shmid);
}
fclose($fp);
}
/**
* @return bool
*/
public function flush()
{
shmop_delete(self::$id);
return true;
}
/**
* Destroy thread context and free relative resources.
*
* @return void
*/
private function _cleanProcessContext()
{
shmop_delete($this->_internalIpcKey);
shmop_delete($this->_internalSemKey);
shmop_close($this->_internalIpcKey);
shmop_close($this->_internalSemKey);
@unlink($this->_ipcSegFile);
@unlink($this->_ipcSemFile);
$this->_isRunning = false;
$this->_pid = null;
}
private function Delete()
{
return shmop_delete($this->mShmId);
}
public function clear()
{
if (false === $this->m_segmentId) {
throw new Exception_IllegalState('memory/shared/shmop', 'Can not clear a closed shared memory segment.');
}
$this->m_offset = 0;
$this->m_capacity = 0;
return shmop_delete($this->m_segmentId);
}
