Пример #1
0
 /**
  * Start an impersonated session with Kaltura's server.
  * The result KS is the session key that you should pass to all services that requires a ticket.
  * 
  * @action impersonate
  * @param string $secret Remember to provide the correct secret according to the sessionType you want
  * @param int $impersonatedPartnerId
  * @param string $userId
  * @param KalturaSessionType $type Regular session or Admin session
  * @param int $partnerId
  * @param int $expiry KS expiry time in seconds
  * @param string $privileges 
  * @return string
  *
  * @throws APIErrors::START_SESSION_ERROR
  */
 function impersonateAction($secret, $impersonatedPartnerId, $userId = "", $type = 0, $partnerId = null, $expiry = 86400, $privileges = null)
 {
     KalturaResponseCacher::disableCache();
     // verify that partnerId exists and is in correspondence with given secret
     $result = myPartnerUtils::isValidSecret($partnerId, $secret, "", $expiry, $type);
     if ($result !== true) {
         throw new KalturaAPIException(APIErrors::START_SESSION_ERROR, $partnerId);
     }
     // verify partner is allowed to start session for another partner
     if (!myPartnerUtils::allowPartnerAccessPartner($partnerId, $this->partnerGroup(), $impersonatedPartnerId)) {
         throw new KalturaAPIException(APIErrors::START_SESSION_ERROR, $partnerId);
     }
     // get impersonated partner
     $impersonatedPartner = PartnerPeer::retrieveByPK($impersonatedPartnerId);
     if (!$impersonatedPartner) {
         // impersonated partner could not be fetched from the DB
         throw new KalturaAPIException(APIErrors::START_SESSION_ERROR, $partnerId);
     }
     // set the correct secret according to required session type
     if ($type == KalturaSessionType::ADMIN) {
         $impersonatedSecret = $impersonatedPartner->getAdminSecret();
     } else {
         $impersonatedSecret = $impersonatedPartner->getSecret();
     }
     // make sure the secret fits the one in the partner's table
     $ks = "";
     $result = kSessionUtils::startKSession($impersonatedPartner->getId(), $impersonatedSecret, $userId, $ks, $expiry, $type, "", $privileges, $partnerId);
     if ($result >= 0) {
         return $ks;
     } else {
         throw new KalturaAPIException(APIErrors::START_SESSION_ERROR, $partnerId);
     }
 }
Пример #2
0
 /**
  * Get license for encrypted content playback
  * 
  * @action getLicense
  * @param string $flavorAssetId
  * @param string $referrer 64base encoded  
  * @return string $response
  * 
  */
 public function getLicenseAction($flavorAssetId, $referrer = null)
 {
     KalturaResponseCacher::disableCache();
     KalturaLog::debug('get license for flavor asset: ' . $flavorAssetId);
     try {
         $requestParams = requestUtils::getRequestParams();
         if (!array_key_exists(WidevineLicenseProxyUtils::ASSETID, $requestParams)) {
             KalturaLog::err('assetid is missing on the request');
             return WidevineLicenseProxyUtils::createErrorResponse(KalturaWidevineErrorCodes::WIDEVINE_ASSET_ID_CANNOT_BE_NULL, 0);
         }
         $wvAssetId = $requestParams[WidevineLicenseProxyUtils::ASSETID];
         $this->validateLicenseRequest($flavorAssetId, $wvAssetId, $referrer);
         $privileges = null;
         $isAdmin = false;
         if (kCurrentContext::$ks_object) {
             $privileges = kCurrentContext::$ks_object->getPrivileges();
             $isAdmin = kCurrentContext::$ks_object->isAdmin();
         }
         $response = WidevineLicenseProxyUtils::sendLicenseRequest($requestParams, $privileges, $isAdmin);
     } catch (KalturaWidevineLicenseProxyException $e) {
         KalturaLog::err($e);
         $response = WidevineLicenseProxyUtils::createErrorResponse($e->getWvErrorCode(), $wvAssetId);
     } catch (Exception $e) {
         KalturaLog::err($e);
         $response = WidevineLicenseProxyUtils::createErrorResponse(KalturaWidevineErrorCodes::GENERAL_ERROR, $wvAssetId);
     }
     WidevineLicenseProxyUtils::printLicenseResponseStatus($response);
     return $response;
 }
Пример #3
0
 /**
  * 
  * @action getUploadedFileTokenByFileName
  * @param string $fileName
  * @return KalturaUploadResponse
  */
 function getUploadedFileTokenByFileNameAction($fileName)
 {
     KalturaResponseCacher::disableConditionalCache();
     $res = new KalturaUploadResponse();
     $ksUnique = md5($this->getKs()->toSecureString());
     $uniqueId = md5($fileName);
     $ext = pathinfo($fileName, PATHINFO_EXTENSION);
     $token = $ksUnique . "_" . $uniqueId . "." . $ext;
     $entryFullPath = myUploadUtils::getUploadPath($token, "", null, strtolower($ext));
     // filesync ok
     if (!file_exists($entryFullPath)) {
         throw new KalturaAPIException(KalturaErrors::UPLOADED_FILE_NOT_FOUND_BY_TOKEN);
     }
     $res->uploadTokenId = $token;
     $res->fileSize = kFile::fileSize($entryFullPath);
     return $res;
 }
Пример #4
0
function setCacheExpiry($entriesCount, $feedId)
{
    $expiryArr = kConf::hasMap("v3cache_getfeed_expiry") ? kConf::getMap("v3cache_getfeed_expiry") : array();
    foreach ($expiryArr as $item) {
        if ($item["key"] == "partnerId" && $item["value"] == kCurrentContext::$partner_id || $item["key"] == "feedId" && $item["value"] == $feedId) {
            KalturaResponseCacher::setExpiry($item["expiry"]);
            return;
        }
    }
    $expiry = kConf::get("v3cache_getfeed_default_cache_time_frame", 'local', 86400);
    if (kConf::hasParam("v3cache_getfeed_short_limits_array")) {
        $shortLimits = kConf::get("v3cache_getfeed_short_limits_array");
    } else {
        $shortLimits = array(50 => 900, 100 => 1800, 200 => 3600, 400 => 7200);
    }
    foreach ($shortLimits as $numOfEntries => $cacheTimeFrame) {
        if ($entriesCount <= $numOfEntries) {
            $expiry = min($expiry, $cacheTimeFrame);
        }
    }
    KalturaResponseCacher::setExpiry($expiry);
}
 public function execute($input_parameters = null)
 {
     if (class_exists('KalturaResponseCacher')) {
         KalturaResponseCacher::disableConditionalCache();
     }
     $search = array();
     $replace = array();
     if (is_null($input_parameters)) {
         $search = array_reverse(array_keys($this->values));
         $replace = array_reverse($this->values);
     } else {
         $i = 1;
         foreach ($input_parameters as $value) {
             $search[] = ':p' . $i++;
             if (is_null($value)) {
                 $replace[] = "NULL";
             } else {
                 $replace[] = "'{$value}'";
             }
         }
         $search = array_reverse($search);
         $replace = array_reverse($replace);
     }
     $sql = str_replace($search, $replace, $this->queryString);
     KalturaLog::debug($sql);
     $sqlStart = microtime(true);
     if (self::$dryRun) {
         KalturaLog::debug("Sql dry run - " . (microtime(true) - $sqlStart) . " seconds");
     } else {
         try {
             parent::execute($input_parameters);
         } catch (PropelException $pex) {
             KalturaLog::alert($pex->getMessage());
             throw new PropelException("Database error");
         }
         KalturaLog::debug("Sql took - " . (microtime(true) - $sqlStart) . " seconds");
     }
 }
 /**
  *
  * @action getFaspUrl
  * @param string $flavorAssetId
  * @throws KalturaAPIException
  * @return string
  */
 function getFaspUrlAction($flavorAssetId)
 {
     KalturaResponseCacher::disableCache();
     $assetDb = assetPeer::retrieveById($flavorAssetId);
     if (!$assetDb || !$assetDb instanceof flavorAsset) {
         throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND, $flavorAssetId);
     }
     if (!$assetDb->isLocalReadyStatus()) {
         throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_IS_NOT_READY);
     }
     $syncKey = $assetDb->getSyncKey(flavorAsset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
     /* @var $fileSync FileSync */
     list($fileSync, $isFileSyncLocal) = kFileSyncUtils::getReadyFileSyncForKey($syncKey);
     $filePath = $fileSync->getFilePath();
     $transferUser = $this->getFromAsperaConfig('transfer_user');
     $transferHost = $this->getFromAsperaConfig('transfer_host');
     $asperaNodeApi = new AsperaNodeApi($this->getFromAsperaConfig('node_api_user'), $this->getFromAsperaConfig('node_api_password'), $this->getFromAsperaConfig('node_api_host'), $this->getFromAsperaConfig('node_api_port'));
     $options = array('transfer_requests' => array('transfer_request' => array('remote_host' => $transferHost)));
     $tokenResponse = $asperaNodeApi->getToken($filePath, $options);
     $token = $tokenResponse->transfer_spec->token;
     $urlParams = array('auth' => 'no', 'token' => $token);
     return 'fasp://' . $transferUser . '@' . $transferHost . $filePath . '?' . http_build_query($urlParams, '', '&');
 }
