public static function updateThumbnailFromFile($dbEntry, $filePath, $fileSyncType = entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB)
{
$dbEntry->setThumbnail(".jpg");
// this will increase the thumbnail version
$dbEntry->save();
$fileSyncKey = $dbEntry->getSyncKey($fileSyncType);
$fileSync = FileSync::createForFileSyncKey($fileSyncKey);
kFileSyncUtils::file_put_contents($fileSyncKey, file_get_contents($filePath));
$wrapper = objectWrapperBase::getWrapperClass($dbEntry);
$wrapper->removeFromCache("entry", $dbEntry->getId());
myNotificationMgr::createNotification(kNotificationJobData::NOTIFICATION_TYPE_ENTRY_UPDATE_THUMBNAIL, $dbEntry);
$mediaEntry = KalturaEntryFactory::getInstanceByType($dbEntry->getType());
$mediaEntry->fromObject($dbEntry);
self::disableAutoThumbnailCreation($dbEntry->getId());
return $mediaEntry;
}
public function executeImpl($partner_id, $subp_id, $puser_id, $partner_prefix, $puser_kuser)
{
if (!$puser_kuser) {
$this->addError(APIErrors::INVALID_USER_ID, $puser_id);
return;
}
$entry_id = $this->getPM("entry_id");
$entry = entryPeer::retrieveByPK($entry_id);
// TODO - verify the user is allowed to modify the entry
if ($entry->getKshowId() === kshow::SANDBOX_ID) {
$this->addError(APIErrors::SANDBOX_ALERT);
return;
}
$entry->setThumbnail(".jpg");
$entry->setCreateThumb(false);
$entry->save();
if (isset($HTTP_RAW_POST_DATA)) {
$thumb_data = $HTTP_RAW_POST_DATA;
} else {
$thumb_data = file_get_contents("php://input");
}
$thumb_data_size = strlen($thumb_data);
$fileSyncKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
$fileSync = FileSync::createForFileSyncKey($fileSyncKey);
kFileSyncUtils::file_put_contents($fileSyncKey, $thumb_data);
// update the metadata in case of a roughcut
if ($entry->getType() == entryType::MIX) {
$sync_key = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
$xml_doc = new DOMDocument();
$xml_doc->loadXML(kFileSyncUtils::file_get_contents($sync_key));
if (myMetadataUtils::updateThumbUrl($xml_doc, $entry->getThumbnailUrl())) {
$entry->setMetadata(null, $xml_doc->saveXML(), true, null, null);
//$entry->getVersion() );
}
myNotificationMgr::createNotification(kNotificationJobData::NOTIFICATION_TYPE_ENTRY_UPDATE_THUMBNAIL, $entry);
}
$this->res = $entry->getBigThumbnailUrl();
$wrapper = objectWrapperBase::getWrapperClass($entry, objectWrapperBase::DETAIL_LEVEL_REGULAR);
$wrapper->removeFromCache("entry", $entry->getId());
$this->addMsg("entry", $wrapper);
}
/**
* @param FileSyncKey $key
* @param $file_root
* @param $real_path
* @return SyncFile
*/
public static function createSyncFileLinkForKey(FileSyncKey $target_key, FileSyncKey $source_key)
{
KalturaLog::debug("target_key [{$target_key}], source_key [{$source_key}]");
// TODO - see that if in strict mode - there are no duplicate keys -> update existing records AND set the other DC's records to PENDING
$dc = kDataCenterMgr::getCurrentDc();
$dc_id = $dc["id"];
// load all source file syncs
$c = new Criteria();
$c = FileSyncPeer::getCriteriaForFileSyncKey($source_key);
$file_sync_list = FileSyncPeer::doSelect($c);
if (!$file_sync_list) {
KalturaLog::notice("Warning: no source. target_key [{$target_key}], source_key [{$source_key}] ");
return null;
}
$source_file_syncs = array();
foreach ($file_sync_list as $file_sync) {
$file_sync = self::resolve($file_sync);
// we only want to link to a source and not to a link.
$source_file_syncs[] = $file_sync;
}
// find the current dc file sync
$current_dc_source_file = null;
foreach ($source_file_syncs as $source_file_sync) {
if ($source_file_sync->getDc() == $dc_id) {
$current_dc_source_file = $source_file_sync;
}
}
if (!$current_dc_source_file) {
$current_dc_source_file = reset($source_file_syncs);
}
// create the remote file syncs
foreach ($source_file_syncs as $source_file_sync) {
$remote_dc_file_sync = FileSync::createForFileSyncKey($target_key);
$remote_dc_file_sync->setDc($source_file_sync->getDc());
$remote_dc_file_sync->setStatus($source_file_sync->getStatus());
$remote_dc_file_sync->setOriginal($current_dc_source_file == $source_file_sync);
$remote_dc_file_sync->setFileSize(-1);
if ($source_file_sync->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_URL) {
$remote_dc_file_sync->setFileType(FileSync::FILE_SYNC_FILE_TYPE_URL);
$remote_dc_file_sync->setFileRoot($source_file_sync->getFileRoot());
$remote_dc_file_sync->setFilePath($source_file_sync->getFilePath());
} else {
$remote_dc_file_sync->setFileType(FileSync::FILE_SYNC_FILE_TYPE_LINK);
}
$remote_dc_file_sync->setLinkedId($source_file_sync->getId());
self::incrementLinkCountForFileSync($source_file_sync);
$remote_dc_file_sync->setPartnerID($target_key->partner_id);
$remote_dc_file_sync->save();
if ($current_dc_source_file == $source_file_sync) {
$current_dc_target_file = $remote_dc_file_sync;
} else {
kEventsManager::raiseEvent(new kObjectAddedEvent($remote_dc_file_sync));
}
}
kEventsManager::raiseEvent(new kObjectAddedEvent($current_dc_target_file));
}
/**
* @param FileSyncKey $key
* @param $file_root
* @param $real_path
* @return SyncFile
*/
public static function createSyncFileLinkForKey(FileSyncKey $target_key, FileSyncKey $source_key)
{
KalturaLog::log(__METHOD__ . " - target_key [{$target_key}], source_key [{$source_key}]");
// TODO - see that if in strict mode - there are no duplicate keys -> update existing records AND set the other DC's records to PENDING
$dc = kDataCenterMgr::getCurrentDc();
$dc_id = $dc["id"];
list($sourceFile, $local) = self::getReadyFileSyncForKey($source_key, true, false);
if (!$sourceFile) {
KalturaLog::log(__METHOD__ . " - Warning: no source. target_key [{$target_key}], source_key [{$source_key}] ");
return null;
}
$sourceFile = self::resolve($sourceFile);
// we only want to link to a source and not to a link.
// create a FileSync for the current DC with status READY
$current_dc_file_sync = FileSync::createForFileSyncKey($target_key);
$current_dc_file_sync->setPartnerId($target_key->partner_id);
$current_dc_file_sync->setFileSize(-1);
$current_dc_file_sync->setStatus($sourceFile->getStatus());
$current_dc_file_sync->setOriginal(1);
if ($sourceFile->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_URL) {
$current_dc_file_sync->setFileType(FileSync::FILE_SYNC_FILE_TYPE_URL);
$current_dc_file_sync->setDc($sourceFile->getDc());
$current_dc_file_sync->setFileRoot($sourceFile->getFileRoot());
$current_dc_file_sync->setFilePath($sourceFile->getFilePath());
} else {
$current_dc_file_sync->setFileType(FileSync::FILE_SYNC_FILE_TYPE_LINK);
$current_dc_file_sync->setDc($dc_id);
$current_dc_file_sync->setLinkedId($sourceFile->getId());
}
$current_dc_file_sync->save();
//increment link_count for this DC source]
if ($sourceFile->getFileType() != FileSync::FILE_SYNC_FILE_TYPE_URL) {
self::incrementLinkCountForFileSync($sourceFile);
}
$c = new Criteria();
$c = FileSyncPeer::getCriteriaForFileSyncKey($source_key);
$file_sync_list = FileSyncPeer::doSelect($c);
$source_file_syncs = array();
foreach ($file_sync_list as $file_sync) {
$file_sync = self::resolve($file_sync);
// we only want to link to a source and not to a link.
$source_file_syncs[$file_sync->getDc()] = $file_sync;
}
foreach ($source_file_syncs as $remote_dc_id => $source_file_sync) {
if ($source_file_sync->getDc() == $current_dc_file_sync->getDc()) {
continue;
}
$remote_dc_file_sync = FileSync::createForFileSyncKey($target_key);
$remote_dc_file_sync->setDc($remote_dc_id);
$remote_dc_file_sync->setStatus($source_file_sync->getStatus());
$remote_dc_file_sync->setOriginal(0);
if ($source_file_sync->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_URL) {
$remote_dc_file_sync->setFileType(FileSync::FILE_SYNC_FILE_TYPE_URL);
$remote_dc_file_sync->setFileRoot($source_file_sync->getFileRoot());
$remote_dc_file_sync->setFilePath($source_file_sync->getFilePath());
} else {
$remote_dc_file_sync->setFileType(FileSync::FILE_SYNC_FILE_TYPE_LINK);
$remote_dc_file_sync->setLinkedId($source_file_sync->getId());
}
$remote_dc_file_sync->setPartnerID($target_key->partner_id);
$remote_dc_file_sync->save();
// increment link_cont for remote DCs sources
if ($source_file_sync->getFileType() != FileSync::FILE_SYNC_FILE_TYPE_URL) {
self::incrementLinkCountForFileSync($source_file_sync);
}
kEventsManager::raiseEvent(new kObjectAddedEvent($remote_dc_file_sync));
}
kEventsManager::raiseEvent(new kObjectAddedEvent($current_dc_file_sync));
}
/**
* @param FileSyncKey $key
* @param $file_root
* @param $real_path
* @param $strict
* @return SyncFile
*/
public static function createSyncFileLinkForKey(FileSyncKey $target_key, FileSyncKey $source_key, $strict = true)
{
KalturaLog::log(__METHOD__ . " - target_key [{$target_key}], source_key [{$source_key}]");
// TODO - see that if in strict mode - there are no duplicate keys -> update existing records AND set the other DC's records to PENDING
$dc = kDataCenterMgr::getCurrentDc();
$dc_id = $dc["id"];
$sourceFile = self::getLocalFileSyncForKey($source_key, $strict);
if (!$sourceFile) {
KalturaLog::log(__METHOD__ . " - Warning: no source but NOT strict. target_key [{$target_key}], source_key [{$source_key}] ");
return null;
}
$sourceFile = self::resolve($sourceFile);
// we only want to link to a source and not to a link.
// create a FileSync for the current DC with status READY
$current_dc_file_sync = FileSync::createForFileSyncKey($target_key);
$current_dc_file_sync->setDc($dc_id);
$current_dc_file_sync->setPartnerId($target_key->partner_id);
$current_dc_file_sync->setFileSize(-1);
$current_dc_file_sync->setStatus(FileSync::FILE_SYNC_STATUS_READY);
$current_dc_file_sync->setReadyAt(time());
$current_dc_file_sync->setOriginal(1);
$current_dc_file_sync->setLinkedId($sourceFile->getId());
$current_dc_file_sync->setFileType(FileSync::FILE_SYNC_FILE_TYPE_LINK);
$current_dc_file_sync->save();
//increment link_count for this DC source]
self::incrementLinkCountForFileSync($sourceFile);
$c = new Criteria();
$c = FileSyncPeer::getCriteriaForFileSyncKey($source_key);
$file_sync_list = FileSyncPeer::doSelect($c);
$source_file_syncs = array();
foreach ($file_sync_list as $file_sync) {
$file_sync = self::resolve($file_sync);
// we only want to link to a source and not to a link.
$source_file_syncs[$file_sync->getDc()] = $file_sync;
}
// create records for all other DCs with status READY
// link is always ready since no one is going to fetch it.
$other_dcs = kDataCenterMgr::getAllDcs();
foreach ($other_dcs as $remote_dc) {
// TODO - maybe we should create the file sync
if (!isset($source_file_syncs[$remote_dc["id"]])) {
continue;
}
$remote_dc_file_sync = FileSync::createForFileSyncKey($target_key);
$remote_dc_file_sync->setDc($remote_dc["id"]);
$remote_dc_file_sync->setStatus(FileSync::FILE_SYNC_STATUS_READY);
$remote_dc_file_sync->setOriginal(0);
$remote_dc_file_sync->setFileType(FileSync::FILE_SYNC_FILE_TYPE_LINK);
$remote_dc_file_sync->setReadyAt(time());
$remote_dc_file_sync->setPartnerID($target_key->partner_id);
$remote_dc_file_sync->setLinkedId($source_file_syncs[$remote_dc["id"]]->getId());
$remote_dc_file_sync->save();
// increment link_cont for remote DCs sources
self::incrementLinkCountForFileSync($source_file_syncs[$remote_dc["id"]]);
kEventsManager::raiseEvent(new kObjectAddedEvent($remote_dc_file_sync));
}
kEventsManager::raiseEvent(new kObjectAddedEvent($current_dc_file_sync));
}
