public function validateEntry(entry $dbEntry) { parent::validateEntry($dbEntry); $this->validatePropertyNotNull('entryId'); $srcEntry = entryPeer::retrieveByPK($this->entryId); if (!$srcEntry) { throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $this->entryId); } if ($srcEntry->getMediaType() == KalturaMediaType::IMAGE) { return parent::validateEntry($dbEntry); } $srcFlavorAsset = null; if (is_null($this->flavorParamsId)) { $srcFlavorAsset = assetPeer::retrieveOriginalByEntryId($this->entryId); if (!$srcFlavorAsset) { throw new KalturaAPIException(KalturaErrors::ORIGINAL_FLAVOR_ASSET_IS_MISSING); } } else { $srcFlavorAsset = assetPeer::retrieveByEntryIdAndParams($this->entryId, $this->flavorParamsId); if (!$srcFlavorAsset) { throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND, $this->assetId); } } $key = $srcFlavorAsset->getSyncKey(asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET); $c = FileSyncPeer::getCriteriaForFileSyncKey($key); $c->addAnd(FileSyncPeer::FILE_TYPE, array(FileSync::FILE_SYNC_FILE_TYPE_FILE, FileSync::FILE_SYNC_FILE_TYPE_LINK), Criteria::IN); $fileSyncs = FileSyncPeer::doSelect($c); foreach ($fileSyncs as $fileSync) { $fileSync = kFileSyncUtils::resolve($fileSync); if ($fileSync->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_FILE) { return; } } throw new KalturaAPIException(KalturaErrors::FILE_DOESNT_EXIST); }
private function resumeEvents($flavorAsset) { $syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET); $c = FileSyncPeer::getCriteriaForFileSyncKey($syncKey); $fileSyncList = FileSyncPeer::doSelect($c); foreach ($fileSyncList as $fileSync) { // resume file sync added event kEventsManager::continueEvent(new kObjectAddedEvent($fileSync), 'kVirusScanFlowManager'); } // resume flavor asset added event consumption kEventsManager::continueEvent(new kObjectAddedEvent($flavorAsset), 'kVirusScanFlowManager'); }
/** * @param string $id * @param int $type */ protected function syncableDeleted($id, $type) { $c = new Criteria(); $c->add(FileSyncPeer::OBJECT_ID, $id); $c->add(FileSyncPeer::OBJECT_TYPE, $type); $c->add(FileSyncPeer::STATUS, array(FileSync::FILE_SYNC_STATUS_PURGED, FileSync::FILE_SYNC_STATUS_DELETED), Criteria::NOT_IN); $fileSyncs = FileSyncPeer::doSelect($c); foreach ($fileSyncs as $fileSync) { $key = kFileSyncUtils::getKeyForFileSync($fileSync); kFileSyncUtils::deleteSyncFileForKey($key); } }
function getAllReadyInternalFileSyncsForKey(FileSyncKey $key) { $c = new Criteria(); $c = FileSyncPeer::getCriteriaForFileSyncKey($key); $c->addAnd(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_FILE); $c->addAnd(FileSyncPeer::STATUS, FileSync::FILE_SYNC_STATUS_READY); $results = FileSyncPeer::doSelect($c); $assocResults = array(); foreach ($results as $curResult) { $assocResults[$curResult->getDc()] = $curResult; } return $assocResults; }
function deleteObject(FileSync $fileSync) { $object = kFileSyncUtils::retrieveObjectForFileSync($fileSync); $key = $object->getSyncKey($fileSync->getObjectSubType()); if ($key->version != $fileSync->getVersion()) { return; } switch ($fileSync->getObjectType()) { case FileSyncObjectType::UICONF: $object->setStatus(uiConf::UI_CONF_STATUS_DELETED); $object->save(); break; case FileSyncObjectType::ENTRY: myEntryUtils::deleteEntry($object); try { $wrapper = objectWrapperBase::getWrapperClass($object); $wrapper->removeFromCache("entry", $object->getId()); } catch (Exception $e) { KalturaLog::err($e); } break; case FileSyncObjectType::ASSET: $object->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_DELETED); $object->setDeletedAt(time()); $object->save(); break; case FileSyncObjectType::METADATA: $object->setStatus(Metadata::STATUS_DELETED); $object->save(); break; default: return; } if ($fileSync->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_LINK) { return; } $criteria = new Criteria(); $criteria->add(FileSyncPeer::DC, $fileSync->getDc()); $criteria->add(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_LINK); $criteria->add(FileSyncPeer::LINKED_ID, $fileSync->getId()); $links = FileSyncPeer::doSelect($criteria); foreach ($links as $link) { deleteObject($link); } }
public function validateForUsage($sourceObject, $propertiesToSkip = array()) { parent::validateForUsage($sourceObject, $propertiesToSkip); $this->validatePropertyNotNull('assetId'); $srcFlavorAsset = assetPeer::retrieveById($this->assetId); if (!$srcFlavorAsset) { throw new KalturaAPIException(KalturaErrors::FLAVOR_ASSET_ID_NOT_FOUND, $resource->assetId); } $key = $srcFlavorAsset->getSyncKey(asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET); $c = FileSyncPeer::getCriteriaForFileSyncKey($key); $c->addAnd(FileSyncPeer::FILE_TYPE, array(FileSync::FILE_SYNC_FILE_TYPE_FILE, FileSync::FILE_SYNC_FILE_TYPE_LINK), Criteria::IN); $fileSyncs = FileSyncPeer::doSelect($c); foreach ($fileSyncs as $fileSync) { $fileSync = kFileSyncUtils::resolve($fileSync); if ($fileSync->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_FILE) { return; } } throw new KalturaAPIException(KalturaErrors::FILE_DOESNT_EXIST); }
/** * List file syce objects by filter and pager * * @action list * @param KalturaFileSyncFilter $filter * @param KalturaFilterPager $pager * @return KalturaFileSyncListResponse */ function listAction(KalturaFileSyncFilter $filter = null, KalturaFilterPager $pager = null) { if (!$filter) { $filter = new KalturaFileSyncFilter(); } if (!$pager) { $pager = new KalturaFilterPager(); } $fileSyncFilter = new FileSyncFilter(); $filter->toObject($fileSyncFilter); $c = new Criteria(); $fileSyncFilter->attachToCriteria($c); $totalCount = FileSyncPeer::doCount($c); $pager->attachToCriteria($c); $dbList = FileSyncPeer::doSelect($c); $list = KalturaFileSyncArray::fromDbArray($dbList, $this->getResponseProfile()); $response = new KalturaFileSyncListResponse(); $response->objects = $list; $response->totalCount = $totalCount; return $response; }
/** * Get remote storage existing paths for the asset * * @action getRemotePaths * @param string $id * @return KalturaRemotePathListResponse * @throws KalturaAttachmentErrors::ATTACHMENT_ASSET_ID_NOT_FOUND * @throws KalturaAttachmentErrors::ATTACHMENT_ASSET_IS_NOT_READY */ public function getRemotePathsAction($id) { $assetDb = assetPeer::retrieveById($id); if (!$assetDb || !$assetDb instanceof AttachmentAsset) { throw new KalturaAPIException(KalturaAttachmentErrors::ATTACHMENT_ASSET_ID_NOT_FOUND, $id); } if ($assetDb->getStatus() != asset::ASSET_STATUS_READY) { throw new KalturaAPIException(KalturaAttachmentErrors::ATTACHMENT_ASSET_IS_NOT_READY); } $c = new Criteria(); $c->add(FileSyncPeer::OBJECT_TYPE, FileSyncObjectType::ASSET); $c->add(FileSyncPeer::OBJECT_SUB_TYPE, asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET); $c->add(FileSyncPeer::OBJECT_ID, $id); $c->add(FileSyncPeer::VERSION, $assetDb->getVersion()); $c->add(FileSyncPeer::PARTNER_ID, $assetDb->getPartnerId()); $c->add(FileSyncPeer::STATUS, FileSync::FILE_SYNC_STATUS_READY); $c->add(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_URL); $fileSyncs = FileSyncPeer::doSelect($c); $listResponse = new KalturaRemotePathListResponse(); $listResponse->objects = KalturaRemotePathArray::fromFileSyncArray($fileSyncs); $listResponse->totalCount = count($listResponse->objects); return $listResponse; }
/** * @param EntryDistribution $entryDistribution * @param DistributionProfile $distributionProfile * @param int $dc * @return bool true if the job could be created */ protected static function prepareDistributionJob(EntryDistribution $entryDistribution, DistributionProfile $distributionProfile, &$dc) { // prepare ids list of all the assets $assetIds = explode(',', implode(',', array($entryDistribution->getThumbAssetIds(), $entryDistribution->getFlavorAssetIds()))); $assets = assetPeer::retrieveByIds($assetIds); $assetObjects = array(); foreach ($assets as $asset) { /* @var $asset asset */ $assetObjects[$asset->getId()] = array('asset' => $asset, 'downloadUrl' => null); } // lists all files from all assets $c = new Criteria(); $c->add(FileSyncPeer::OBJECT_TYPE, FileSyncObjectType::ASSET); $c->add(FileSyncPeer::OBJECT_SUB_TYPE, asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET); $c->add(FileSyncPeer::OBJECT_ID, $assetIds, Criteria::IN); $c->add(FileSyncPeer::PARTNER_ID, $entryDistribution->getPartnerId()); $c->add(FileSyncPeer::STATUS, FileSync::FILE_SYNC_STATUS_READY); $fileSyncs = FileSyncPeer::doSelect($c); $dcs = array(); foreach ($fileSyncs as $fileSync) { /* @var $fileSync FileSync */ $assetId = $fileSync->getObjectId(); if (!isset($assetObjects[$assetId])) { // the object is not in the list of assets continue; } $asset = $assetObjects[$assetId]['asset']; /* @var $asset asset */ if ($asset->getVersion() != $fileSync->getVersion()) { // the file sync is not of the current asset version continue; } $fileSync = kFileSyncUtils::resolve($fileSync); // use the best URL as the source for download in case it will be needed if ($fileSync->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_URL) { if (!is_null($assetObjects[$assetId]['downloadUrl']) && $fileSync->getDc() != $distributionProfile->getRecommendedStorageProfileForDownload()) { continue; } $downloadUrl = $fileSync->getExternalUrl($entryDistribution->getEntryId()); if (!$downloadUrl) { continue; } $assetObjects[$assetId]['downloadUrl'] = $downloadUrl; continue; } // populates the list of files in each dc $fileSyncDc = $fileSync->getDc(); if (!isset($dcs[$fileSyncDc])) { $dcs[$fileSyncDc] = array(); } $dcs[$fileSyncDc][$assetId] = $fileSync->getId(); } if (isset($dcs[$dc]) && count($dcs[$dc]) == count($assets)) { KalturaLog::debug("All files exist in the preferred dc [{$dc}]"); return true; } // check if all files exist on any of the remote dcs $otherDcs = kDataCenterMgr::getAllDcs(true); foreach ($otherDcs as $remoteDc) { $remoteDcId = $remoteDc['id']; if (!isset($dcs[$remoteDcId]) && count($dcs[$remoteDcId]) != count($assets)) { continue; } $dc = $remoteDcId; KalturaLog::debug("All files exist in none-preferred dc [{$dc}]"); return true; } if ($entryDistribution->getStatus() == EntryDistributionStatus::IMPORT_SUBMITTING || $entryDistribution->getStatus() == EntryDistributionStatus::IMPORT_UPDATING) { KalturaLog::debug("Entry distribution already importing"); return false; } // create all needed import jobs $destinationDc = $distributionProfile->getRecommendedDcForDownload(); $dcExistingFiles = $dcs[$destinationDc]; foreach ($assetObjects as $assetId => $assetObject) { if (is_null($assetObject['downloadUrl'])) { KalturaLog::debug("Download URL not found for asset [{$assetId}]"); continue; } $asset = $assetObject['asset']; /* @var $asset asset */ if (isset($dcExistingFiles[$assetId])) { continue; } $jobData = new kImportJobData(); $jobData->setCacheOnly(true); self::addImportJob($destinationDc, $assetObject['downloadUrl'], $asset); } return false; }
private function deleteOldFileSyncVersions(FileSync $newFileSync) { KalturaLog::debug('Deleting old file_sync versions for [' . $newFileSync->getId() . ']'); if (kConf::hasParam('num_of_old_file_sync_versions_to_keep')) { $keepCount = kConf::get('num_of_old_file_sync_versions_to_keep'); if (!is_numeric($newFileSync->getVersion())) { return; } $intVersion = intval($newFileSync->getVersion()); $c = new Criteria(); $c->add(FileSyncPeer::OBJECT_ID, $newFileSync->getObjectId()); $c->add(FileSyncPeer::OBJECT_TYPE, $newFileSync->getObjectType()); $c->add(FileSyncPeer::OBJECT_SUB_TYPE, $newFileSync->getObjectSubType()); $c->add(FileSyncPeer::STATUS, array(FileSync::FILE_SYNC_STATUS_PURGED, FileSync::FILE_SYNC_STATUS_DELETED), Criteria::NOT_IN); $c->setLimit(40); //we limit the number of files to delete in one run so there will be no out of memory issues $fileSyncs = FileSyncPeer::doSelect($c); foreach ($fileSyncs as $fileSync) { if (is_numeric($fileSync->getVersion())) { $currentIntVersion = intval($fileSync->getVersion()); if ($intVersion - $keepCount > $currentIntVersion) { $key = kFileSyncUtils::getKeyForFileSync($fileSync); self::deleteSyncFileForKey($key); } } } } }
protected function getRemotePaths($entryId, $entryType = null) { $dbEntry = entryPeer::retrieveByPK($entryId); if (!$dbEntry || $entryType !== null && $dbEntry->getType() != $entryType) { throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId); } if ($dbEntry->getStatus() != entryStatus::READY) { throw new KalturaAPIException(KalturaErrors::ENTRY_NOT_READY, $entryId); } $c = new Criteria(); $c->add(FileSyncPeer::OBJECT_TYPE, FileSyncObjectType::ENTRY); $c->add(FileSyncPeer::OBJECT_SUB_TYPE, entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA); $c->add(FileSyncPeer::OBJECT_ID, $entryId); $c->add(FileSyncPeer::VERSION, $dbEntry->getVersion()); $c->add(FileSyncPeer::PARTNER_ID, $dbEntry->getPartnerId()); $c->add(FileSyncPeer::STATUS, FileSync::FILE_SYNC_STATUS_READY); $c->add(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_URL); $fileSyncs = FileSyncPeer::doSelect($c); $listResponse = new KalturaRemotePathListResponse(); $listResponse->objects = KalturaRemotePathArray::fromDbArray($fileSyncs, $this->getResponseProfile()); $listResponse->totalCount = count($listResponse->objects); return $listResponse; }
$lastFileSyncId = null; $loopLimit = 500; while ($moreFileSyncs) { // ---------------------------- // get next remote file syncs // ---------------------------- $exportedFileSyncsCriteria = new Criteria(); $exportedFileSyncsCriteria->setLimit($loopLimit); $exportedFileSyncsCriteria->addAscendingOrderByColumn(FileSyncPeer::ID); $exportedFileSyncsCriteria->addAnd(FileSyncPeer::DC, $storageProfileId, Criteria::EQUAL); $exportedFileSyncsCriteria->addAnd(FileSyncPeer::STATUS, FileSync::FILE_SYNC_STATUS_READY, Criteria::EQUAL); $exportedFileSyncsCriteria->addAnd(FileSyncPeer::PARTNER_ID, $partnerId, Criteria::EQUAL); if ($lastFileSyncId) { $exportedFileSyncsCriteria->addAnd(FileSyncPeer::ID, $lastFileSyncId, Criteria::GREATER_THAN); } $exportedFileSyncs = FileSyncPeer::doSelect($exportedFileSyncsCriteria, myDbHelper::getConnection(myDbHelper::DB_HELPER_CONN_PROPEL3)); // ----------------------------------------------- // delete the local dcs copies of each file sync // ----------------------------------------------- foreach ($exportedFileSyncs as $exportedFileSync) { $lastFileSyncId = $exportedFileSync->getId(); $syncKey = kFileSyncUtils::getKeyForFileSync($exportedFileSync); echo 'Deleting file sync key - ' . serialize($syncKey) . PHP_EOL; kFileSyncUtils::deleteSyncFileForKey($syncKey, false, true); // 3rd param = true -> only delete from local dcs } // -------------------------- // check if loop should end // -------------------------- if (count($exportedFileSyncs) < $loopLimit) { $moreFileSyncs = false;
$criteriaTemplate->setLimit($countLimitEachLoop); $criteria = clone $criteriaTemplate; if ($lastId) { $criteria->add(FileSyncPeer::ID, $lastId, Criteria::GREATER_THAN); } $fileSyncs = FileSyncPeer::doSelect($criteria, $con); while (count($fileSyncs)) { foreach ($fileSyncs as $fileSync) { /* @var $fileSync FileSync */ $lastId = $fileSync->getId(); $linksCriteria = new Criteria(); $linksCriteria->add(FileSyncPeer::DC, $fileSync->getDc()); $linksCriteria->add(FileSyncPeer::FILE_TYPE, array(FileSync::FILE_SYNC_FILE_TYPE_FILE, FileSync::FILE_SYNC_FILE_TYPE_LINK), Criteria::IN); $linksCriteria->add(FileSyncPeer::LINKED_ID, $fileSync->getId()); $linksCriteria->add(FileSyncPeer::STATUS, $fileSync->getStatus(), Criteria::NOT_IN); $links = FileSyncPeer::doSelect($linksCriteria, $con); KalturaStatement::setDryRun($dryRun); // change the status to current source file sync status foreach ($links as $link) { $link = cast($link, 'MigrationFileSync'); /* @var $link FileSync */ $link->setStatus($fileSync->getStatus()); $link->save(); } KalturaStatement::setDryRun(false); } $criteria = clone $criteriaTemplate; $criteria->add(FileSyncPeer::ID, $lastId, Criteria::GREATER_THAN); $fileSyncs = FileSyncPeer::doSelect($criteria, $con); usleep(100); }
protected function initFlavorAssetArray() { if (!$this->shouldInitFlavorAssetsArray()) { return; } $oneOnly = false; if ($this->deliveryAttributes->getFormat() == PlaybackProtocol::HTTP || $this->deliveryAttributes->getFormat() == "url" || $this->deliveryAttributes->getFormat() == "rtsp") { $oneOnly = true; } // get initial flavor list by input $flavorAssets = array(); if ($this->flavorIds) { $flavorAssets = assetPeer::retrieveReadyByEntryId($this->entryId, $this->flavorIds); $flavorAssets = $this->removeNotAllowedFlavors($flavorAssets); $flavorAssets = $this->removeMaxBitrateFlavors($flavorAssets); } if (!$flavorAssets || !count($flavorAssets)) { $flavorAssets = assetPeer::retrieveReadyFlavorsByEntryId($this->entryId); $flavorAssets = $this->deliveryAttributes->filterFlavorsByTags($flavorAssets); $flavorAssets = $this->removeNotAllowedFlavors($flavorAssets); $flavorAssets = $this->removeMaxBitrateFlavors($flavorAssets); } if ($this->deliveryAttributes->getFormat() == PlaybackProtocol::SILVER_LIGHT) { $this->initSilverLightManifest($flavorAssets); return; } if ($this->deliveryAttributes->getFormat() == PlaybackProtocol::HDS || $this->deliveryAttributes->getFormat() == PlaybackProtocol::APPLE_HTTP) { // try to look for a smil manifest, if it was found, we will use it for hds and hls if ($this->initSmilManifest($flavorAssets)) { return; } } // get flavors availability $servePriority = $this->entry->getPartner()->getStorageServePriority(); $localFlavors = array(); $remoteFlavorsByDc = array(); $remoteFileSyncs = array(); foreach ($flavorAssets as $flavorAsset) { $flavorId = $flavorAsset->getId(); $key = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET); $c = new Criteria(); $c = FileSyncPeer::getCriteriaForFileSyncKey($key); $c->addAnd(FileSyncPeer::STATUS, FileSync::FILE_SYNC_STATUS_READY); switch ($servePriority) { case StorageProfile::STORAGE_SERVE_PRIORITY_KALTURA_ONLY: $c->addAnd(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_URL, Criteria::NOT_EQUAL); break; case StorageProfile::STORAGE_SERVE_PRIORITY_EXTERNAL_ONLY: $c->add(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_URL); break; } if ($this->deliveryAttributes->getStorageId()) { $c->addAnd(FileSyncPeer::DC, $this->deliveryAttributes->getStorageId()); } $fileSyncs = FileSyncPeer::doSelect($c); foreach ($fileSyncs as $fileSync) { if ($fileSync->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_URL) { $dc = $fileSync->getDc(); $remoteFlavorsByDc[$dc][$flavorId] = $flavorAsset; $remoteFileSyncs[$dc][$flavorId] = $fileSync; } else { $localFlavors[$flavorId] = $flavorAsset; } } } // filter out any invalid / disabled storage profiles if ($remoteFileSyncs) { $storageProfileIds = array_keys($remoteFileSyncs); $storageProfiles = StorageProfilePeer::retrieveExternalByPartnerId($this->entry->getPartnerId(), $storageProfileIds); $activeStorageProfileIds = array(); foreach ($storageProfiles as $storageProfile) { $activeStorageProfileIds[] = $storageProfile->getId(); } foreach ($storageProfileIds as $storageProfileId) { if (in_array($storageProfileId, $activeStorageProfileIds)) { continue; } unset($remoteFlavorsByDc[$storageProfileId]); unset($remoteFileSyncs[$storageProfileId]); } } // choose the storage profile with the highest number of flavors $maxDc = null; $maxDcFlavorCount = 0; $remoteFlavors = array(); foreach ($remoteFlavorsByDc as $dc => $curDcFlavors) { $curDcFlavorCount = count($curDcFlavors); if ($curDcFlavorCount <= $maxDcFlavorCount) { continue; } $maxDc = $dc; $maxDcFlavorCount = $curDcFlavorCount; $remoteFlavors = $curDcFlavors; } // choose the flavor set according to the serve priority if ($this->shouldUseLocalFlavors($localFlavors, $remoteFlavors)) { $this->deliveryAttributes->setStorageId(null); $this->deliveryAttributes->setFlavorAssets($localFlavors); } else { if ($maxDc) { $this->deliveryAttributes->setStorageId($maxDc); $this->deliveryAttributes->setFlavorAssets($remoteFlavors); $this->deliveryAttributes->setRemoteFileSyncs($remoteFileSyncs[$maxDc]); } } if (!$this->deliveryAttributes->getFlavorAssets()) { KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND); } if ($oneOnly) { $flavorAssets = $this->deliveryAttributes->getFlavorAssets(); $this->deliveryAttributes->setFlavorAssets(array(reset($flavorAssets))); } }
/** * gets a source file of current DC, will make sure all links points to that source * are converted to files on all DCs * * @param FileSyncKey $key * @return void */ public static function convertLinksToFiles(FileSyncKey $key) { // fetch sources from all DCs $c = new Criteria(); $c = FileSyncPeer::getCriteriaForFileSyncKey($key); $fileSyncList = FileSyncPeer::doSelect($c); foreach ($fileSyncList as $fileSync) { // for each source, find its links and fix them $c = new Criteria(); $c->add(FileSyncPeer::LINKED_ID, $fileSync->getId()); $c->addAnd(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_LINK); $c->addAnd(FileSyncPeer::DC, $fileSync->getDc()); $c->addAnd(FileSyncPeer::STATUS, FileSync::FILE_SYNC_STATUS_READY); $links = FileSyncPeer::doSelect($c); foreach ($links as $link) { $link->setStatus($fileSync->getStatus()); $link->setFileRoot($fileSync->getFileRoot()); $link->setFilePath($fileSync->getFilePath()); $link->setFileType(FileSync::FILE_SYNC_FILE_TYPE_FILE); $link->save(); } } }
protected static function deleteOldVersionedFileSyncs($objectType, $objectSubType) { if (!isset(self::$oldVersionsStartUpdatedAt[$objectType])) { self::$oldVersionsStartUpdatedAt[$objectType] = 0; } if (!isset(self::$oldVersionsEndUpdatedAt[$objectType])) { self::$oldVersionsEndUpdatedAt[$objectType] = 0; } $criteria = new Criteria(); switch ($objectType) { case FileSyncObjectType::ASSET: if ($objectSubType != asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET) { return array(); } $join = new Join(); $join->addCondition(FileSyncPeer::OBJECT_ID, assetPeer::ID); $join->addCondition(FileSyncPeer::VERSION, assetPeer::VERSION, Criteria::NOT_EQUAL); $join->setJoinType(Criteria::LEFT_JOIN); $criteria->addJoinObject($join); $criteria->add(assetPeer::VERSION, null, Criteria::ISNOTNULL); break; case FileSyncObjectType::UICONF: $join = new Join(); $join->addCondition(FileSyncPeer::OBJECT_ID, uiConfPeer::ID); $join->addCondition(FileSyncPeer::VERSION, uiConfPeer::VERSION, Criteria::NOT_EQUAL); $join->setJoinType(Criteria::LEFT_JOIN); $criteria->addJoinObject($join); $criteria->add(uiConfPeer::VERSION, null, Criteria::ISNOTNULL); break; case FileSyncObjectType::ENTRY: $join = new Join(); $join->addCondition(FileSyncPeer::OBJECT_ID, entryPeer::ID); switch ($objectSubType) { case entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB: $join->addCondition(FileSyncPeer::VERSION, entryPeer::THUMBNAIL, Criteria::NOT_EQUAL); $criteria->add(entryPeer::THUMBNAIL, null, Criteria::ISNOTNULL); break; case entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA: case entry::FILE_SYNC_ENTRY_SUB_TYPE_DOWNLOAD: $join->addCondition(FileSyncPeer::VERSION, entryPeer::DATA, Criteria::NOT_EQUAL); $criteria->add(entryPeer::DATA, null, Criteria::ISNOTNULL); break; default: return array(); } $join->setJoinType(Criteria::LEFT_JOIN); $criteria->addJoinObject($join); break; case FileSyncObjectType::METADATA: $join = new Join(); $join->addCondition(FileSyncPeer::OBJECT_ID, MetadataPeer::ID); $join->addCondition(FileSyncPeer::VERSION, MetadataPeer::VERSION, Criteria::NOT_EQUAL); $join->setJoinType(Criteria::LEFT_JOIN); $criteria->addJoinObject($join); $criteria->add(MetadataPeer::VERSION, null, Criteria::ISNOTNULL); break; case FileSyncObjectType::METADATA_PROFILE: $join = new Join(); $join->addCondition(FileSyncPeer::OBJECT_ID, MetadataProfilePeer::ID); switch ($objectSubType) { case MetadataProfile::FILE_SYNC_METADATA_DEFINITION: $join->addCondition(FileSyncPeer::VERSION, MetadataProfilePeer::FILE_SYNC_VERSION, Criteria::NOT_EQUAL); $criteria->add(MetadataProfilePeer::FILE_SYNC_VERSION, null, Criteria::ISNOTNULL); break; case MetadataProfile::FILE_SYNC_METADATA_VIEWS: $join->addCondition(FileSyncPeer::VERSION, MetadataProfilePeer::VIEWS_VERSION, Criteria::NOT_EQUAL); $criteria->add(MetadataProfilePeer::VIEWS_VERSION, null, Criteria::ISNOTNULL); break; default: return array(); } $join->setJoinType(Criteria::LEFT_JOIN); $criteria->addJoinObject($join); break; default: return array(); } $criteria->add(FileSyncPeer::DC, kDataCenterMgr::getCurrentDcId()); $criteria->add(FileSyncPeer::OBJECT_TYPE, $objectType); $criteria->add(FileSyncPeer::OBJECT_SUB_TYPE, $objectSubType); $criteria->add(FileSyncPeer::STATUS, array(FileSync::FILE_SYNC_STATUS_DELETED, FileSync::FILE_SYNC_STATUS_PURGED), Criteria::NOT_IN); $nextCriteria = clone $criteria; $criteria->add(FileSyncPeer::UPDATED_AT, self::$oldVersionsStartUpdatedAt[$objectType], Criteria::GREATER_EQUAL); $criteria->addAnd(FileSyncPeer::UPDATED_AT, self::$oldVersionsEndUpdatedAt[$objectType], Criteria::LESS_EQUAL); $criteria->addAscendingOrderByColumn(FileSyncPeer::UPDATED_AT); $criteria->setLimit(self::$queryLimit); $fileSyncs = FileSyncPeer::doSelect($criteria); if (count($fileSyncs)) { foreach ($fileSyncs as $fileSync) { /* @var $fileSync FileSync */ self::deleteFileSync($fileSync); if ($fileSync->getUpdatedAt(null)) { self::$oldVersionsNextStartUpdatedAt[$objectType] = $fileSync->getUpdatedAt(null); } } } else { self::$oldVersionsNextStartUpdatedAt[$objectType] = self::$oldVersionsStartUpdatedAt[$objectType]; $nextCriteria->add(FileSyncPeer::UPDATED_AT, self::$oldVersionsStartUpdatedAt[$objectType], Criteria::GREATER_THAN); $nextCriteria->addSelectColumn('UNIX_TIMESTAMP(MIN(' . FileSyncPeer::UPDATED_AT . '))'); $stmt = FileSyncPeer::doSelectStmt($nextCriteria); $mins = $stmt->fetchAll(PDO::FETCH_COLUMN); if (count($mins)) { $oldVersionsNextStartUpdatedAt = reset($mins); if (!is_null($oldVersionsNextStartUpdatedAt)) { self::$oldVersionsNextStartUpdatedAt[$objectType] = $oldVersionsNextStartUpdatedAt; } } } kMemoryManager::clearMemory(); }
/** * Get remote storage existing paths for the asset * * @action getRemotePaths * @param string $id * @return KalturaRemotePathListResponse * @throws KalturaErrors::THUMB_ASSET_ID_NOT_FOUND * @throws KalturaErrors::THUMB_ASSET_IS_NOT_READY */ public function getRemotePathsAction($id) { $assetDb = assetPeer::retrieveById($id); if (!$assetDb || !$assetDb instanceof thumbAsset) { throw new KalturaAPIException(KalturaErrors::THUMB_ASSET_ID_NOT_FOUND, $id); } if (kEntitlementUtils::getEntitlementEnforcement()) { $entry = entryPeer::retrieveByPK($assetDb->getEntryId()); if (!$entry) { //we will throw thumb asset not found, as the user is not entitled, and should not know that the entry exists. throw new KalturaAPIException(KalturaErrors::THUMB_ASSET_ID_NOT_FOUND, $id); } } if ($assetDb->getStatus() != asset::ASSET_STATUS_READY) { throw new KalturaAPIException(KalturaErrors::THUMB_ASSET_IS_NOT_READY); } $c = new Criteria(); $c->add(FileSyncPeer::OBJECT_TYPE, FileSyncObjectType::ASSET); $c->add(FileSyncPeer::OBJECT_SUB_TYPE, asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET); $c->add(FileSyncPeer::OBJECT_ID, $id); $c->add(FileSyncPeer::VERSION, $assetDb->getVersion()); $c->add(FileSyncPeer::PARTNER_ID, $assetDb->getPartnerId()); $c->add(FileSyncPeer::STATUS, FileSync::FILE_SYNC_STATUS_READY); $c->add(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_URL); $fileSyncs = FileSyncPeer::doSelect($c); $listResponse = new KalturaRemotePathListResponse(); $listResponse->objects = KalturaRemotePathArray::fromFileSyncArray($fileSyncs); $listResponse->totalCount = count($listResponse->objects); return $listResponse; }
public function objectChanged(BaseObject $object, array $modifiedColumns) { /* @var $object FileSync */ $c = new Criteria(); $c->add(FileSyncPeer::DC, $object->getDc()); $c->add(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_LINK); $c->add(FileSyncPeer::LINKED_ID, $object->getId()); $links = FileSyncPeer::doSelect($c); foreach ($links as $link) { $link->setStatus($object->getStatus()); $link->save(); } }
/** * Retrieve multiple objects by pkey. * * @param array $pks List of primary keys * @param PropelPDO $con the connection to use * @throws PropelException Any exceptions caught during processing will be * rethrown wrapped into a PropelException. */ public static function retrieveByPKs($pks, PropelPDO $con = null) { $objs = null; if (empty($pks)) { $objs = array(); } else { $criteria = new Criteria(FileSyncPeer::DATABASE_NAME); $criteria->add(FileSyncPeer::ID, $pks, Criteria::IN); $objs = FileSyncPeer::doSelect($criteria, $con); } return $objs; }
/** * Will investigate a single entry */ public function execute() { $this->forceSystemAuthentication(); myDbHelper::$use_alternative_con = myDbHelper::DB_HELPER_CONN_PROPEL2; entryPeer::setUseCriteriaFilter(false); $this->result = NULL; $fast = $this->getRequestParameter("fast", "") != ""; $this->fast = $fast; $kshow_id = $this->getRequestParameter("kshow_id"); $this->kshow_id = $kshow_id; $this->kshow = NULL; $entry_id = $this->getRequestParameter("entry_id"); $this->entry_id = $entry_id; $this->entry = NULL; $this->error = $this->getRequestParameter("error"); $this->bg_entry = NULL; if (!empty($kshow_id)) { $c = new Criteria(); $c->add(kshowPeer::ID, $kshow_id); $kshows = kshowPeer::doSelect($c); $kshow = new kshow(); if (!$kshows) { $this->result = "No kshow [{$kshow_id}] in DB"; return; } $kshow_original = $kshows[0]; $kshow_original->getShowEntry(); // pre fetch $kshow_original->getIntro(); // pre fetch $this->kshow_original = $kshows[0]; $this->kshow = new genericObjectWrapper($this->kshow_original, true); $alredy_exist_entries = array(); $alredy_exist_entries[] = $kshow_original->getShowEntryId(); if ($kshow_original->getIntroId()) { $alredy_exist_entries[] = $kshow_original->getIntroId(); } $skin_obj = $this->kshow_original->getSkinObj(); $bg_entry_id = $skin_obj->get("bg_entry_id"); if ($bg_entry_id) { $alredy_exist_entries[] = $bg_entry_id; $this->bg_entry = new genericObjectWrapper(entryPeer::retrieveByPK($bg_entry_id), true); } $c = new Criteria(); $c->add(entryPeer::ID, $alredy_exist_entries, Criteria::NOT_IN); $c->setLimit(100); $this->kshow_entries = $this->kshow_original->getEntrysJoinKuser($c); return; //return "KshowSuccess"; } if (empty($entry_id)) { return; } entryPeer::setUseCriteriaFilter(false); // from entry table $c = new Criteria(); $c->add(entryPeer::ID, $entry_id); //$entries = entryPeer::doSelectJoinAll ( $c ); $entries = entryPeer::doSelect($c); if (!$entries) { $this->result = "No entry [{$entry_id}] in DB"; return; } $this->entry = new genericObjectWrapper($entries[0], true); // from conversion table $c = new Criteria(); $c->add(conversionPeer::ENTRY_ID, $entry_id); $original_conversions = conversionPeer::doSelect($c); //$this->conversions = array() ; // $this->conversions = $original_conversions; //new genericObjectWrapper( $original_conversions ); // find all relevant batches in DB // from batch_job table $c = new Criteria(); //$c->add ( BatchJobPeer::DATA , "%\"entryId\";i:" . $entry_id . ";%" , Criteria::LIKE ); $c->add(BatchJobPeer::ENTRY_ID, $entry_id); $original_batch_jobs = BatchJobPeer::doSelect($c); $this->batch_jobs = $original_batch_jobs; // new genericObjectWrapper( $original_batch_jobs ); // use this as a refernece of all the directories // myBatchFileConverterServer::init( true ); $entry_patttern = "/" . $entry_id . "\\..*/"; $getFileData_method = array('kFile', 'getFileData'); $getFileDataWithContent_method = array('kFile', 'getFileDataWithContent'); // find all relevant files on disk $c = new Criteria(); $c->add(FileSyncPeer::OBJECT_TYPE, FileSyncObjectType::ENTRY); $c->add(FileSyncPeer::OBJECT_ID, $entry_id); // order by OBJECT SUB TYPE $c->addAscendingOrderByColumn(FileSyncPeer::OBJECT_SUB_TYPE); $this->file_syncs = FileSyncPeer::doSelect($c); $file_sync_links = array(); $flavors = assetPeer::retrieveFlavorsByEntryId($entry_id); $flavor_ids = array(); $this->flavors = array(); foreach ($flavors as $f) { $flavor_ids[] = $f->getId(); $f->getflavorParamsOutputs(); $f->getflavorParams(); $f->getmediaInfos(); $this->flavors[] = $f; } // find all relevant files on disk $c = new Criteria(); $c->add(FileSyncPeer::OBJECT_TYPE, FileSyncObjectType::FLAVOR_ASSET); $c->add(FileSyncPeer::OBJECT_ID, $flavor_ids, Criteria::IN); // order by OBJECT SUB TYPE $c->addAscendingOrderByColumn(FileSyncPeer::OBJECT_SUB_TYPE); $flavors_file_syncs = FileSyncPeer::doSelect($c); $this->flavors_file_syncs = array(); foreach ($flavors as $flav) { foreach ($flavors_file_syncs as $f) { if ($f->getLinkedId()) { $file_sync_links[] = $f->getLinkedId(); } if ($f->getObjectId() == $flav->getId()) { $this->flavors_file_syncs[$flav->getId()][] = $f; } } } if ($this->file_syncs) { $this->file_syncs_by_sub_type = array(); foreach ($this->file_syncs as $fs) { if ($fs->getLinkedId()) { $file_sync_links[] = $fs->getLinkedId(); } $sub_type = $fs->getObjectSubType(); if (!isset($this->file_syncs_by_sub_type[$sub_type])) { // create the array $this->file_syncs_by_sub_type[$sub_type] = array(); } $this->file_syncs_by_sub_type[$sub_type][] = $fs; } } else { $this->file_syncs_by_sub_type = array(); } $file_sync_criteria = new Criteria(); $file_sync_criteria->add(FileSyncPeer::ID, $file_sync_links, Criteria::IN); $this->file_sync_links = FileSyncPeer::doSelect($file_sync_criteria); $track_entry_c = new Criteria(); $track_entry_c->add(TrackEntryPeer::ENTRY_ID, $entry_id); $track_entry_list = TrackEntryPeer::doSelect($track_entry_c); $more_interesting_track_entries = array(); foreach ($track_entry_list as $track_entry) { if ($track_entry->getTrackEventTypeId() == TrackEntry::TRACK_ENTRY_EVENT_TYPE_ADD_ENTRY) { $more_interesting_track_entries[] = $track_entry->getParam3Str(); } } $track_entry_list2 = array(); //very heavy query, skip this /* // add all the track_entry objects that are related (joined on PARAM_3_STR) $track_entry_c2 = new Criteria(); $track_entry_c2->add ( TrackEntryPeer::TRACK_EVENT_TYPE_ID , TrackEntry::TRACK_ENTRY_EVENT_TYPE_UPLOADED_FILE ); $track_entry_c2->add ( TrackEntryPeer::PARAM_3_STR , $more_interesting_track_entries , Criteria::IN ); $track_entry_list2 = TrackEntryPeer::doSelect ( $track_entry_c2 ); */ // first add the TRACK_ENTRY_EVENT_TYPE_UPLOADED_FILE - they most probably happend before the rest $this->track_entry_list = array_merge($track_entry_list2, $track_entry_list); }
/** * batch lockPendingFileSyncs action locks file syncs for import by the file sync periodic worker * * @action lockPendingFileSyncs * @param KalturaFileSyncFilter $filter * @param int $workerId The id of the file sync import worker * @param int $sourceDc The id of the DC from which the file syncs should be pulled * @param int $maxCount The maximum number of file syncs that should be returned * @param int $maxSize The maximum total size of file syncs that should be returned, this limit may be exceeded by one file sync * @return KalturaLockFileSyncsResponse */ function lockPendingFileSyncsAction(KalturaFileSyncFilter $filter, $workerId, $sourceDc, $maxCount, $maxSize = null) { // need to explicitly disable the cache since this action may not perform any queries kApiCache::disableConditionalCache(); // for dual dc deployments, if source dc is not specified, set it to the remote dc if ($sourceDc < 0) { $sourceDc = 1 - kDataCenterMgr::getCurrentDcId(); } // get caches $keysCache = kCacheManager::getSingleLayerCache(kCacheManager::CACHE_TYPE_QUERY_CACHE_KEYS); if (!$keysCache) { throw new KalturaAPIException(MultiCentersErrors::GET_KEYS_CACHE_FAILED); } $lockCache = kCacheManager::getSingleLayerCache(kCacheManager::CACHE_TYPE_LOCK_KEYS); if (!$lockCache) { throw new KalturaAPIException(MultiCentersErrors::GET_LOCK_CACHE_FAILED); } // get the max id / last id $maxId = $keysCache->get(self::MAX_FILESYNC_ID_PREFIX . $sourceDc); if (!$maxId) { throw new KalturaAPIException(MultiCentersErrors::GET_MAX_FILESYNC_ID_FAILED, $sourceDc); } $initialLastId = $keysCache->get(self::LAST_FILESYNC_ID_PREFIX . $workerId); KalturaLog::info("got lastId [{$initialLastId}] for worker [{$workerId}]"); $lastId = $initialLastId ? $initialLastId : $maxId; // created at less than handled explicitly $createdAtLessThanOrEqual = $filter->createdAtLessThanOrEqual; $filter->createdAtLessThanOrEqual = null; // build the criteria $fileSyncFilter = new FileSyncFilter(); $filter->toObject($fileSyncFilter); $baseCriteria = new Criteria(); $fileSyncFilter->attachToCriteria($baseCriteria); $baseCriteria->add(FileSyncPeer::STATUS, FileSync::FILE_SYNC_STATUS_PENDING); $baseCriteria->add(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_FILE); $baseCriteria->add(FileSyncPeer::DC, kDataCenterMgr::getCurrentDcId()); $baseCriteria->addAscendingOrderByColumn(FileSyncPeer::ID); $baseCriteria->setLimit(self::MAX_FILESYNCS_PER_CHUNK); $lockedFileSyncs = array(); $lockedFileSyncsSize = 0; $limitReached = false; $selectCount = 0; $lastSelectId = 0; $done = false; while (!$done && $selectCount < self::MAX_FILESYNC_QUERIES_PER_CALL) { // make sure last id is always increasing if ($lastId <= $lastSelectId) { KalturaLog::info("last id was decremented {$lastId} <= {$lastSelectId}, stopping"); break; } $lastSelectId = $lastId; // clear the instance pool every once in a while (not clearing every time since // some objects repeat between selects) $selectCount++; if ($selectCount % 5 == 0) { FileSyncPeer::clearInstancePool(); } // get a chunk of file syncs // Note: starting slightly before the last id, because the ids may arrive out of order in the mysql replication $c = clone $baseCriteria; $idCriterion = $c->getNewCriterion(FileSyncPeer::ID, $lastId - 100, Criteria::GREATER_THAN); $idCriterion->addAnd($c->getNewCriterion(FileSyncPeer::ID, $maxId, Criteria::LESS_THAN)); $c->addAnd($idCriterion); // Note: disabling the criteria because it accumulates more and more criterions, and the status was already explicitly added // once that bug is fixed, this can be removed FileSyncPeer::setUseCriteriaFilter(false); $fileSyncs = FileSyncPeer::doSelect($c); FileSyncPeer::setUseCriteriaFilter(true); if (!$fileSyncs) { $lastId = $maxId; break; } // if we got less than the limit no reason to perform any more queries if (count($fileSyncs) < self::MAX_FILESYNCS_PER_CHUNK) { $done = true; } $lastFileSync = end($fileSyncs); $lastId = $lastFileSync->getId(); // filter by source dc foreach ($fileSyncs as $index => $fileSync) { if ($fileSync->getOriginalDc() != $sourceDc) { unset($fileSyncs[$index]); } } // filter by object type / sub type $fileSyncs = array_filter($fileSyncs, array('FileSyncImportBatchService', 'shouldSyncFileObjectType')); if (!$fileSyncs) { continue; } // filter by created at if ($createdAtLessThanOrEqual) { $firstFileSync = reset($fileSyncs); $prevLastId = $firstFileSync->getId(); foreach ($fileSyncs as $index => $fileSync) { if ($fileSync->getCreatedAt(null) > $createdAtLessThanOrEqual) { $done = true; unset($fileSyncs[$index]); if (!is_null($prevLastId)) { $lastId = $prevLastId; $prevLastId = null; } } else { $prevLastId = $fileSync->getId(); } } if (!$fileSyncs) { break; } } // get locked file syncs with multi get $lockKeys = array(); foreach ($fileSyncs as $fileSync) { $lockKeys[] = self::LOCK_KEY_PREFIX . $fileSync->getId(); } $lockKeys = $lockCache->get($lockKeys); // try to lock file syncs foreach ($fileSyncs as $fileSync) { $curKey = self::LOCK_KEY_PREFIX . $fileSync->getId(); if (isset($lockKeys[$curKey])) { KalturaLog::info('file sync ' . $fileSync->getId() . ' already locked'); continue; } if (!$lockCache->add($curKey, true, self::LOCK_EXPIRY)) { KalturaLog::info('failed to lock file sync ' . $fileSync->getId()); continue; } KalturaLog::info('locked file sync ' . $fileSync->getId()); // get the original id if not set if (!$fileSync->getOriginalId()) { $originalFileSync = self::getOriginalFileSync($fileSync); if (!$originalFileSync) { KalturaLog::info('failed to get original file sync for ' . $fileSync->getId()); continue; } $fileSync->setOriginalId($originalFileSync->getId()); $fileSync->setCustomDataObj(); // update $fileSync->custom_data so that originalId will be set by fromObject } // add to the result set $lockedFileSyncs[] = $fileSync; $lockedFileSyncsSize += $fileSync->getFileSize(); if (count($lockedFileSyncs) >= $maxCount || $maxSize && $lockedFileSyncsSize >= $maxSize) { $lastId = $fileSync->getId(); $limitReached = true; break; } } if ($limitReached) { break; } } // update the last id // Note: it is possible that the last id will go back in case of race condition, // but the only effect of this is that some file syncs will be scanned again if (!$initialLastId || $lastId > $initialLastId) { KalturaLog::info("setting lastId to [{$lastId}] for worker [{$workerId}]"); $keysCache->set(self::LAST_FILESYNC_ID_PREFIX . $workerId, $lastId); } // make sure all file syncs have a path foreach ($lockedFileSyncs as $fileSync) { if ($fileSync->getFileRoot() && $fileSync->getFilePath()) { continue; } $fileSyncKey = kFileSyncUtils::getKeyForFileSync($fileSync); list($fileRoot, $realPath) = kPathManager::getFilePathArr($fileSyncKey); $fileSync->setFileRoot($fileRoot); $fileSync->setFilePath($realPath); } // build the response object $sourceDc = kDataCenterMgr::getDcById($sourceDc); $result = new KalturaLockFileSyncsResponse(); $result->fileSyncs = KalturaFileSyncArray::fromDbArray($lockedFileSyncs, $this->getResponseProfile()); $result->limitReached = $limitReached; $result->dcSecret = $sourceDc["secret"]; $result->baseUrl = isset($sourceDc["fileSyncImportUrl"]) ? $sourceDc["fileSyncImportUrl"] : $sourceDc["url"]; return $result; }
KalturaStatement::setDryRun($dryRun); // choose the first link and convert it to file $firstLink = array_shift($links); /* @var $firstLink FileSync */ if ($firstLink) { $firstLink = cast($firstLink, 'MigrationFileSync'); $firstLink->setLinkedId(0); // keep it zero instead of null, that's the only way to know it used to be a link. $firstLink->setFileSize($srcFileSync->getFileSize()); $firstLink->setLinkCount(count($links)); $firstLink->save(); $handledIds[] = $firstLink->getId(); } // change all the rest of the links to point on the new file sync foreach ($links as $link) { $link = cast($link, 'MigrationFileSync'); /* @var $link FileSync */ $link->setFileType(FileSync::FILE_SYNC_FILE_TYPE_LINK); $link->setLinkedId($firstLink->getId()); $link->save(); $handledIds[] = $link->getId(); } KalturaStatement::setDryRun(false); // make sure that current file handled, otherwise we will have enless loops if (!in_array($fileSync->getId(), $handledIds)) { throw new Exception("File Sync id [" . $fileSync->getId() . "] not handled"); } } $fileSyncs = FileSyncPeer::doSelect($criteriaTemplate, $con); usleep(100); }