public static function file_get_contents(FileSyncKey $key, $fetch_from_remote_if_no_local = true, $strict = true)
{
$cacheStore = kCacheManager::getCache(kCacheManager::MC_GLOBAL_FILESYNC);
if ($cacheStore) {
$cacheKey = self::CACHE_KEY_PREFIX . "{$key->object_id}_{$key->object_type}_{$key->object_sub_type}_{$key->version}";
$result = $cacheStore->get($cacheKey);
if ($result) {
KalturaLog::log("returning from cache, key [{$cacheKey}] size [" . strlen($result) . "]");
return $result;
}
}
KalturaLog::log(__METHOD__ . " - key [{$key}], fetch_from_remote_if_no_local [{$fetch_from_remote_if_no_local}], strict [{$strict}]");
list($file_sync, $local) = self::getReadyFileSyncForKey($key, $fetch_from_remote_if_no_local, $strict);
if ($file_sync) {
$file_sync = self::resolve($file_sync);
}
if ($file_sync) {
$result = self::getContentsByFileSync($file_sync, $local, $fetch_from_remote_if_no_local, $strict);
if ($cacheStore && $result && strlen($result) < self::MAX_CACHED_FILE_SIZE && !in_array($key->object_type, self::$uncachedObjectTypes)) {
KalturaLog::log("saving to cache, key [{$cacheKey}] size [" . strlen($result) . "]");
$cacheStore->set($cacheKey, $result, self::FILE_SYNC_CACHE_EXPIRY);
}
return $result;
}
KalturaLog::log(__METHOD__ . " - FileSync not found");
return null;
}
/**
* Get value from cache for the given key
* @param string $key
*/
private static function getFromCache($key, $roleCacheDirtyAt)
{
if (!self::useCache()) {
return null;
}
self::$cacheStores = array();
foreach (self::$cacheLayers as $cacheLayer) {
$cacheStore = kCacheManager::getCache($cacheLayer);
if (!$cacheStore) {
continue;
}
$value = $cacheStore->get(self::getCacheKeyPrefix() . $key);
// try to fetch from cache
if (!$value || !isset($value['updatedAt']) || $value['updatedAt'] < $roleCacheDirtyAt) {
self::$cacheStores[] = $cacheStore;
continue;
}
KalturaLog::debug("Found a cache value for key [{$key}] in layer [{$cacheLayer}]");
self::storeInCache($key, $value);
// store in lower cache layers
self::$cacheStores[] = $cacheStore;
// cache is updated - init from cache
unset($value['updatedAt']);
return $value;
}
KalturaLog::debug("No cache value found for key [{$key}]");
return null;
}
protected static function initGlobalMemcache()
{
if (self::$s_memcacheInited) {
return;
}
self::$s_memcacheInited = true;
self::$s_memcacheKeys = kCacheManager::getCache(kCacheManager::MC_GLOBAL_KEYS);
if (self::$s_memcacheKeys === null) {
// no reason to init the queries server, the query cache won't be used anyway
return;
}
self::$s_memcacheQueries = kCacheManager::getCache(kCacheManager::MC_GLOBAL_QUERIES);
}
/**
* @return array<kBaseCacheWrapper>
*/
protected static function getStores($cacheType = kCacheManager::CACHE_TYPE_RESPONSE_PROFILE)
{
if (isset(self::$cacheStores[$cacheType])) {
return self::$cacheStores[$cacheType];
}
self::$cacheStores[$cacheType] = array();
$cacheSections = kCacheManager::getCacheSectionNames($cacheType);
if (is_array($cacheSections)) {
foreach ($cacheSections as $cacheSection) {
$cacheStore = kCacheManager::getCache($cacheSection);
if ($cacheStore) {
self::$cacheStores[$cacheType][] = $cacheStore;
}
}
}
return self::$cacheStores[$cacheType];
}
private function calculateCacheKey()
{
$this->getKsData();
$this->_playbackContext = isset($this->_params['playbackContext']) ? $this->_params['playbackContext'] : null;
unset($this->_params['playbackContext']);
$this->_params['___cache___protocol'] = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on' ? "https" : "http";
$this->_params['___cache___host'] = @$_SERVER['HTTP_HOST'];
$this->_params['___cache___version'] = self::CACHE_VERSION;
// take only the hostname part of the referrer parameter of baseEntry.getContextData
if (isset($this->_params['referrer'])) {
$referrer = base64_decode(str_replace(" ", "+", $this->_params['referrer']));
if (!is_string($referrer)) {
$referrer = "";
}
unset($this->_params['referrer']);
} else {
$referrer = self::getHttpReferrer();
}
$this->_referrers[] = $referrer;
$this->finalizeCacheKey();
$this->addExtraFields();
$this->_cacheWrapper = kCacheManager::getCache(kCacheManager::FS_PLAY_MANIFEST);
}
protected function warmCache($key)
{
if (self::$_cacheWarmupInitiated) {
return;
}
self::$_cacheWarmupInitiated = true;
$key = "cache-warmup-{$key}";
$cacheSections = kCacheManager::getCacheSectionNames(kCacheManager::CACHE_TYPE_API_WARMUP);
if (!$cacheSections) {
return;
}
foreach ($cacheSections as $cacheSection) {
$cacheStore = kCacheManager::getCache($cacheSection);
if (!$cacheStore) {
return;
}
// abort warming if a previous warmup started less than 10 seconds ago
if ($cacheStore->get($key) !== false) {
return;
}
// flag we are running a warmup for the current request
$cacheStore->set($key, true, self::WARM_CACHE_TTL);
}
$uri = $_SERVER["REQUEST_URI"];
$fp = fsockopen(kConf::get('api_cache_warmup_host'), 80, $errno, $errstr, 1);
if ($fp === false) {
error_log("warmCache - Couldn't open a socket [" . $uri . "]", 0);
return;
}
$method = $_SERVER["REQUEST_METHOD"];
$out = "{$method} {$uri} HTTP/1.1\r\n";
$sentHeaders = self::getRequestHeaders();
$sentHeaders["Connection"] = "Close";
// mark request as a warm cache request in order to disable caching and pass the http/https protocol (the warmup always uses http)
$sentHeaders[self::WARM_CACHE_HEADER] = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on' ? "https" : "http";
// if the request wasn't proxied pass the ip on the X-FORWARDED-FOR header
$ipHeader = infraRequestUtils::getSignedIpAddressHeader();
if ($ipHeader) {
list($headerName, $headerValue) = $ipHeader;
$sentHeaders[$headerName] = $headerValue;
}
foreach ($sentHeaders as $header => $value) {
$out .= "{$header}:{$value}\r\n";
}
$out .= "\r\n";
if ($method == "POST") {
$postParams = array();
foreach ($_POST as $key => &$val) {
if (is_array($val)) {
$val = implode(',', $val);
}
$postParams[] = $key . '=' . urlencode($val);
}
$out .= implode('&', $postParams);
}
fwrite($fp, $out);
fclose($fp);
}
protected function storeExtraFields()
{
if (!$this->_cacheKeyDirty) {
return;
}
// no extra fields were added to the cache
$extraFieldsCache = kCacheManager::getCache(kCacheManager::APC);
if (!$extraFieldsCache) {
self::disableCache();
return;
}
if ($extraFieldsCache->set(self::EXTRA_KEYS_PREFIX . $this->_originalCacheKey, $this->_extraFields, self::CONDITIONAL_CACHE_EXPIRY) === false) {
self::disableCache();
return;
}
$this->finalizeCacheKey();
// update the cache key to include the extra fields
}
/**
* Get value from cache for the given key
* @param string $key
*/
private static function getFromCache($key, $roleCacheDirtyAt)
{
if (!self::useCache()) {
return null;
}
self::$cacheStores = array();
$cacheLayers = kCacheManager::getCacheSectionNames(kCacheManager::CACHE_TYPE_PERMISSION_MANAGER);
foreach ($cacheLayers as $cacheLayer) {
$cacheStore = kCacheManager::getCache($cacheLayer);
if (!$cacheStore) {
continue;
}
$cacheRole = $cacheStore->get(self::getCacheKeyPrefix() . $key);
// try to fetch from cache
if (!$cacheRole || !isset($cacheRole['updatedAt']) || $cacheRole['updatedAt'] < $roleCacheDirtyAt) {
self::$cacheStores[] = $cacheStore;
continue;
}
$map = $cacheStore->get(self::getCacheKeyPrefix() . $cacheRole['mapHash']);
// try to fetch from cache
if (!$map) {
self::$cacheStores[] = $cacheStore;
continue;
}
KalturaLog::debug("Found a cache value for key [{$key}] map hash [" . $cacheRole['mapHash'] . "] in layer [{$cacheLayer}]");
self::storeInCache($key, $cacheRole, $map);
// store in lower cache layers
self::$cacheStores[] = $cacheStore;
return $map;
}
KalturaLog::debug("No cache value found for key [{$key}]");
return null;
}
public static function getSecretsFromCache($partnerId)
{
$cacheSections = kCacheManager::getCacheSectionNames(kCacheManager::CACHE_TYPE_PARTNER_SECRETS);
if (!$cacheSections) {
return null;
}
$cacheKey = self::getSecretsCacheKey($partnerId);
$lowerStores = array();
foreach ($cacheSections as $cacheSection) {
$cacheStore = kCacheManager::getCache($cacheSection);
if (!$cacheStore) {
continue;
}
$secrets = $cacheStore->get($cacheKey);
if (!$secrets) {
$lowerStores[] = $cacheStore;
continue;
}
foreach ($lowerStores as $cacheStore) {
$cacheStore->set($cacheKey, $secrets);
}
return $secrets;
}
return null;
}
protected function getKSVersionAndSecret($partnerId)
{
$result = parent::getKSVersionAndSecret($partnerId);
if ($result) {
return $result;
}
$partner = PartnerPeer::retrieveByPK($partnerId);
if (!$partner) {
return array(1, null);
}
// VERY big problem
$ksVersion = $partner->getKSVersion();
$cacheKey = self::getSecretsCacheKey($partnerId);
$cacheSections = kCacheManager::getCacheSectionNames(kCacheManager::CACHE_TYPE_PARTNER_SECRETS);
foreach ($cacheSections as $cacheSection) {
$cacheStore = kCacheManager::getCache($cacheSection);
if (!$cacheStore) {
continue;
}
$cacheStore->set($cacheKey, array($partner->getAdminSecret(), $partner->getSecret(), $ksVersion));
}
return array($ksVersion, $partner->getAdminSecret());
}
/**
* @return KalturaPDO
*/
public static function getSphinxConnection($read = true)
{
if (self::$sphinxConnection) {
return self::$sphinxConnection;
}
$sphinxDS = isset(self::$config['sphinx_datasources']['datasources']) ? self::$config['sphinx_datasources']['datasources'] : array(self::DB_CONFIG_SPHINX);
$cacheExpiry = isset(self::$config['sphinx_datasources']['cache_expiry']) ? self::$config['sphinx_datasources']['cache_expiry'] : 300;
$connectTimeout = isset(self::$config['sphinx_datasources']['connect_timeout']) ? self::$config['sphinx_datasources']['connect_timeout'] : 1;
$stickySessionExpiry = isset(self::$config['sphinx_datasources']['sticky_session_timeout']) ? self::$config['sphinx_datasources']['sticky_session_timeout'] : 600;
$stickySessionKey = 'StickySession:' . kCurrentContext::$user_ip;
$cache = kCacheManager::getCache(kCacheManager::MC_GLOBAL_QUERIES);
if ($cache) {
$key = $cache->get($stickySessionKey);
if ($key) {
$connection = self::getConnection($key, $cacheExpiry, $connectTimeout);
if (!is_null($connection)) {
return $connection;
}
}
}
// loop twice, on first iteration try only connections not marked as failed
// in case all connections failed, try all connections on second iteration
$iteration = 2;
while ($iteration--) {
$count = count($sphinxDS);
$offset = mt_rand(0, $count - 1);
while ($count--) {
$key = $sphinxDS[($count + $offset) % count($sphinxDS)];
$cacheKey = "sphinxCon:" . $key;
if (function_exists('apc_fetch')) {
if (!$iteration) {
// on second iteration reset failed connection flag
apc_store($cacheKey, 0);
} else {
if (apc_fetch($cacheKey)) {
// if connection failed to connect in the past mark it
continue;
}
}
}
$connection = self::getConnection($key, $cacheExpiry, $connectTimeout);
if (!$read && $cache) {
$cache->set($stickySessionKey, $key, $stickySessionExpiry);
}
if (!is_null($connection)) {
return $connection;
}
}
}
KalturaLog::debug("getSphinxConnection: Failed to connect to any Sphinx config");
throw new Exception('Failed to connect to any Sphinx config');
}
private static function getMaxInvalidationTime($invalidationKeys)
{
$memcache = kCacheManager::getCache(kCacheManager::MC_GLOBAL_KEYS);
if (!$memcache) {
return null;
}
$cacheResult = $memcache->multiGet($invalidationKeys);
if ($cacheResult === false) {
return null;
}
// failed to get the invalidation keys
if (!$cacheResult) {
return 0;
}
// no invalidation keys - no changes occured
return max($cacheResult);
}
protected function isKSInvalidated()
{
if (strpos($this->privileges, self::PRIVILEGE_ACTIONS_LIMIT) !== false) {
return null;
}
// cannot validate action limited KS at this level
$memcache = kCacheManager::getCache(kCacheManager::MC_GLOBAL_KEYS);
if (!$memcache) {
return null;
}
// failed to connect to memcache or memcache not enabled
$ksKey = self::INVALID_SESSION_KEY_PREFIX . $this->hash;
$keysToGet = array(self::INVALID_SESSIONS_SYNCED_KEY, $ksKey);
$cacheResult = $memcache->multiGet($keysToGet);
if ($cacheResult === false) {
return null;
}
// failed to get the keys
if (!array_key_exists(self::INVALID_SESSIONS_SYNCED_KEY, $cacheResult) || !$cacheResult[self::INVALID_SESSIONS_SYNCED_KEY]) {
return null;
}
// invalid sessions not synched to memcache
if (array_key_exists($ksKey, $cacheResult)) {
return true;
}
// the session is invalid
return false;
}