Пример #7
0
 public function handleMultiRequest()
 {
     $listOfRequests = array();
     $results = array();
     $found = true;
     $i = 1;
     while ($found) {
         $currentService = isset($this->params[$i . ":service"]) ? $this->params[$i . ":service"] : null;
         $currentAction = isset($this->params[$i . ":action"]) ? $this->params[$i . ":action"] : null;
         $found = $currentAction && $currentService;
         if ($found) {
             $listOfRequests[$i]["service"] = $currentService;
             $listOfRequests[$i]["action"] = $currentAction;
             // find all the parameters for this request
             foreach ($this->params as $key => $val) {
                 // the key "1:myparam" mean that we should input value of this key to request "1", for param "myparam"
                 $keyArray = explode(":", $key);
                 if ($keyArray[0] == $i) {
                     array_shift($keyArray);
                     // remove the request number
                     $requestKey = implode(":", $keyArray);
                     /* remarked by Dor - 13/10/2010
                         * There is no need to remove service and action from the params in case of multirequest
                         * while they are needed in KalturaResponseCacher
                         
                        if (in_array($requestKey, array("service", "action"))) // don't add service name and action name to the params
                            continue;
                        
                        */
                     $listOfRequests[$i]["params"][$requestKey] = $val;
                     // store the param
                 }
             }
             // clientTag param might be used in KalturaResponseCacher
             if (isset($this->params['clientTag']) && !isset($listOfRequests[$i]["params"]['clientTag'])) {
                 $listOfRequests[$i]["params"]['clientTag'] = $this->params['clientTag'];
             }
             // if ks is not set for a specific request, copy the ks from the top params
             $currentKs = isset($listOfRequests[$i]["params"]["ks"]) ? $listOfRequests[$i]["params"]["ks"] : null;
             if (!$currentKs) {
                 $mainKs = isset($this->params["ks"]) ? $this->params["ks"] : null;
                 if ($mainKs) {
                     $listOfRequests[$i]["params"]["ks"] = $mainKs;
                 }
             }
             $currentPartner = isset($listOfRequests[$i]["params"]["partnerId"]) ? $listOfRequests[$i]["params"]["partnerId"] : null;
             if (!$currentPartner) {
                 $mainPartner = isset($this->params["partnerId"]) ? $this->params["partnerId"] : null;
                 if ($mainPartner) {
                     $listOfRequests[$i]["params"]["partnerId"] = $mainPartner;
                 }
             }
             $i++;
         } else {
             // will break the loop
         }
     }
     $i = 1;
     foreach ($listOfRequests as $currentRequest) {
         $currentService = $currentRequest["service"];
         $currentAction = $currentRequest["action"];
         $currentParams = $currentRequest["params"];
         // check if we need to replace params with prev results
         foreach ($currentParams as $key => &$val) {
             $matches = array();
             // keywords: multirequest, result, depend, pass
             // figuring out if requested params should be extracted from previous result
             // example: if you want to use KalturaPlaylist->playlistContent result from the first request
             // in your second request, the second request will contain the following value:
             // {1:result:playlistContent}
             if (preg_match('/\\{([0-9]*)\\:result\\:?(.*)?\\}/', $val, $matches)) {
                 $resultIndex = $matches[1];
                 $resultKey = $matches[2];
                 if (count($results) >= $resultIndex) {
                     if (strlen(trim($resultKey)) > 0) {
                         $resultPathArray = explode(":", $resultKey);
                     } else {
                         $resultPathArray = array();
                     }
                     $val = $this->getValueFromObject($results[$resultIndex], $resultPathArray);
                 }
             }
         }
         try {
             // cached parameters should be different when the request is part of a multirequest
             // as part of multirequest - the cached data is a serialized php object
             // when not part of multirequest - the cached data is the actual response
             $currentParams['multirequest'] = true;
             unset($currentParams['format']);
             $cache = new KalturaResponseCacher($currentParams);
             if (!isset($currentParams['ks']) && kCurrentContext::$ks) {
                 $cache->setKS(kCurrentContext::$ks);
             }
             $cachedResult = $cache->checkCache('X-Kaltura-Part-Of-MultiRequest');
             if ($cachedResult) {
                 $currentResult = unserialize($cachedResult);
             } else {
                 $currentResult = $this->dispatcher->dispatch($currentService, $currentAction, $currentParams);
                 // store serialized resposne in cache
                 $cache->storeCache(serialize($currentResult));
             }
         } catch (Exception $ex) {
             $currentResult = $this->getExceptionObject($ex);
             KalturaResponseCacher::disableCache();
         }
         $results[$i] = $currentResult;
         $i++;
     }
     return $results;
 }
Пример #8
0
 public function shouldConsumeSavedEvent(BaseObject $object)
 {
     return KalturaResponseCacher::isCacheEnabled();
 }
