function __construct()
{
$this->logger = Logger::getLogger(__CLASS__);
$this->db = $this->getContainer()->adodb;
$this->lastCleanup = new Scalr_System_Ipc_Shm(array("name" => "scalr.cronjob.poller.lastCleanup"));
$this->cleanupSem = sem_get(Scalr_System_OS::getInstance()->tok("scalr.cronjob.poller.cleanupSem"));
}
/**
* Provides Mutex factories.
*
* @return callable[][] The mutex factories.
*/
public function provideMutexFactories()
{
$cases = ["NoMutex" => [function () {
return new NoMutex();
}], "TransactionalMutex" => [function () {
$pdo = new \PDO("sqlite::memory:");
$pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
return new TransactionalMutex($pdo);
}], "FlockMutex" => [function () {
vfsStream::setup("test");
return new FlockMutex(fopen(vfsStream::url("test/lock"), "w"));
}], "SemaphoreMutex" => [function () {
return new SemaphoreMutex(sem_get(ftok(__FILE__, "a")));
}], "SpinlockMutex" => [function () {
$mock = $this->getMockForAbstractClass(SpinlockMutex::class, ["test"]);
$mock->expects($this->any())->method("acquire")->willReturn(true);
$mock->expects($this->any())->method("release")->willReturn(true);
return $mock;
}], "LockMutex" => [function () {
$mock = $this->getMockForAbstractClass(LockMutex::class);
$mock->expects($this->any())->method("lock")->willReturn(true);
$mock->expects($this->any())->method("unlock")->willReturn(true);
return $mock;
}]];
if (getenv("MEMCACHE_HOST")) {
$cases["MemcacheMutex"] = [function () {
$memcache = new Memcache();
$memcache->connect(getenv("MEMCACHE_HOST"));
return new MemcacheMutex("test", $memcache);
}];
$cases["MemcachedMutex"] = [function () {
$memcache = new Memcached();
$memcache->addServer(getenv("MEMCACHE_HOST"), 11211);
return new MemcachedMutex("test", $memcache);
}];
}
if (getenv("REDIS_URIS")) {
$uris = explode(",", getenv("REDIS_URIS"));
$cases["PredisMutex"] = [function () use($uris) {
$clients = array_map(function ($uri) {
return new Client($uri);
}, $uris);
return new PredisMutex($clients, "test");
}];
$cases["PHPRedisMutex"] = [function () use($uris) {
$apis = array_map(function ($uri) {
$redis = new Redis();
$uri = parse_url($uri);
if (!empty($uri["port"])) {
$redis->connect($uri["host"], $uri["port"]);
} else {
$redis->connect($uri["host"]);
}
return $redis;
}, $uris);
return new PHPRedisMutex($apis, "test");
}];
}
return $cases;
}
/**
* Tests removing semaphore fails.
*
* @test
* @expectedException bandwidthThrottle\tokenBucket\storage\StorageException
* @expectedExceptionMessage Could not remove semaphore.
*/
public function testfailRemovingSemaphore()
{
$key = ftok(__FILE__, "a");
$storage = new IPCStorage($key);
sem_remove(sem_get($key));
@$storage->remove();
}
public function __construct($key)
{
if (!is_long($key)) {
E("传入了非法的信号量key");
}
$this->ipc_signal = sem_get($key);
}
/**
* 获得SemFd
*/
protected static function getSemFd()
{
if (!self::$semFd && extension_loaded('sysvsem')) {
self::$semFd = sem_get(self::SEM_KEY);
}
return self::$semFd;
}
private function getSemaphoreId()
{
if ($this->semaphoreId === null) {
$this->semaphoreId = sem_get($this->key);
}
return $this->semaphoreId;
}
/**
* @param $config
* @key string [name]
* @key string [key]
* @key array [items]
*/
function __construct($config)
{
$this->logger = Logger::getLogger(__CLASS__);
$this->initialConfig = $config;
$this->shm = new Scalr_System_Ipc_Shm($config);
$key = $this->shm->key + 8;
$this->logger->debug(sprintf("Get semaphore (key: 0x%08x)", $key));
$this->sem = sem_get($key, 1, 0666, true);
if (!$this->sem) {
throw new Scalr_System_Ipc_Exception("Cannot sem_get (key: {$key})");
}
if (!sem_acquire($this->sem)) {
throw new Scalr_System_Ipc_Exception("Cannot acquire semaphore");
}
try {
$meta = $this->getMeta();
if ($meta === null) {
$this->clear0();
}
sem_release($this->sem);
} catch (Exception $e) {
sem_release($this->sem);
throw $e;
}
if ($config["items"]) {
foreach ($config["items"] as $item) {
$this->add($item);
}
}
}
/**
* Wake up from a sleep
*/
function __wakeup()
{
$this->id = sem_get($this->key);
shm_attach($this->id);
$this->refreshMemoryVarList();
shm_put_var($this->id, 1, shm_get_var($this->id, 1) + 1);
}
/**
* 通过本机共享内存件来生成一个auto_increment序列
*
* 序列类似MySQL的auto_increment
*
* @access private
* @param void
* @return mixed
*/
function getNextValueByShareMemory()
{
$addr = '127.0.0.1';
if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
$addr = $_SERVER['HTTP_X_FORWARDED_FOR'];
} elseif (!empty($_SERVER['SERVER_ADDR'])) {
$addr = $_SERVER['SERVER_ADDR'];
}
$skey = 'global_serial_generator_seed_' . $addr;
$ikey = crc32($skey);
$sem = $shm = null;
$retry_times = 1;
do {
$sem = sem_get($ikey, 1, 0777);
$shm = shm_attach($ikey, 128, 0777);
if (is_resource($sem) && is_resource($shm)) {
break;
}
$cmd = "ipcrm -M 0x00000000; ipcrm -S 0x00000000; ipcrm -M {$ikey} ; ipcrm -S {$ikey}";
$last_line = exec($cmd, $output, $retval);
} while ($retry_times-- > 0);
if (!sem_acquire($sem)) {
return false;
}
$next_value = false;
if (shm_has_var($shm, $ikey)) {
shm_put_var($shm, $ikey, $next_value = shm_get_var($shm, $ikey) + 1);
} else {
shm_put_var($shm, $ikey, $next_value = 1);
}
$shm && shm_detach($shm);
$sem && sem_release($sem);
return $next_value;
}
/**
* Registers the PID of a child-process
*
* @param int The PID
*/
public function registerChildPID($pid)
{
$sem_key = sem_get($this->crawler_uniqid);
sem_acquire($sem_key);
file_put_contents($this->working_directory . "pids", $pid . "\n", FILE_APPEND);
sem_release($sem_key);
}
/**
* @return IdValue
*/
public function generate()
{
$timestamp = $this->generateTimestamp();
// Acquire semaphore
$semaphore = sem_get($this->semaphoreId);
sem_acquire($semaphore);
// Attach shared memory
$memory = shm_attach(self::SHM_KEY);
$sequence = 0;
if (!is_null($this->lastTimestamp) && $timestamp->equals($this->lastTimestamp)) {
// Get
$sequence = shm_get_var($memory, self::SHM_SEQUENCE) + 1 & $this->config->getSequenceMask();
// Increment sequence
shm_put_var($memory, self::SHM_SEQUENCE, $sequence);
if ($sequence === 0) {
usleep(1000);
$timestamp = $this->generateTimestamp();
}
} else {
// Reset sequence if timestamp is different from last one.
$sequence = 0;
shm_put_var($memory, self::SHM_SEQUENCE, $sequence);
}
// Detach shared memory
shm_detach($memory);
// Release semaphore
sem_release($semaphore);
// Update lastTimestamp
$this->lastTimestamp = $timestamp;
return new IdValue($timestamp, $this->regionId, $this->serverId, $sequence, $this->calculate($timestamp, $this->regionId, $this->serverId, $sequence));
}
public static function put($killID, $raw)
{
$file = static::getFile($killID, true);
$sem = sem_get(5632);
// kmdb is 5632 on a phone
if (!sem_acquire($sem)) {
throw new Exception('Unable to obtain kmdb semaphore');
}
// Thread safe from here until sem_release
if (!file_exists($file)) {
$kills = array();
} else {
$contents = file_get_contents($file);
$deflated = gzdecode($contents);
$kills = unserialize($deflated);
$contents = null;
}
if (!isset($kills["{$killID}"])) {
$kills["{$killID}"] = $raw;
$contents = serialize($kills);
$compressed = gzencode($contents);
file_put_contents($file, $compressed, LOCK_EX);
}
sem_release($sem);
}
public function __construct($path, $currentArticleFile, $debug_delete_file)
{
$this->path = $path;
$this->debug_delete_file = $debug_delete_file;
$this->currentArticleFile = $currentArticleFile;
$this->semaphoreID = sem_get(OAIRECORDFILES);
}
/**
* Constructor.
*
* @see BasicMutex::__construct()
*/
public function __construct($name)
{
$this->key = abs(crc32($name));
$this->sem = sem_get($this->key, 1, 0666, 1);
if ($this->sem === false) {
throw new MutexException('Error geting semaphore');
}
}
protected function initializeShm()
{
if (null !== $this->shmHandle) {
return;
}
$this->shmHandle = shm_attach($this->getId(), 60 * 1024);
$this->semHandle = sem_get($this->getId());
}
function MMC_Lock($name)
{
if (false && function_exists('sem_get') && function_exists('sem_acquire')) {
$semid = sem_get(crc32(MMC_Name($name)), 1, 0644 | IPC_CREAT, true);
$GLOBALS['APC_SEMAPHORE_RESOURCES'][MMC_Name($name)] = $semid;
return sem_acquire($semid);
}
}
/**
* Create shared memory block
*/
private function attach()
{
$this->__key = ftok($this->__path, $this->__proj_id);
$this->__shm = shm_attach($this->__key, $this->__size);
//allocate shared memory
$this->__mutex = sem_get($this->__key, 1);
//create mutex with same key
}
function pleac_Sharing_Variables_in_Different_Processes()
{
// sharetest - test shared variables across forks
$SHM_KEY = ftok(__FILE__, chr(1));
$handle = sem_get($SHM_KEY);
$buffer = shm_attach($handle, 1024);
// The original recipe has an INT signal handler here. However, it
// causes erratic behavior with PHP, and PHP seems to do the right
// thing without it.
for ($i = 0; $i < 10; $i++) {
$child = pcntl_fork();
if ($child == -1) {
die('cannot fork');
} elseif ($child) {
$kids[] = $child;
// in case we care about their pids
} else {
squabble();
exit;
}
}
while (true) {
print 'Buffer is ' . shm_get_var($buffer, 1) . "\n";
sleep(1);
}
die('Not reached');
function squabble()
{
global $handle;
global $buffer;
$i = 0;
$pid = getmypid();
while (true) {
if (preg_match("/^{$pid}\\b/", shm_get_var($buffer, 1))) {
continue;
}
sem_acquire($handle);
$i++;
shm_put_var($buffer, 1, "{$pid} {$i}");
sem_release($handle);
}
}
// Buffer is 14357 1
// Buffer is 14355 3
// Buffer is 14355 4
// Buffer is 14354 5
// Buffer is 14353 6
// Buffer is 14351 8
// Buffer is 14351 9
// Buffer is 14350 10
// Buffer is 14348 11
// Buffer is 14348 12
// Buffer is 14357 10
// Buffer is 14357 11
// Buffer is 14355 13
// ...
}
function acquire($cacheId, $key, $block = true)
{
if (!$block) {
throw new \InvalidArgumentException("Non-blocking lock not supported by Sempahore");
}
$id = $this->getId($cacheId, $key);
$this->sem[$id] = $sem = sem_get($id);
sem_acquire($sem);
}
/**
* Constructor.
*
* @param string name File name to use to generate the semaphore key.
*/
public function __construct($name)
{
$this->count = 0;
$this->semKey = ftok($name, 'R');
$this->semId = sem_get($this->semKey);
if (!is_resource($this->semId)) {
throw new \Exception('Unable to create semaphore');
}
}
/**
* @param $key
* @param $size
* @throws InvalidArgumentException
* @return array
*/
protected function attach($key, $size)
{
if (!array_key_exists($key, $this->values)) {
if (!is_long($key)) {
throw new InvalidArgumentException(sprintf('Expected type long for "key" but "%s" given.', gettype($key)));
}
$this->values[$key] = array('shm' => shm_attach($key, $size), 'mutex' => sem_get($key, 1));
}
return $this->values[$key];
}
/**
* @param mixed $identity
* @param int $type
* @throws \RuntimeException
*/
public function __construct($identity, $type = self::IDX)
{
$this->identity = $identity;
$this->type = $type;
$this->generateIdentifier();
$this->generateSystemVIPCKey();
if (false === ($this->semaphore = @sem_get($this->systemVIPCKey))) {
throw new \RuntimeException("Unable to get semaphore");
}
}
public function get($key)
{
try {
if (!isset($this->pool[$key])) {
$this->pool[$key] = sem_get($key, 1, HESPER_IPC_PERMS, false);
}
return sem_acquire($this->pool[$key]);
} catch (BaseException $e) {
return null;
}
}
public function attach()
{
try {
$this->shm_id = shm_attach($this->shm_key, $this->shm_size);
// 初始化信号量
$this->sem = sem_get($this->sem_key, 1);
} catch (Exception $e) {
return FALSE;
}
return TRUE;
}
function lock_que_on($callback)
{
$mutex = sem_get(ftok(__FILE__, 'g'), 1);
sem_acquire($mutex);
try {
$res = call_user_func($callback);
} catch (Exception $e) {
}
sem_release($mutex);
return $res;
}
/**
* Updates the status of the crawler
*
* @param PHPCrawlerDocumentInfo $PageInfo The PHPCrawlerDocumentInfo-object of the last received document
* or NULL if no document was received.
* @param int $abort_reason One of the PHPCrawlerAbortReasons::ABORTREASON-constants if the crawling-process
* should get aborted, otherwise NULL
* @param string $first_content_url The first URL some content was found in (or NULL if no content was found so far).
*/
public function updateCrawlerStatus($PageInfo, $abort_reason = null, $first_content_url = null, $last_request_time = null)
{
PHPCrawlerBenchmark::start("updating_crawler_status");
// Set semaphore/lock if
if ($this->lock_status_updates == true) {
$sem_key = sem_get($this->crawler_uniqid);
sem_acquire($sem_key);
}
// Get current Status
$crawler_status = $this->getCrawlerStatus();
// Update status
if ($PageInfo != null) {
// Increase number of followed links
$crawler_status->links_followed++;
// Increase documents_received-counter
if ($PageInfo->received == true) {
$crawler_status->documents_received++;
}
// Increase bytes-counter
$crawler_status->bytes_received += $PageInfo->bytes_received + $PageInfo->header_bytes_received;
// Benchmarks
if ($PageInfo->error_occured == false) {
// server connect time
$crawler_status->sum_server_connect_time += $PageInfo->server_connect_time;
$crawler_status->sum_server_connects++;
// server response time
$crawler_status->sum_server_response_time += $PageInfo->server_response_time;
$crawler_status->sum_server_responses++;
// data transfer time
$crawler_status->sum_data_transfer_time += $PageInfo->data_transfer_time;
// unbuffered bytes read
$crawler_status->unbuffered_bytes_read += $PageInfo->unbuffered_bytes_read;
}
}
// Set abortreason
if ($abort_reason !== null) {
$crawler_status->abort_reason = $abort_reason;
}
// Set first_content_url
if ($first_content_url !== null) {
$crawler_status->first_content_url = $first_content_url;
}
// Set last request-time
if ($last_request_time !== null) {
$crawler_status->last_request_time = $last_request_time;
}
// Write crawler-status back
$this->setCrawlerStatus($crawler_status);
// Remove semaphore/lock
if ($this->lock_status_updates == true) {
sem_release($sem_key);
}
PHPCrawlerBenchmark::stop("updating_crawler_status");
}
public function __construct()
{
$shmkey = ftok(__FILE__, 't');
$this->shmId = shmop_open($shmkey, "c", 0644, $this->memSize);
$this->maxQSize = $this->memSize / $this->blockSize;
// 申請一个信号量
$this->semId = sem_get($shmkey, 1);
sem_acquire($this->semId);
// 申请进入临界区
$this->init();
}
private static function get_exclusive_by_semaphore()
{
if (JxBotExclusion::$sem = sem_get(ftok(__FILE__, "j"), 1)) {
if (!sem_acquire(JxBotExclusion::$sem, true)) {
return false;
}
return true;
}
throw new Exception("Couldn't acquire System V semaphore.");
return false;
}
/**
* Constructor.
*
* @param int $key The key
* @param int $acquires The number of processes that can acquire the semaphore simultaneously
*
* @throws \InvalidArgumentException When $acquires less than 1
* @throws \RuntimeException When unable to get semaphore
*/
public function __construct($key, $acquires = 1)
{
$acquires = (int) $acquires;
if ($acquires < 1) {
throw new \InvalidArgumentException(sprintf('Number of acquires (%d) cannot be less than 1.', $acquires));
}
$this->handle = sem_get((int) $key, (int) $acquires);
if (!is_resource($this->handle)) {
throw new \RuntimeException(sprintf('Unable to get semaphore by key "%s".', $key));
}
$this->locked = false;
}
/**
* On any *nix use the commands ipcs and ipcrm to work with the memory
* @return resource
*/
protected function _getSemIdentifier()
{
if (null !== $this->_semId) {
return $this->_semId;
}
$this->_semId = sem_get($this->getIndexerCodeCrc(), 8, 0666);
if (false === $this->_semId) {
Mage::throwException('FastIndexer: Cannot create semaphore id lock for ' . $this->getIndexerCode());
}
$this->_shmId = shm_attach($this->getIndexerCodeCrc(), 128);
return $this->_semId;
}
