/**
* get a lock
* @throws \Exception
*/
public function acquire()
{
if (!sem_acquire($this->lock_id)) {
throw new \RuntimeException('Cannot acquire semaphore: ' . $this->lock_id);
}
$this->locked = true;
}
/**
* 通过本机共享内存件来生成一个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;
}
public function acquire()
{
if (!sem_acquire($this->_semaphore)) {
throw new Sera_Exception("failed to acquire semaphore");
}
$this->_acquired = true;
}
/**
* Acquire a semaphore - blocks (if necessary) until the semaphore can be acquired.
* A process attempting to acquire a semaphore which it has already acquired will
* block forever if acquiring the semaphore would cause its max_acquire value to
* be exceeded.
*
* @return bool success
* @throws io.IOException
*/
public function acquire()
{
if (FALSE === sem_acquire($this->_hdl)) {
throw new IOException('Could not acquire semaphore ' . $this->key);
}
return TRUE;
}
function session_value($name, $index)
{
global $shm_key, $shm_var, $sem_id;
switch ($index) {
case 'config':
$shm_size = 859;
break;
case 'ipdata':
$shm_size = 30050;
break;
default:
$shm_size = 0;
}
sem_acquire($sem_id['shlock']);
$shm_id = shmop_open($shm_key[$index], 'c', 0644, $shm_size);
if ($name == 'update') {
$shm_data = serialize($shm_var[$index]);
shmop_write($shm_id, str_pad($shm_data, $shm_size, "", STR_PAD_RIGHT), 0);
} else {
$shm_data = shmop_read($shm_id, 0, $shm_size);
$shm_var[$index] = @unserialize($shm_data);
}
shmop_close($shm_id);
sem_release($sem_id['shlock']);
}
/**
* @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));
}
/**
* Try to acquire a semaphore.
*
* NOTE: sem_acquire will wait forever if a semaphore is not released
* for any reason. Therefor as of PHP version 5.6.1 the $nowait
* flag was introduced which could is used here. Further work may
* lead to an implementation which runs an interruptable version
* of sem_acquire without using the $nowait flag, e.g. a
* TimeoutThread
*
* @param $timeout timeout for acquiring a semaphore
* @throws TimerException
* @throws SemaphoreException
* @see Timer
*/
public function acquire($timeout = 30, $tries = 3)
{
// set and start the timer
$timer = null;
if (strncmp(gettype($timeout), "integer", 7) == 0 && $timeout > 0) {
$timer = new Timer($timeout);
}
if ($timer === null) {
$this->log(__METHOD__ . ": %.", array(new TimerException("creation failed")));
throw new TimerException("creation failed");
}
$timer->start();
// now try to acquire a semaphore
$acquired = false;
$try = 1;
while (!is_null($this->semaphore->get_sem_res()) && $acquired === false && $timer !== null && $try <= $this->semaphore_max_try) {
// use sem_acquire with $nowait flag to append a timer
// NOTE: warnings should be suppressed here any error should throw an
// exception
$acquired = @sem_acquire($this->semaphore->get_sem_res(), true);
// retart the timer
if ($timer->get() == 0 && $timer->get_timed_out()) {
$this->log(__METHOD__ . ": Acquiring. Try #%. Timer timed out.", array($try));
$try++;
$timer->start();
}
}
if ($acquired === false) {
$this->log(__METHOD__ . ": %.", array(new SemaphoreException("acquisition failed", 0)));
throw new SemaphoreException("acquisition failed", 0);
}
return $acquired;
}
/**
* Acquire a semaphore - blocks (if necessary) until the semaphore can be acquired.
* A process attempting to acquire a semaphore which it has already acquired will
* block forever if acquiring the semaphore would cause its max_acquire value to
* be exceeded.
*
* @return bool success
* @throws io.IOException
*/
public function acquire()
{
if (false === sem_acquire($this->_hdl)) {
throw new \io\IOException('Could not acquire semaphore ' . $this->key);
}
return true;
}
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);
}
/**
* 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);
}
/**
* @param $key
* @param int $size
* @return mixed
*/
public function get($key, $size = 10000)
{
$result = $this->attach($key, $size);
sem_acquire($result['mutex']);
$value = @shm_get_var($result['shm'], $key);
sem_release($result['mutex']);
return $value;
}
public function readShared()
{
sem_acquire($this->sem_id);
$data = shmop_read($this->shm_id, 0, $this->size);
$data = trim($data);
$data = unserialize($data);
return $data;
}
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);
}
}
/**
* @return bool
*/
public function acquire()
{
$result = sem_acquire($this->semaphore);
if (true === $result) {
$this->acquired = true;
}
return $result;
}
public function lock()
{
if (PHP_OS !== 'Linux') {
return;
}
sem_acquire($this->getSemaphoreId());
$this->locked = true;
}
/**
* Delete shared memory var
*/
public function del()
{
sem_acquire($this->__mutex);
//block until released
@shm_remove_var($this->__shm, $this->__key);
sem_release($this->__mutex);
//release mutex
}
/**
* Retorna numero
*/
public function getNumero()
{
if (!sem_acquire($this->_semaforo)) {
die('Error esperando al semaforo.');
}
$cantidad = $this->_ci->_marea_roja_desembarco_informe_model->maximoNumeroPorLaboratorio($this->_id_laboratorio);
return $cantidad + 1;
}
/**
* if an error like "not enough shared memory left" occurs then set sysvshm.init_mem to a higher value
* Lock process without blocking.
* This method allow protect multiple process running and fast lock validation.
*
*/
public function lock()
{
$success = sem_acquire($this->_getSemIdentifier());
shm_put_var($this->_shmId, $this->getIndexerCodeCrc(), $this->_getMicrotimeString());
if (false === $success) {
Mage::throwException('FastIndexer: Cannot acquire semaphore lock!');
}
$this->_isLocked = true;
}
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);
}
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;
}
}
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;
}
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;
}
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();
}
/** Begins a transaction. */
public final function begin()
{
if ($this->count > 0) {
++$this->count;
} else {
sem_acquire($this->semId);
$this->count = 1;
$this->rollBackOnly = false;
$this->doBegin();
}
}
/**
* 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 acquire()
{
if (!$this->acquired) {
$t = microtime(true);
$this->debug("Acquiring semaphore");
sem_acquire($this->semaphore);
$te = microtime(true) - $t;
$this->debug("Semaphore acquired (+%.4fs)", $te);
$this->start = microtime(true);
$this->acquired = true;
}
}
public function get($key)
{
try {
if (!isset($this->pool[$key])) {
$this->pool[$key] = sem_get($key, 1, ONPHP_IPC_PERMS, false);
}
return sem_acquire($this->pool[$key]);
} catch (BaseException $e) {
return null;
}
Assert::isUnreachable();
}
/**
* {@inheritdoc}
* @see Scalr_System_Cronjob_MultiProcess_DefaultWorker::startForking()
*/
function startForking($workQueue)
{
// Reopen DB connection after daemonizing
$this->db = $this->getContainer()->adodb;
// Check that time has come to cleanup dead servers
$doCleanup = false;
sem_acquire($this->cleanupSem);
try {
if (time() - (int) $this->lastCleanup->get(0) >= $this->cleanupInterval) {
$doCleanup = true;
$this->lastCleanup->put(0, time());
}
} catch (Exception $e) {
sem_release($this->cleanupSem);
}
sem_release($this->cleanupSem);
if ($doCleanup) {
$this->logger->info("Cleanup dead servers");
try {
$importing_servers = $this->db->GetAll("\n SELECT server_id FROM servers\n WHERE status IN(?, ?)\n AND `dtadded` < NOW() - INTERVAL 1 DAY\n ", array(SERVER_STATUS::IMPORTING, SERVER_STATUS::TEMPORARY));
foreach ($importing_servers as $ts) {
$dbServer = DBServer::LoadByID($ts['server_id']);
if ($dbServer->status == SERVER_STATUS::TEMPORARY) {
try {
$dbServer->terminate(DBServer::TERMINATE_REASON_TEMPORARY_SERVER_ROLE_BUILDER);
} catch (Exception $e) {
}
} else {
if ($dbServer->status == SERVER_STATUS::IMPORTING) {
$dbServer->Remove();
}
}
}
$pending_launch_servers = $this->db->GetAll("SELECT server_id FROM servers WHERE status=?", array(SERVER_STATUS::PENDING_LAUNCH));
try {
foreach ($pending_launch_servers as $ts) {
$DBServer = DBServer::LoadByID($ts['server_id']);
if ($DBServer->status == SERVER_STATUS::PENDING_LAUNCH) {
$account = Scalr_Account::init()->loadById($DBServer->clientId);
if ($account->status == Scalr_Account::STATUS_ACTIVE) {
Scalr::LaunchServer(null, $DBServer);
}
}
}
} catch (Exception $e) {
Logger::getLogger(LOG_CATEGORY::FARM)->error(sprintf("Can't load server with ID #'%s'", $ts['server_id'], $e->getMessage()));
}
} catch (Exception $e) {
$this->logger->fatal("Poller::cleanup failed: {$e->getMessage()}");
}
}
}
function execute()
{
set_error_handler('fragtable_error_handler');
define('FRAGTABLE_ROOT', dirname(__FILE__));
$HTTP_HOST = isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : 'NULL';
$HTTP_USER_AGENT = isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : 'NULL';
if (!isset($_SERVER['REQUEST_URI'])) {
trigger_error("'REQUEST_URI' not found", E_USER_WARNING);
}
$salt = $HTTP_USER_AGENT . $_SERVER['REQUEST_URI'];
$hashi = hexdec(substr(hash('crc32b', $salt), 0, 2));
$subject = "[{$HTTP_HOST}] DDoS WARNING!!";
$accucnt = 0;
$logfile = FRAGTABLE_ROOT . '/secure.log';
$shm_key['data'] = ftok(__FILE__, 't');
$shm_key['lock'] = ftok(__FILE__, 'u');
$sem_id = sem_get($shm_key['lock']);
$shm_size = 9626;
sem_acquire($sem_id);
$shm_id = shmop_open($shm_key['data'], 'c', 0644, $shm_size);
$shm_data = shmop_read($shm_id, 0, $shm_size);
$fragtable = @unserialize($shm_data);
if (!$fragtable) {
$fragtable = array();
}
$nowtime = time();
if (isset($fragtable[$hashi]) && $nowtime < $fragtable[$hashi][0] + self::$intervsl) {
$accucnt = $fragtable[$hashi][1] < 99 ? $fragtable[$hashi][1] + 1 : $fragtable[$hashi][1];
$acctime = $fragtable[$hashi][0];
} else {
$accucnt = 1;
$acctime = $nowtime;
}
$fragtable[$hashi] = array($acctime, $accucnt);
$shm_data = serialize($fragtable);
shmop_write($shm_id, str_pad($shm_data, $shm_size, "", STR_PAD_RIGHT), 0);
shmop_close($shm_id);
sem_release($sem_id);
$fragtable = $shm_data = NULL;
if ($accucnt > self::$threshold) {
if (!file_exists($logfile) || filesize($logfile) < 10 * 1024 * 1024) {
$message = sprintf("%s | %d | %d | %s | %s | %s\n", gmdate('Y-m-d H:i:s', $nowtime + self::$timezone * 3600), $acctime, $hashi, str_pad($_SERVER["REMOTE_ADDR"], 15, ' ', STR_PAD_RIGHT), "{$_SERVER['REQUEST_METHOD']} {$_SERVER['REQUEST_URI']} {$_SERVER['SERVER_PROTOCOL']}", $HTTP_USER_AGENT);
if (!file_exists($logfile) || $nowtime > filemtime($logfile) + 3600) {
@mail(self::$mailto, $subject, $message);
}
file_put_contents($logfile, $message, FILE_APPEND | LOCK_EX);
}
header('HTTP/1.1 503 Service Temporarily Unavailable');
die('<h1>Service Temporarily Unavailable</h1>');
}
restore_error_handler();
}
function obtainLock($sem, $i)
{
echo "process {$i} is getting the sem \n";
$res = sem_acquire($sem, true);
sleep(1);
if (!$res) {
echo "process {$i} unable to get sem. \n";
} else {
echo "process {$i} successfully got the sem \n";
sem_release($sem);
}
exit;
}