Пример #9
0
 /**
  * This action delivers entry-related data, based on the user's context: access control, restriction, playback format and storage information.
  * @action getContextData
  * @param string $entryId
  * @param KalturaEntryContextDataParams $contextDataParams
  * @return KalturaEntryContextDataResult
  */
 public function getContextData($entryId, KalturaEntryContextDataParams $contextDataParams)
 {
     $dbEntry = entryPeer::retrieveByPK($entryId);
     if (!$dbEntry) {
         throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
     }
     $asset = null;
     if ($contextDataParams->flavorAssetId) {
         $asset = assetPeer::retrieveById($contextDataParams->flavorAssetId);
         if (!$asset) {
             throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND, $contextDataParams->flavorAssetId);
         }
     }
     $contextDataHelper = new kContextDataHelper($dbEntry, $this->getPartner(), $asset);
     if ($dbEntry->getAccessControl() && $dbEntry->getAccessControl()->hasRules()) {
         $accessControlScope = $dbEntry->getAccessControl()->getScope();
     } else {
         $accessControlScope = new accessControlScope();
     }
     $contextDataParams->toObject($accessControlScope);
     $contextDataHelper->buildContextDataResult($accessControlScope, $contextDataParams->flavorTags, $contextDataParams->streamerType, $contextDataParams->mediaProtocol);
     if ($contextDataHelper->getDisableCache()) {
         KalturaResponseCacher::disableCache();
     }
     $result = new KalturaEntryContextDataResult();
     $result->fromObject($contextDataHelper->getContextDataResult());
     $result->flavorAssets = KalturaFlavorAssetArray::fromDbArray($contextDataHelper->getAllowedFlavorAssets());
     $result->streamerType = $contextDataHelper->getStreamerType();
     $result->mediaProtocol = $contextDataHelper->getMediaProtocol();
     $result->storageProfilesXML = $contextDataHelper->getStorageProfilesXML();
     $result->isAdmin = $contextDataHelper->getIsAdmin();
     $parentEntryId = $dbEntry->getParentEntryId();
     if ($parentEntryId) {
         $dbEntry = $dbEntry->getParentEntry();
         if (!$dbEntry) {
             throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $parentEntryId);
         }
     }
     $result->isScheduledNow = $dbEntry->isScheduledNow($contextDataParams->time);
     $result->pluginData = new KalturaPluginDataArray();
     $pluginInstances = KalturaPluginManager::getPluginInstances('IKalturaEntryContextDataContributor');
     foreach ($pluginInstances as $pluginInstance) {
         $pluginInstance->contributeToEntryContextDataResult($entryId, $contextDataParams, $result);
     }
     return $result;
 }
 /**
  * Start an impersonated session with Kaltura's server.
  * The result KS info contains the session key that you should pass to all services that requires a ticket.
  * Type, expiry and privileges won't be changed if they're not set
  * 
  * @action impersonateByKs
  * @param string $session The old KS of the impersonated partner
  * @param KalturaSessionType $type Type of the new KS 
  * @param int $expiry Expiry time in seconds of the new KS
  * @param string $privileges Privileges of the new KS
  * @return KalturaSessionInfo
  *
  * @throws APIErrors::START_SESSION_ERROR
  */
 function impersonateByKsAction($session, $type = null, $expiry = null, $privileges = null)
 {
     KalturaResponseCacher::disableCache();
     $oldKS = null;
     try {
         $oldKS = ks::fromSecureString($session);
     } catch (Exception $e) {
         KalturaLog::err($e->getMessage());
         throw new KalturaAPIException(APIErrors::START_SESSION_ERROR, $this->getPartnerId());
     }
     $impersonatedPartnerId = $oldKS->partner_id;
     $impersonatedUserId = $oldKS->user;
     $impersonatedType = $oldKS->type;
     $impersonatedExpiry = $oldKS->valid_until - time();
     $impersonatedPrivileges = $oldKS->privileges;
     if (!is_null($type)) {
         $impersonatedType = $type;
     }
     if (!is_null($expiry)) {
         $impersonatedExpiry = $expiry;
     }
     if ($privileges) {
         $impersonatedPrivileges = $privileges;
     }
     // verify partner is allowed to start session for another partner
     $impersonatedPartner = null;
     if (!myPartnerUtils::allowPartnerAccessPartner($this->getPartnerId(), $this->partnerGroup(), $impersonatedPartnerId)) {
         $c = PartnerPeer::getDefaultCriteria();
         $c->addAnd(PartnerPeer::ID, $impersonatedPartnerId);
         $impersonatedPartner = PartnerPeer::doSelectOne($c);
     } else {
         // get impersonated partner
         $impersonatedPartner = PartnerPeer::retrieveByPK($impersonatedPartnerId);
     }
     if (!$impersonatedPartner) {
         KalturaLog::err("Impersonated partner [{$impersonatedPartnerId} ]could not be fetched from the DB");
         throw new KalturaAPIException(APIErrors::START_SESSION_ERROR, $this->getPartnerId());
     }
     // set the correct secret according to required session type
     if ($impersonatedType == KalturaSessionType::ADMIN) {
         $impersonatedSecret = $impersonatedPartner->getAdminSecret();
     } else {
         $impersonatedSecret = $impersonatedPartner->getSecret();
     }
     $sessionInfo = new KalturaSessionInfo();
     $result = kSessionUtils::startKSession($impersonatedPartnerId, $impersonatedSecret, $impersonatedUserId, $sessionInfo->ks, $impersonatedExpiry, $impersonatedType, '', $impersonatedPrivileges, $this->getPartnerId());
     if ($result < 0) {
         KalturaLog::err("Failed starting a session with result [{$result}]");
         throw new KalturaAPIException(APIErrors::START_SESSION_ERROR, $this->getPartnerId());
     }
     $sessionInfo->partnerId = $impersonatedPartnerId;
     $sessionInfo->userId = $impersonatedUserId;
     $sessionInfo->expiry = $impersonatedExpiry;
     $sessionInfo->sessionType = $impersonatedType;
     $sessionInfo->privileges = $impersonatedPrivileges;
     return $sessionInfo;
 }
Пример #11
0
 /**
  * Serves the file content
  * 
  * @action serveByFlavorParamsId
  * @serverOnly
  * @param string $entryId Document entry id
  * @param string $flavorParamsId Flavor params id
  * @param bool $forceProxy force to get the content without redirect
  * 
  * @throws KalturaErrors::ENTRY_ID_NOT_FOUND
  * @throws KalturaErrors::FLAVOR_ASSET_IS_NOT_READY
  * @throws KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND
  */
 public function serveByFlavorParamsIdAction($entryId, $flavorParamsId = null, $forceProxy = false)
 {
     KalturaResponseCacher::disableCache();
     entryPeer::setDefaultCriteriaFilter();
     $dbEntry = entryPeer::retrieveByPK($entryId);
     if (!$dbEntry || $dbEntry->getType() != entryType::DOCUMENT) {
         throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
     }
     $ksObj = $this->getKs();
     $ks = $ksObj ? $ksObj->getOriginalString() : null;
     $securyEntryHelper = new KSecureEntryHelper($dbEntry, $ks, null);
     $securyEntryHelper->validateForDownload();
     $flavorAsset = null;
     assetPeer::resetInstanceCriteriaFilter();
     if ($flavorParamsId) {
         $flavorAsset = assetPeer::retrieveByEntryIdAndParams($entryId, $flavorParamsId);
         if (!$flavorAsset) {
             throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_IS_NOT_READY, $flavorParamsId);
         }
     } else {
         $flavorAsset = assetPeer::retrieveOriginalByEntryId($entryId);
         if (!$flavorAsset) {
             throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND, $flavorParamsId);
         }
     }
     $fileName = $dbEntry->getName() . '.' . $flavorAsset->getFileExt();
     return $this->serveFlavorAsset($flavorAsset, $fileName, $forceProxy);
 }
