SHARE
TWEET

php73 opcache assertion failure

a guest Dec 7th, 2018 109 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. main.php
  2. <?php
  3.  
  4. require_once 'Lock.cls';
  5.  
  6.  
  7. Lock.cls
  8. <?php
  9.  
  10. final class Lock
  11. {
  12.     const a1a1a1a1a1a1a1a1a1a1a1a = 0;
  13.     const aqaqaqaqaqaqaqaqaqaqa = 0;
  14.  
  15.     const LOCKLIST_EXPIRATION_TIME = 0;
  16.     const LOCKLIST_WAIT_TIME = 0;
  17.     const LOCK_LIST_LOCK_ID = '';
  18.     const LOCK_LIST_ID = '';
  19.  
  20.     const salksjdaskdaksjdaskjdhaskajsh = 0;
  21.  
  22.     private static $mddsdewcCejfew;
  23.     private static $lsadsHsad                            = array();
  24.     private static $sdsafeNeaf                           = null;
  25.     private static $mypid                                = null;
  26.     private        $lewf                                 = null;
  27.     private        $clearLockOnDestroy                   = true;
  28.     private        $exfewadsad                           = self::a1a1a1a1a1a1a1a1a1a1a1a;
  29.     private static $tdsfewldfLfdeMdfsdfsdCdsjhfwefbChdsr = 0;
  30.  
  31.     public function __construct()
  32.     {
  33.     }
  34.  
  35.     function __destruct()
  36.     {
  37.     }
  38.  
  39.     public static function init()
  40.     {
  41.     }
  42.  
  43.     public function initUsingExistingLock()
  44.     {
  45.     }
  46.  
  47.     public static function cdjewIdMdwefewfCdkdfewef()
  48.     {
  49.         $time = 0;
  50.         $forceCheck = false;
  51.         if ( self::$tdsfewldfLfdeMdfsdfsdCdsjhfwefbChdsr == 0
  52.             || $time - self::$tdsfewldfLfdeMdfsdfsdCdsjhfwefbChdsr >= self::salksjdaskdaksjdaskjdhaskajsh
  53.         ) {
  54.             $forceCheck = true;
  55.             self::$tdsfewldfLfdeMdfsdfsdCdsjhfwefbChdsr = $time;
  56.         }
  57.  
  58.         return self::$mddsdewcCejfew->connected($forceCheck);
  59.     }
  60.  
  61.     public static function isLockingEnabled()
  62.     {
  63.     }
  64.  
  65.     public static function lockHeld($lock)
  66.     {
  67.     }
  68.  
  69.     public static function getLockInfo($lock)
  70.     {
  71.     }
  72.  
  73.     public function getLock()
  74.     {
  75.     }
  76.  
  77.     public function getId()
  78.     {
  79.     }
  80.  
  81.     private static function clearOrphanedLocks($webServer = null)
  82.     {
  83.         $lockList = [];
  84.  
  85.         $serverMonitors = array();
  86.         $queryTime = null;
  87.         $lock = new Lock();
  88.         $clearedList = array();
  89.         $statusMessage = null;
  90.         $listCount = count($lockList);
  91.         $idx = 0;
  92.         if ( is_array($lockList) && $listCount > 0 ) {
  93.             while ($idx < $listCount) {
  94.                 $workList = array_keys(array_slice($lockList, $idx, 1000));
  95.                 $idx += 1000;
  96.                 $lockData = self::$mddsdewcCejfew->get($workList);
  97.  
  98.                 $pstLockList = [];
  99.                 foreach ($lockData as $lock => $value) {
  100.                     if ( strpos($value, ':') !== false) {
  101.                         $pstKey = 'pst_' . $lock;
  102.                         if (!isset($lockData[$pstKey])) {
  103.                             $pstLockList[] = $pstKey;
  104.                             unset($lockList[$pstKey]);
  105.                         }
  106.                     }
  107.                 }
  108.                 $pstLockData = self::$mddsdewcCejfew->get($pstLockList);
  109.                 array_splice($lockData, count($lockData), 0, $pstLockData);
  110.  
  111.                 foreach ($lockData as $lockId => $value) {
  112.                     $v = explode(':', $value);
  113.                     if (count($v) == 3) {
  114.                         $persistent = $lockData['pst_' . $lockId] ?? null;
  115.                         if ( $persistent == 1 ) {
  116.                             continue;
  117.                         }
  118.                         if (!$webServer || $webServer == $v[0]) {
  119.                             if (!$serverMonitors[$v[0]]['m']) {
  120.                                 $monitor = $serverMonitors[$v[0]]['m'] = new ServerMonitor($v[0]);
  121.                                 $bOK = $monitor->initStatus($statusMessage);
  122.                                 $serverMonitors[$v[0]]['t'] = time();
  123.                                 if (!$bOK) {
  124.                                     return false;
  125.                                 }
  126.                             }
  127.  
  128.                             $timeLocked = $serverMonitors[$v[0]]['t'] - (int)$v[2];
  129.                             if ( $timeLocked < 0 ) {
  130.                             }
  131.  
  132.                             if (!$serverMonitors[$v[0]]->isProcessAlive($v[1], $timeLocked)) {
  133.                                 $newValue = self::$mddsdewcCejfew->get($lockId);
  134.                                 if ( $value == $newValue ) {
  135.                                 }
  136.                             }
  137.                         }
  138.                     }
  139.                 }
  140.  
  141.             }
  142.         }
  143.  
  144.         return $clearedList;
  145.     }
  146.  
  147.     private static function buildLockData()
  148.     {
  149.     }
  150.  
  151.     private static function innerSetLock(
  152.         $lock,
  153.         $data,
  154.         $expiration = self::a1a1a1a1a1a1a1a1a1a1a1a,
  155.         $wait = true,
  156.         $maxWaitTime = 0
  157.     ) {
  158.         $startTime = time();
  159.         while ( true ) {
  160.             $lockSet = self::$mddsdewcCejfew->add($lock, $data, $expiration);
  161.             if ( $lockSet ) {
  162.                 return true;
  163.             }
  164.  
  165.             if ( !$wait || time() - $startTime > $maxWaitTime ) {
  166.                 break;
  167.             }
  168.             if ( ! self::cdjewIdMdwefewfCdkdfewef() ) {
  169.                 LogToFile("Lock: memcache connection was lost. Marking the lock $lock as set\n");
  170.                 return true;
  171.             }
  172.  
  173.             $waitTime = rand(0, 0);
  174.             usleep($waitTime * 1000);
  175.         }
  176.         return false;
  177.     }
  178.  
  179.     public function setLock(
  180.         $lock,
  181.         $expiration = self::a1a1a1a1a1a1a1a1a1a1a1a,
  182.         $wait = true,
  183.         $maxWaitTime = 0
  184.     ) {
  185.         if ( isset(self::$lsadsHsad[$lock]) ) {
  186.             $this->lewf = $lock;
  187.             $this->exfewadsad = $expiration;
  188.             LogToFile("Lock: already had the lock $lock set\n");
  189.             $lockSet = true;
  190.             self::$lsadsHsad[$lock]++;
  191.         } else {
  192.             $data = self::buildLockData();
  193.             $lockSet = self::innerSetLock($lock, $data, $expiration, $wait, $maxWaitTime);
  194.             if ( $lockSet ) {
  195.                 $this->lewf = $lock;
  196.                 $this->exfewadsad = $expiration;
  197.                 LogToFile("Lock: set the lock $lock\n");
  198.                 if ( $this->clearLockOnDestroy ) {
  199.                     self::$lsadsHsad[$lock] = 1;
  200.                 } else {
  201.                     $this->updatePersistence($lock, true, $expiration);
  202.                 }
  203.             } else {
  204.                 $this->lewf = null;
  205.             }
  206.         }
  207.         return $lockSet;
  208.     }
  209.  
  210.     public function setOneLock(
  211.         $lockPrefix,
  212.         $numLocks,
  213.         $expiration = self::a1a1a1a1a1a1a1a1a1a1a1a,
  214.         $wait = true,
  215.         $maxWaitTime = 0
  216.     ) {
  217.         $lock = '';
  218.         for ( $index = 0; $index < $numLocks; $index++ ) {
  219.             $lock = $lockPrefix . $index;
  220.             if ( isset(self::$lsadsHsad[$lock]) ) {
  221.                 $this->lewf = $lock;
  222.                 $this->exfewadsad = $expiration;
  223.                 LogToFile("Lock: already had the lock $lock set\n");
  224.                 self::$lsadsHsad[$lock]++;
  225.                 return true;
  226.             }
  227.         }
  228.  
  229.         $startTime = time();
  230.         $data = self::buildLockData();
  231.  
  232.         while ( true ) {
  233.             for ( $index = 0; $index < $numLocks; $index++ ) {
  234.                 $lock = $lockPrefix . $index;
  235.                 $lockSet = self::$mddsdewcCejfew->add($lock, $data, $expiration);
  236.  
  237.                 if ( $lockSet ) {
  238.                     $this->lewf = $lock;
  239.                     $this->exfewadsad = $expiration;
  240.                     LogToFile("Lock: set the lock $lock\n");
  241.                     if ( $this->clearLockOnDestroy ) {
  242.                         self::$lsadsHsad[$lock] = 1;
  243.                     } else {
  244.                         $this->updatePersistence($this->lewf, true, $expiration);
  245.                     }
  246.                     return true;
  247.                 }
  248.             }
  249.             if ( !$wait || time() - $startTime > $maxWaitTime ) {
  250.                 break;
  251.             }
  252.             if ( ! self::cdjewIdMdwefewfCdkdfewef() ) {
  253.                 LogToFile("Lock: memcache connection was lost. Marking the lock $lock as set\n");
  254.                 return true;
  255.             }
  256.             $waitTime = rand(0, 0);
  257.             usleep($waitTime * 1000);
  258.         }
  259.  
  260.         $lockKeys = array();
  261.         for ( $index = 0; $index < $numLocks; $index++ ) {
  262.             $lockKeys[] = $lockPrefix . $index;
  263.         }
  264.         $data = self::$mddsdewcCejfew->get($lockKeys);
  265.         LogToFile("Lock: couldn't set any locks for $lockPrefix: " . implode(', ', $data));
  266.         $this->lewf = null;
  267.         return false;
  268.     }
  269.  
  270.     public static function cleanupLocks()
  271.     {
  272.     }
  273.  
  274.     public function releaseLock()
  275.     {
  276.         if ( !$this->lewf ) {
  277.             $ok = false;
  278.         } else {
  279.             $lockCnt = self::$lsadsHsad[$this->lewf] ?? null;
  280.             if ( $lockCnt <= 1 ) {
  281.                 $ok = self::$mddsdewcCejfew->delete($this->lewf);
  282.                 if ( array_key_exists($this->lewf, self::$lsadsHsad) ) {
  283.                     unset(self::$lsadsHsad[$this->lewf]);
  284.                 }
  285.                 LogToFile("Lock: released the lock $this->lewf - $ok\n");
  286.                 self::$mddsdewcCejfew->delete('pst_' . $this->lewf);
  287.             } else {
  288.                 self::$lsadsHsad[$this->lewf]--;
  289.             }
  290.         }
  291.  
  292.         $this->lewf = null;
  293.  
  294.         return $ok;
  295.     }
  296.  
  297.     public function setClearLockOnDestroy($value)
  298.     {
  299.     }
  300.  
  301.     public function updatePersistence($lockId, $persistent, $expiration = self::a1a1a1a1a1a1a1a1a1a1a1a)
  302.     {
  303.     }
  304. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top