Пример #12
0
 /**
  * Delivering the status of a live stream (on-air/offline) if it is possible
  * 
  * @action isLive
  * @param string $id ID of the live stream
  * @param KalturaPlaybackProtocol $protocol protocol of the stream to test.
  * @return bool
  * 
  * @throws KalturaErrors::LIVE_STREAM_STATUS_CANNOT_BE_DETERMINED
  * @throws KalturaErrors::INVALID_ENTRY_ID
  */
 public function isLiveAction($id, $protocol)
 {
     KalturaResponseCacher::setExpiry(self::ISLIVE_ACTION_CACHE_EXPIRY);
     KalturaResponseCacher::setConditionalCacheExpiry(self::ISLIVE_ACTION_CONDITIONAL_CACHE_EXPIRY);
     if (!kCurrentContext::$ks) {
         kEntitlementUtils::initEntitlementEnforcement(null, false);
         $liveStreamEntry = kCurrentContext::initPartnerByEntryId($id);
         if (!$liveStreamEntry || $liveStreamEntry->getStatus() == entryStatus::DELETED) {
             throw new KalturaAPIException(KalturaErrors::INVALID_ENTRY_ID, $id);
         }
         // enforce entitlement
         $this->setPartnerFilters(kCurrentContext::getCurrentPartnerId());
     } else {
         $liveStreamEntry = entryPeer::retrieveByPK($id);
     }
     if (!$liveStreamEntry || $liveStreamEntry->getType() != entryType::LIVE_STREAM) {
         throw new KalturaAPIException(KalturaErrors::INVALID_ENTRY_ID, $id);
     }
     /* @var $liveStreamEntry LiveStreamEntry */
     if (in_array($liveStreamEntry->getSource(), array(KalturaSourceType::LIVE_STREAM, KalturaSourceType::LIVE_STREAM_ONTEXTDATA_CAPTIONS))) {
         return $liveStreamEntry->hasMediaServer();
     }
     $dpda = new DeliveryProfileDynamicAttributes();
     $dpda->setEntryId($id);
     $dpda->setFormat($protocol);
     switch ($protocol) {
         case KalturaPlaybackProtocol::HLS:
         case KalturaPlaybackProtocol::APPLE_HTTP:
             $url = $liveStreamEntry->getHlsStreamUrl();
             foreach (array(KalturaPlaybackProtocol::HLS, KalturaPlaybackProtocol::APPLE_HTTP) as $hlsProtocol) {
                 $config = $liveStreamEntry->getLiveStreamConfigurationByProtocol($hlsProtocol, requestUtils::getProtocol());
                 if ($config) {
                     $url = $config->getUrl();
                     $protocol = $hlsProtocol;
                     break;
                 }
             }
             KalturaLog::info('Determining status of live stream URL [' . $url . ']');
             $urlManager = DeliveryProfilePeer::getLiveDeliveryProfileByHostName(parse_url($url, PHP_URL_HOST), $dpda);
             if ($urlManager) {
                 return $urlManager->isLive($url);
             }
             break;
         case KalturaPlaybackProtocol::HDS:
         case KalturaPlaybackProtocol::AKAMAI_HDS:
             $config = $liveStreamEntry->getLiveStreamConfigurationByProtocol($protocol, requestUtils::getProtocol());
             if ($config) {
                 $url = $config->getUrl();
                 KalturaLog::info('Determining status of live stream URL [' . $url . ']');
                 $urlManager = DeliveryProfilePeer::getLiveDeliveryProfileByHostName(parse_url($url, PHP_URL_HOST), $dpda);
                 if ($urlManager) {
                     return $urlManager->isLive($url);
                 }
             }
             break;
     }
     throw new KalturaAPIException(KalturaErrors::LIVE_STREAM_STATUS_CANNOT_BE_DETERMINED, $protocol);
 }
 /**
  * This action delivers entry-related data, based on the user's context: access control, restriction, playback format and storage information.
  * @action getContextData
  * @param string $entryId
  * @param KalturaEntryContextDataParams $contextDataParams
  * @return KalturaEntryContextDataResult
  */
 public function getContextData($entryId, KalturaEntryContextDataParams $contextDataParams)
 {
     $dbEntry = entryPeer::retrieveByPK($entryId);
     if (!$dbEntry) {
         throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
     }
     $ks = $this->getKs();
     $isAdmin = false;
     if ($ks) {
         $isAdmin = $ks->isAdmin();
     }
     $accessControl = $dbEntry->getAccessControl();
     /* @var $accessControl accessControl */
     $result = new KalturaEntryContextDataResult();
     $result->isAdmin = $isAdmin;
     $result->isScheduledNow = $dbEntry->isScheduledNow($contextDataParams->time);
     if ($dbEntry->getStartDate() && abs($dbEntry->getStartDate(null) - time()) <= 86400 || $dbEntry->getEndDate() && abs($dbEntry->getEndDate(null) - time()) <= 86400) {
         KalturaResponseCacher::setConditionalCacheExpiry(600);
     }
     if ($accessControl && $accessControl->hasRules()) {
         $disableCache = true;
         if (kConf::hasMap("optimized_playback")) {
             $partnerId = $accessControl->getPartnerId();
             $optimizedPlayback = kConf::getMap("optimized_playback");
             if (array_key_exists($partnerId, $optimizedPlayback)) {
                 $params = $optimizedPlayback[$partnerId];
                 if (array_key_exists('cache_kdp_acccess_control', $params) && $params['cache_kdp_acccess_control']) {
                     $disableCache = false;
                 }
             }
         }
         $accessControlScope = $accessControl->getScope();
         $contextDataParams->toObject($accessControlScope);
         $accessControlScope->setEntryId($entryId);
         $result->isAdmin = $accessControlScope->getKs() && $accessControlScope->getKs()->isAdmin();
         $dbResult = new kEntryContextDataResult();
         if ($accessControl->applyContext($dbResult) && $disableCache) {
             KalturaResponseCacher::disableCache();
         }
         $result->fromObject($dbResult);
     }
     $partner = PartnerPeer::retrieveByPK($dbEntry->getPartnerId());
     if (PermissionPeer::isValidForPartner(PermissionName::FEATURE_REMOTE_STORAGE_DELIVERY_PRIORITY, $dbEntry->getPartnerId()) && $partner->getStorageServePriority() != StorageProfile::STORAGE_SERVE_PRIORITY_KALTURA_ONLY) {
         if (is_null($contextDataParams->flavorAssetId)) {
             if ($contextDataParams->flavorTags) {
                 $assets = assetPeer::retrieveReadyByEntryIdAndTag($entryId, $contextDataParams->flavorTags);
                 $asset = reset($assets);
             } else {
                 $asset = assetPeer::retrieveBestPlayByEntryId($entryId);
             }
             if (!$asset) {
                 throw new KalturaAPIException(KalturaErrors::NO_FLAVORS_FOUND, $entryId);
             }
         } else {
             $asset = assetPeer::retrieveByPK($contextDataParams->flavorAssetId);
             if (!$asset) {
                 throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND, $contextDataParams->flavorAssetId);
             }
         }
         if (!$asset) {
             throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND, $entryId);
         }
         $assetSyncKey = $asset->getSyncKey(asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
         $fileSyncs = kFileSyncUtils::getAllReadyExternalFileSyncsForKey($assetSyncKey);
         $storageProfilesXML = new SimpleXMLElement("<StorageProfiles/>");
         foreach ($fileSyncs as $fileSync) {
             $storageProfileId = $fileSync->getDc();
             $storageProfile = StorageProfilePeer::retrieveByPK($storageProfileId);
             if (!$storageProfile->getDeliveryRmpBaseUrl() && (!$contextDataParams->streamerType || $contextDataParams->streamerType == StorageProfile::PLAY_FORMAT_AUTO)) {
                 $contextDataParams->streamerType = StorageProfile::PLAY_FORMAT_HTTP;
                 $contextDataParams->mediaProtocol = StorageProfile::PLAY_FORMAT_HTTP;
             }
             $storageProfileXML = $storageProfilesXML->addChild("StorageProfile");
             $storageProfileXML->addAttribute("storageProfileId", $storageProfileId);
             $storageProfileXML->addChild("Name", $storageProfile->getName());
             $storageProfileXML->addChild("SystemName", $storageProfile->getSystemName());
         }
         $result->storageProfilesXML = $storageProfilesXML->saveXML();
     }
     if ($contextDataParams->streamerType && $contextDataParams->streamerType != StorageProfile::PLAY_FORMAT_AUTO) {
         $result->streamerType = $contextDataParams->streamerType;
         $result->mediaProtocol = $contextDataParams->mediaProtocol ? $contextDataParams->mediaProtocol : $contextDataParams->streamerType;
     } else {
         $result->streamerType = $this->getPartner()->getStreamerType();
         if (!$result->streamerType) {
             $result->streamerType = StorageProfile::PLAY_FORMAT_HTTP;
         }
         $result->mediaProtocol = $this->getPartner()->getMediaProtocol();
         if (!$result->mediaProtocol) {
             $result->mediaProtocol = StorageProfile::PLAY_FORMAT_HTTP;
         }
     }
     return $result;
 }
Пример #14
0
 /**
  * batch suspendJobs action suspends jobs from running.
  *
  * @action suspendJobs
  */
 function suspendJobsAction()
 {
     KalturaResponseCacher::disableCache();
     kJobsSuspender::balanceJobsload();
 }
Пример #15
0
 /**
  * Set initial users password
  * 
  * @param string $hashKey
  * @param string $newPassword new password to set
  *
  * @throws KalturaErrors::LOGIN_DATA_NOT_FOUND
  * @throws KalturaErrors::PASSWORD_STRUCTURE_INVALID
  * @throws KalturaErrors::NEW_PASSWORD_HASH_KEY_EXPIRED
  * @throws KalturaErrors::NEW_PASSWORD_HASH_KEY_INVALID
  * @throws KalturaErrors::PASSWORD_ALREADY_USED
  * @throws KalturaErrors::INTERNAL_SERVERL_ERROR
  */
 protected function setInitialPasswordImpl($hashKey, $newPassword)
 {
     KalturaResponseCacher::disableCache();
     try {
         $loginData = UserLoginDataPeer::isHashKeyValid($hashKey);
         if ($loginData) {
             $this->validateApiAccessControl($loginData->getLastLoginPartnerId());
         }
         $result = UserLoginDataPeer::setInitialPassword($hashKey, $newPassword);
     } catch (kUserException $e) {
         $code = $e->getCode();
         if ($code == kUserException::LOGIN_DATA_NOT_FOUND) {
             throw new KalturaAPIException(KalturaErrors::LOGIN_DATA_NOT_FOUND);
         }
         if ($code == kUserException::PASSWORD_STRUCTURE_INVALID) {
             $loginData = UserLoginDataPeer::isHashKeyValid($hashKey);
             $invalidPasswordStructureMessage = $loginData->getInvalidPasswordStructureMessage();
             throw new KalturaAPIException(KalturaErrors::PASSWORD_STRUCTURE_INVALID, $invalidPasswordStructureMessage);
         }
         if ($code == kUserException::NEW_PASSWORD_HASH_KEY_EXPIRED) {
             throw new KalturaAPIException(KalturaErrors::NEW_PASSWORD_HASH_KEY_EXPIRED);
         }
         if ($code == kUserException::NEW_PASSWORD_HASH_KEY_INVALID) {
             throw new KalturaAPIException(KalturaErrors::NEW_PASSWORD_HASH_KEY_INVALID);
         }
         if ($code == kUserException::PASSWORD_ALREADY_USED) {
             throw new KalturaAPIException(KalturaErrors::PASSWORD_ALREADY_USED);
         }
         throw $e;
     }
     if (!$result) {
         throw new KalturaAPIException(KalturaErrors::INTERNAL_SERVERL_ERROR);
     }
 }
Пример #16
0
 /**
  * @action getVersion
  * @return string the current server version
  */
 function getVersionAction()
 {
     KalturaResponseCacher::disableCache();
     $version = file_get_contents(realpath(dirname(__FILE__)) . '/../../VERSION.txt');
     return trim($version);
 }
 protected function validateApiAccessControl()
 {
     if (is_null($this->partner)) {
         return;
     }
     // ignore for system partners
     // for cases where an api action has a 'partnerId' parameter which will causes loading that partner instead of the ks partner
     if ($this->getKs() && $this->getKs()->partner_id < 0) {
         return;
     }
     $accessControl = $this->partner->getApiAccessControl();
     if (is_null($accessControl)) {
         return;
     }
     $context = new kEntryContextDataResult();
     $disableCache = $accessControl->applyContext($context, $this->getApiAccessControlScope());
     if ($disableCache) {
         KalturaResponseCacher::disableCache();
     }
     if (count($context->getAccessControlMessages())) {
         foreach ($context->getAccessControlMessages() as $msg) {
             header("X-Kaltura: api-access-control: {$msg}");
         }
     }
     if (count($context->getAccessControlActions())) {
         $actions = $context->getAccessControlActions();
         foreach ($actions as $action) {
             /* @var $action kAccessControlAction */
             if ($action->getType() == accessControlActionType::BLOCK) {
                 throw new KalturaAPIException(APIErrors::SERVICE_ACCESS_CONTROL_RESTRICTED, $this->serviceId . '->' . $this->actionName);
             }
         }
     }
 }
 /**
  * @param asset $asset
  * @param bool $tokenizeUrl
  * @return string
  */
 public function getAssetUrl(asset $asset, $tokenizeUrl = true)
 {
     $url = null;
     if ($asset instanceof thumbAsset) {
         $url = $this->doGetThumbnailAssetUrl($asset);
     }
     if ($asset instanceof flavorAsset) {
         $url = $this->doGetFlavorAssetUrl($asset);
         if ($tokenizeUrl) {
             $tokenizer = $this->getTokenizer();
             if ($tokenizer) {
                 $url = $tokenizer->tokenizeSingleUrl($url);
                 if (class_exists('KalturaResponseCacher')) {
                     KalturaResponseCacher::disableCache();
                 }
             }
         }
     }
     return $url;
 }
 /**
  * Retrieve partner secret and admin secret
  * 
  * @action getSecrets
  * @param int $partnerId
  * @param string $adminEmail
  * @param string $cmsPassword
  * @return KalturaPartner
  * 
  *
  * @throws APIErrors::ADMIN_KUSER_NOT_FOUND
  */
 public function getSecretsAction($partnerId, $adminEmail, $cmsPassword)
 {
     KalturaResponseCacher::disableCache();
     $adminKuser = null;
     try {
         $adminKuser = UserLoginDataPeer::userLoginByEmail($adminEmail, $cmsPassword, $partnerId);
     } catch (kUserException $e) {
         throw new KalturaAPIException(APIErrors::ADMIN_KUSER_NOT_FOUND, "The data you entered is invalid");
     }
     if (!$adminKuser || !$adminKuser->getIsAdmin()) {
         throw new KalturaAPIException(APIErrors::ADMIN_KUSER_NOT_FOUND, "The data you entered is invalid");
     }
     KalturaLog::log("Admin Kuser found, going to validate password", KalturaLog::INFO);
     // user logged in - need to re-init kPermissionManager in order to determine current user's permissions
     $ks = null;
     kSessionUtils::createKSessionNoValidations($partnerId, $adminKuser->getPuserId(), $ks, 86400, $adminKuser->getIsAdmin(), "", '*');
     kCurrentContext::initKsPartnerUser($ks);
     kPermissionManager::init();
     $dbPartner = PartnerPeer::retrieveByPK($partnerId);
     $partner = new KalturaPartner();
     $partner->fromPartner($dbPartner);
     $partner->cmsPassword = $cmsPassword;
     return $partner;
 }
Пример #20
0
 public function getExceptionObject($ex, $service, $action)
 {
     KalturaResponseCacher::adjustApiCacheForException($ex);
     if ($ex instanceof KalturaAPIException) {
         KalturaLog::err($ex);
         $object = $ex;
     } else {
         if ($ex instanceof APIException) {
             $args = $ex->extra_data;
             $reflectionException = new ReflectionClass("KalturaAPIException");
             $ex = $reflectionException->newInstanceArgs($args);
             KalturaLog::err($ex);
             $object = $ex;
         } else {
             if ($ex instanceof kCoreException) {
                 switch ($ex->getCode()) {
                     case kCoreException::USER_BLOCKED:
                         $object = new KalturaAPIException(KalturaErrors::USER_BLOCKED);
                         break;
                     case kCoreException::PARTNER_BLOCKED:
                         $object = new KalturaAPIException(KalturaErrors::SERVICE_FORBIDDEN_CONTENT_BLOCKED);
                         break;
                     case kCoreException::INVALID_KS:
                         $object = new KalturaAPIException(KalturaErrors::INVALID_KS, $ex->getData(), ks::INVALID_STR, 'INVALID_STR');
                         break;
                     case kCoreException::MAX_NUMBER_OF_ACCESS_CONTROLS_REACHED:
                         $object = new KalturaAPIException(KalturaErrors::MAX_NUMBER_OF_ACCESS_CONTROLS_REACHED, $ex->getData());
                         break;
                     case kCoreException::MAX_CATEGORIES_PER_ENTRY:
                         $object = new KalturaAPIException(KalturaErrors::MAX_CATEGORIES_FOR_ENTRY_REACHED, $ex->getData());
                         break;
                     case kCoreException::MAX_ASSETS_PER_ENTRY:
                         $object = new KalturaAPIException(KalturaErrors::MAX_ASSETS_FOR_ENTRY_REACHED, asset::MAX_ASSETS_PER_ENTRY);
                         break;
                     case kCoreException::SEARCH_TOO_GENERAL:
                         $object = new KalturaAPIException(KalturaErrors::SEARCH_TOO_GENERAL);
                         break;
                     case kCoreException::SOURCE_FILE_NOT_FOUND:
                         $object = new KalturaAPIException(KalturaErrors::SOURCE_FILE_NOT_FOUND);
                         break;
                     case APIErrors::INVALID_ACTIONS_LIMIT:
                         $object = new KalturaAPIException(APIErrors::INVALID_ACTIONS_LIMIT);
                         break;
                     case APIErrors::PRIVILEGE_IP_RESTRICTION:
                         $object = new KalturaAPIException(APIErrors::PRIVILEGE_IP_RESTRICTION);
                         break;
                     case APIErrors::INVALID_SET_ROLE:
                         $object = new KalturaAPIException(APIErrors::INVALID_SET_ROLE);
                         break;
                     case APIErrors::UNKNOWN_ROLE_ID:
                         $object = new KalturaAPIException(APIErrors::UNKNOWN_ROLE_ID);
                         break;
                     case APIErrors::SEARCH_ENGINE_QUERY_FAILED:
                         $object = new KalturaAPIException(APIErrors::SEARCH_ENGINE_QUERY_FAILED);
                         break;
                     case kCoreException::FILE_NOT_FOUND:
                         $object = new KalturaAPIException(KalturaErrors::FILE_NOT_FOUND);
                         break;
                     case kCoreException::LOCK_TIMED_OUT:
                         $object = new KalturaAPIException(KalturaErrors::LOCK_TIMED_OUT);
                         break;
                     case kCoreException::SPHINX_CRITERIA_EXCEEDED_MAX_MATCHES_ALLOWED:
                         $object = new KalturaAPIException(KalturaErrors::SPHINX_CRITERIA_EXCEEDED_MAX_MATCHES_ALLOWED);
                         break;
                     case kCoreException::INVALID_ENTRY_ID:
                         $object = new KalturaAPIException(KalturaErrors::INVALID_ENTRY_ID, $ex->getData());
                         break;
                     case kCoreException::MAX_FILE_SYNCS_FOR_OBJECT_PER_DAY_REACHED:
                         $object = new KalturaAPIException(KalturaErrors::MAX_FILE_SYNCS_FOR_OBJECT_PER_DAY_REACHED, $ex->getData());
                         break;
                     case kCoreException::ID_NOT_FOUND:
                         $object = new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $ex->getData());
                         break;
                     default:
                         KalturaLog::crit($ex);
                         $object = new KalturaAPIException(KalturaErrors::INTERNAL_SERVERL_ERROR);
                 }
             } else {
                 if ($ex instanceof PropelException) {
                     KalturaLog::alert($ex);
                     $object = new KalturaAPIException(KalturaErrors::INTERNAL_DATABASE_ERROR);
                 } else {
                     KalturaLog::crit($ex);
                     $object = new KalturaAPIException(KalturaErrors::INTERNAL_SERVERL_ERROR);
                 }
             }
         }
     }
     return $this->handleErrorMapping($object, $service, $action);
 }
 public function query()
 {
     if (class_exists('KalturaResponseCacher')) {
         KalturaResponseCacher::disableConditionalCache();
     }
     $args = func_get_args();
     $sql = $args[0];
     KalturaLog::debug($sql);
     $comment = $this->getCommentWrapped();
     $sql = $comment . $sql;
     $sqlStart = microtime(true);
     try {
         if (version_compare(PHP_VERSION, '5.3', '<')) {
             $result = call_user_func_array(array($this, 'parent::query'), $args);
         } else {
             $result = call_user_func_array('parent::query', $args);
         }
     } catch (PropelException $pex) {
         KalturaLog::alert($pex->getMessage());
         throw new PropelException("Database error");
     }
     KalturaLog::debug("Sql took - " . (microtime(true) - $sqlStart) . " seconds");
     return $result;
 }
Пример #22
0
 /**
  * Flag inappropriate media entry for moderation
  *
  * @action flag
  * @param string $entryId
  * @param KalturaModerationFlag $moderationFlag
  * 
  * @throws KalturaErrors::ENTRY_ID_NOT_FOUND
  */
 public function flagAction(KalturaModerationFlag $moderationFlag)
 {
     KalturaResponseCacher::disableCache();
     return parent::flagEntry($moderationFlag, KalturaEntryType::MEDIA_CLIP);
 }
Пример #23
0
 private function responseHandlingIsLive($isLive)
 {
     if (!$isLive) {
         KalturaResponseCacher::setExpiry(self::ISLIVE_ACTION_CACHE_EXPIRY_WHEN_NOT_LIVE);
         KalturaResponseCacher::setHeadersCacheExpiry(self::ISLIVE_ACTION_CACHE_EXPIRY_WHEN_NOT_LIVE);
     } else {
         KalturaResponseCacher::setExpiry(self::ISLIVE_ACTION_CACHE_EXPIRY_WHEN_LIVE);
         KalturaResponseCacher::setHeadersCacheExpiry(self::ISLIVE_ACTION_CACHE_EXPIRY_WHEN_LIVE);
     }
     return $isLive;
 }
Пример #24
0
 /**
  * Starts a new KS (kaltura Session) based on application authentication token id
  * 
  * @action startSession
  * @param string $id application token id
  * @param string $tokenHash hashed token, built of sha1 on current KS concatenated with the application token
  * @param string $userId session user id, will be ignored if a different user id already defined on the application token
  * @param KalturaSessionType $type session type, will be ignored if a different session type already defined on the application token
  * @param int $expiry session expiry (in seconds), could be overwritten by shorter expiry of the application token and the session-expiry that defined on the application token 
  * @param string $privileges session privileges, will be appended to privileges that defined on the application token
  * @throws KalturaErrors::APP_TOKEN_ID_NOT_FOUND
  * @return KalturaSessionInfo
  */
 function startSessionAction($id, $tokenHash, $userId = null, $type = null, $expiry = null)
 {
     $dbAppToken = AppTokenPeer::retrieveByPK($id);
     if (!$dbAppToken) {
         throw new KalturaAPIException(KalturaErrors::APP_TOKEN_ID_NOT_FOUND, $id);
     }
     if ($dbAppToken->getStatus() != AppTokenStatus::ACTIVE) {
         throw new KalturaAPIException(KalturaErrors::APP_TOKEN_NOT_ACTIVE, $id);
     }
     $appTokenHash = sha1(kCurrentContext::$ks . $dbAppToken->getToken());
     if ($appTokenHash !== $tokenHash) {
         throw new KalturaAPIException(KalturaErrors::INVALID_APP_TOKEN_HASH);
     }
     KalturaResponseCacher::disableCache();
     $tokenExpiry = $dbAppToken->getSessionDuration();
     if (!is_null($dbAppToken->getExpiry())) {
         $tokenExpiry = min($tokenExpiry, $dbAppToken->getExpiry() - time());
         if ($tokenExpiry < 0) {
             throw new KalturaAPIException(KalturaErrors::APP_TOKEN_EXPIRED, $id);
         }
     }
     if (!$expiry) {
         $expiry = $tokenExpiry;
     }
     $expiry = min($expiry, $tokenExpiry);
     if (!is_null($dbAppToken->getSessionType())) {
         $type = $dbAppToken->getSessionType();
     }
     if (is_null($type)) {
         $type = SessionType::USER;
     }
     if (!is_null($dbAppToken->getSessionUserId())) {
         $userId = $dbAppToken->getSessionUserId();
     }
     $partnerId = kCurrentContext::getCurrentPartnerId();
     $partner = PartnerPeer::retrieveByPK($partnerId);
     $secret = $type == SessionType::ADMIN ? $partner->getAdminSecret() : $partner->getSecret();
     $privilegesArray = array(ks::PRIVILEGE_SESSION_ID => array($id), ks::PRIVILEGE_APP_TOKEN => array($id));
     if ($dbAppToken->getSessionPrivileges()) {
         $privilegesArray = array_merge_recursive($privilegesArray, ks::parsePrivileges($dbAppToken->getSessionPrivileges()));
     }
     $privileges = ks::buildPrivileges($privilegesArray);
     $ks = kSessionUtils::createKSession($partnerId, $secret, $userId, $expiry, $type, $privileges);
     if (!$ks) {
         throw new KalturaAPIException(APIErrors::START_SESSION_ERROR, $partnerId);
     }
     $sessionInfo = new KalturaSessionInfo();
     $sessionInfo->ks = $ks->toSecureString();
     $sessionInfo->partnerId = $partnerId;
     $sessionInfo->userId = $userId;
     $sessionInfo->expiry = $ks->valid_until;
     $sessionInfo->sessionType = $type;
     $sessionInfo->privileges = $privileges;
     return $sessionInfo;
 }
Пример #25
0
 public function dispatch($service, $action, $params = array())
 {
     $start = microtime(true);
     // prevent impersonate to partner zero
     $p = isset($params["p"]) && $params["p"] ? $params["p"] : null;
     if (!$p) {
         $p = isset($params["partnerId"]) && $params["partnerId"] ? $params["partnerId"] : null;
     }
     $GLOBALS["partnerId"] = $p;
     // set for logger
     $userId = "";
     $ksStr = isset($params["ks"]) ? $params["ks"] : null;
     if (!$service) {
         throw new KalturaAPIException(KalturaErrors::SERVICE_NOT_SPECIFIED);
     }
     //strtolower on service - map is indexed according to lower-case service IDs
     $service = strtolower($service);
     $serviceActionItem = KalturaServicesMap::retrieveServiceActionItem($service, $action);
     $action = strtolower($action);
     if (!isset($serviceActionItem->actionMap[$action])) {
         KalturaLog::crit("Action does not exist!");
         throw new KalturaAPIException(KalturaErrors::ACTION_DOES_NOT_EXISTS, $action, $service);
     }
     try {
         $actionReflector = new KalturaActionReflector($service, $action, $serviceActionItem->actionMap[$action]);
     } catch (Exception $e) {
         throw new Exception("Could not create action reflector for service [{$service}], action [{$action}]. Received error: " . $e->getMessage());
     }
     $actionParams = $actionReflector->getActionParams();
     $actionInfo = $actionReflector->getActionInfo();
     // services.ct - check if partner is allowed to access service ...
     kCurrentContext::$host = isset($_SERVER["HOSTNAME"]) ? $_SERVER["HOSTNAME"] : gethostname();
     kCurrentContext::$user_ip = requestUtils::getRemoteAddress();
     kCurrentContext::$ps_vesion = "ps3";
     kCurrentContext::$service = $serviceActionItem->serviceInfo->serviceName;
     kCurrentContext::$action = $action;
     kCurrentContext::$client_lang = isset($params['clientTag']) ? $params['clientTag'] : null;
     kCurrentContext::initKsPartnerUser($ksStr, $p, $userId);
     // validate it's ok to access this service
     $deserializer = new KalturaRequestDeserializer($params);
     $this->arguments = $deserializer->buildActionArguments($actionParams);
     KalturaLog::debug("Dispatching service [" . $service . "], action [" . $action . "], reqIndex [" . kCurrentContext::$multiRequest_index . "] with params " . print_r($this->arguments, true));
     $responseProfile = $deserializer->getResponseProfile();
     if ($responseProfile) {
         KalturaLog::debug("Response profile: " . print_r($responseProfile, true));
     }
     kPermissionManager::init(kConf::get('enable_cache'));
     kEntitlementUtils::initEntitlementEnforcement();
     $disableTags = $actionInfo->disableTags;
     if ($disableTags && is_array($disableTags) && count($disableTags)) {
         foreach ($disableTags as $disableTag) {
             KalturaCriterion::disableTag($disableTag);
         }
     }
     if ($actionInfo->validateUserObjectClass && $actionInfo->validateUserIdParamName && isset($actionParams[$actionInfo->validateUserIdParamName])) {
         //			// TODO maybe if missing should throw something, maybe a bone?
         //			if(!isset($actionParams[$actionInfo->validateUserIdParamName]))
         //				throw new KalturaAPIException(KalturaErrors::MISSING_MANDATORY_PARAMETER, $actionInfo->validateUserIdParamName);
         KalturaLog::debug("validateUserIdParamName: " . $actionInfo->validateUserIdParamName);
         $objectId = $params[$actionInfo->validateUserIdParamName];
         $this->validateUser($actionInfo->validateUserObjectClass, $objectId, $actionInfo->validateUserPrivilege, $actionInfo->validateOptions);
     }
     // initialize the service before invoking the action on it
     // action reflector will init the service to maintain the pluginable action transparency
     $actionReflector->initService($responseProfile);
     $invokeStart = microtime(true);
     KalturaLog::debug("Invoke start");
     try {
         $res = $actionReflector->invoke($this->arguments);
     } catch (KalturaAPIException $e) {
         if ($actionInfo->returnType != 'file') {
             throw $e;
         }
         KalturaResponseCacher::adjustApiCacheForException($e);
         $res = new kRendererDieError($e->getCode(), $e->getMessage());
     }
     kEventsManager::flushEvents();
     KalturaLog::debug("Invoke took - " . (microtime(true) - $invokeStart) . " seconds");
     KalturaLog::debug("Dispatch took - " . (microtime(true) - $start) . " seconds, memory: " . memory_get_peak_usage(true));
     return $res;
 }
Пример #26
0
 /**
  * Validates all registered media servers
  *
  * @action validateRegisteredMediaServers
  * @param string $entryId Live entry id
  *
  * @throws KalturaErrors::ENTRY_ID_NOT_FOUND
  */
 function validateRegisteredMediaServersAction($entryId)
 {
     KalturaResponseCacher::disableCache();
     $this->dumpApiRequest($entryId, false);
     $dbEntry = entryPeer::retrieveByPK($entryId);
     if (!$dbEntry || !$dbEntry instanceof LiveEntry) {
         throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
     }
     /* @var $dbEntry LiveEntry */
     if ($dbEntry->validateMediaServers()) {
         $dbEntry->save();
     }
 }
Пример #27
0
<?php

$start = microtime(true);
set_time_limit(0);
require_once dirname(__FILE__) . '/../../alpha/config/sfrootdir.php';
// check cache before loading anything
require_once "../lib/KalturaResponseCacher.php";
$cache = new KalturaResponseCacher(null, "/web/cache/feed/", 86400);
$cache->checkOrStart();
require_once "../bootstrap.php";
KalturaLog::setContext("syndicationFeedRenderer");
KalturaLog::debug(">------------------------------------- syndicationFeedRenderer -------------------------------------");
KalturaLog::info("syndicationFeedRenderer-start ");
$feedId = $_GET['feedId'];
$entryId = @$_GET['entryId'];
try {
    $syndicationFeedRenderer = new KalturaSyndicationFeedRenderer($feedId);
    $syndicationFeedRenderer->addFlavorParamsAttachedFilter();
    if (isset($entryId)) {
        $syndicationFeedRenderer->addEntryAttachedFilter($entryId);
    }
    $syndicationFeedRenderer->execute();
} catch (Exception $ex) {
    header('KalturaSyndication: ' . $ex->getMessage());
    die;
}
$end = microtime(true);
KalturaLog::info("syndicationFeedRenderer-end [" . ($end - $start) . "]");
KalturaLog::debug("<------------------------------------- syndicationFeedRenderer -------------------------------------");
$cache->end();
 public function get($obj_name)
 {
     if (!self::$s_ready) {
         return NULL;
     }
     //		$this->m_stats->m_gets++;
     if (class_exists('KalturaResponseCacher')) {
         KalturaResponseCacher::disableConditionalCache();
     }
     $value = self::$s_memcache->get($this->m_namespace . $obj_name);
     if (!isset($value)) {
         $this->m_stats->m_misses++;
         return NULL;
     } else {
         $this->m_stats->m_hits++;
         return $value;
     }
 }
 /**
  * Serves short link
  * 
  * @action goto
  * @param string $id
  * @param bool $proxy proxy the response instead of redirect
  * @return file
  * 
  * @throws KalturaErrors::INVALID_OBJECT_ID
  */
 function gotoAction($id, $proxy = false)
 {
     KalturaResponseCacher::disableCache();
     $dbShortLink = ShortLinkPeer::retrieveByPK($id);
     if (!$dbShortLink) {
         throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $id);
     }
     if ($proxy) {
         kFile::dumpUrl($dbShortLink->getFullUrl(), true, true);
     }
     header('Location: ' . $dbShortLink->getFullUrl());
     die;
 }
Пример #30
0
 /**
  * Serves the file content
  * 
  * @action serveByFlavorParamsId
  * @param string $entryId Document entry id
  * @param string $flavorParamsId Flavor params id
  * @param bool $forceProxy force to get the content without redirect
  * @return file
  * 
  * @throws KalturaErrors::ENTRY_ID_NOT_FOUND
  * @throws KalturaErrors::FLAVOR_ASSET_IS_NOT_READY
  * @throws KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND
  */
 public function serveByFlavorParamsIdAction($entryId, $flavorParamsId = null, $forceProxy = false)
 {
     // temporary workaround for getting the referrer from a url with the format ....&forceProxy/true/referrer/...
     $referrer = null;
     if (isset($_GET["forceProxy"]) && kString::beginsWith($_GET["forceProxy"], "true/referrer/")) {
         $referrer = substr($_GET["forceProxy"], strlen("true/referrer/"));
         $referrer = base64_decode($referrer);
     }
     KalturaResponseCacher::disableCache();
     myPartnerUtils::resetPartnerFilter('entry');
     $dbEntry = entryPeer::retrieveByPK($entryId);
     if (!$dbEntry || $dbEntry->getType() != entryType::DOCUMENT) {
         throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
     }
     $ksObj = $this->getKs();
     $ks = $ksObj ? $ksObj->getOriginalString() : null;
     $securyEntryHelper = new KSecureEntryHelper($dbEntry, $ks, $referrer, ContextType::DOWNLOAD);
     $securyEntryHelper->validateForDownload();
     $flavorAsset = null;
     if ($flavorParamsId) {
         $flavorAsset = assetPeer::retrieveByEntryIdAndParams($entryId, $flavorParamsId);
         if (!$flavorAsset) {
             throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_IS_NOT_READY, $flavorParamsId);
         }
     } else {
         $flavorAsset = assetPeer::retrieveOriginalByEntryId($entryId);
         if (!$flavorAsset) {
             throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND, $flavorParamsId);
         }
     }
     if (!$securyEntryHelper->isAssetAllowed($flavorAsset)) {
         throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND, $flavorParamsId);
     }
     $fileName = $dbEntry->getName() . '.' . $flavorAsset->getFileExt();
     return $this->serveFlavorAsset($flavorAsset, $fileName, $forceProxy);
 }