protected function createDirDescriber($outDir, $fileName) { $fileList = kFile::dirList($outDir, false); $fileListXml = $this->createImagesListXML($fileList); kFile::setFileContent($outDir . DIRECTORY_SEPARATOR . $fileName, $fileListXml->asXML()); KalturaLog::info('file list xml [' . $outDir . DIRECTORY_SEPARATOR . $fileName . '] created'); }
/** * @param string $type * @return KalturaTypeReflector */ static function get($type) { if (!self::$_enabled) { return new KalturaTypeReflector($type); } if (!array_key_exists($type, self::$_loadedTypeReflectors)) { $cachedDir = KAutoloader::buildPath(kConf::get("cache_root_path"), "api_v3", "typeReflector"); if (!is_dir($cachedDir)) { mkdir($cachedDir); chmod($cachedDir, 0755); } $cachedFilePath = $cachedDir . DIRECTORY_SEPARATOR . $type . ".cache"; $typeReflector = null; if (file_exists($cachedFilePath)) { $cachedData = file_get_contents($cachedFilePath); $typeReflector = unserialize($cachedData); } if (!$typeReflector) { $typeReflector = new KalturaTypeReflector($type); $cachedData = serialize($typeReflector); $bytesWritten = kFile::safeFilePutContents($cachedFilePath, $cachedData); if (!$bytesWritten) { $folderPermission = substr(decoct(fileperms(dirname($cachedFilePath))), 2); error_log("Kaltura type reflector could not be saved to path [{$cachedFilePath}] type [{$type}] folder permisisons [{$folderPermission}]"); } } self::$_loadedTypeReflectors[$type] = $typeReflector; } return self::$_loadedTypeReflectors[$type]; }
public function toObject($object_to_fill = null, $props_to_skip = array()) { $dbUploadToken = UploadTokenPeer::retrieveByPK($this->token); if (is_null($dbUploadToken)) { throw new KalturaAPIException(KalturaErrors::UPLOAD_TOKEN_NOT_FOUND); } if (!$object_to_fill) { $object_to_fill = new kUploadedFileTokenResource(); } $object_to_fill->setToken($this->token); if ($dbUploadToken->getStatus() != UploadToken::UPLOAD_TOKEN_FULL_UPLOAD) { $object_to_fill->setIsReady(false); return $object_to_fill; } try { $entryFullPath = kUploadTokenMgr::getFullPathByUploadTokenId($this->token); } catch (kCoreException $ex) { if ($ex->getCode() == kUploadTokenException::UPLOAD_TOKEN_INVALID_STATUS) { } throw new KalturaAPIException(KalturaErrors::UPLOAD_TOKEN_INVALID_STATUS_FOR_ADD_ENTRY); throw $ex; } if (!file_exists($entryFullPath)) { $remoteDCHost = kUploadTokenMgr::getRemoteHostForUploadToken($this->token, kDataCenterMgr::getCurrentDcId()); if ($remoteDCHost) { kFile::dumpApiRequest($remoteDCHost); } else { throw new KalturaAPIException(KalturaErrors::UPLOADED_FILE_NOT_FOUND_BY_TOKEN); } } $object_to_fill->setLocalFilePath($entryFullPath); return $object_to_fill; }
private static function sendRequest($params, $url = "rest") { $fullUrl = self::buildUrl($params, $url); $rsp = kFile::downloadUrlToString($fullUrl); $rsp_obj = unserialize($rsp); return $rsp_obj; }
public function execute() { $this->forceSystemAuthentication(); $this->basePath = "/content/dynamic/"; $dynamicRoot = myContentStorage::getFSContentRootPath() . $this->basePath; if ($this->getRequest()->getMethod() == sfRequest::POST) { $origFilename = basename($_FILES['Filedata']['name']); $fullPath = $dynamicRoot . $origFilename; move_uploaded_file($_FILES['Filedata']['tmp_name'], $fullPath); chmod($fullPath, 0777); return $this->renderText("ok"); } else { if ($this->getRequest()->getMethod() == sfRequest::DELETE) { $filename = basename($_REQUEST['fileName']); kFile::deleteFile($dynamicRoot . $filename); return $this->renderText("ok"); } } $this->files = kFile::dirListExtended($dynamicRoot, false); $this->extraHead = <<<EOT \t\t<style type="text/css"> \t\t\ttable{ font-size:1.2em; width:100%; margin:40px 0 0 0; } \t\t\ttable thead{ font-size:1.4em; } \t\t\t\ttable thead td{ border-bottom:1px solid #444; margin-bottom:20px; } \t\t\ttable tbody td{ padding:2px 0; color:#ccc; } \t\t\t\ttable tbody td b{ font-weight:normal; cursor:default; } \t\t\t\ttable tbody td span.btn{ margin-right:12px;} \t\t\tdiv#helper{ display:none; position:absolute; left:0; width:250px; } \t\t\tdiv#helper img{ float:right; max-width:250px; } \t\t</style> EOT; }
public function validateEntry(entry $dbEntry) { parent::validateEntry($dbEntry); $this->validatePropertyNotNull('resources'); $dc = null; foreach ($this->resources as $resource) { $resource->validateEntry($dbEntry); if (!$resource instanceof KalturaDataCenterContentResource) { continue; } $theDc = $resource->getDc(); if (is_null($theDc)) { continue; } if (is_null($dc)) { $dc = $theDc; } elseif ($dc != $theDc) { throw new KalturaAPIException(KalturaErrors::RESOURCES_MULTIPLE_DATA_CENTERS); } } if (!is_null($dc) && $dc != kDataCenterMgr::getCurrentDcId()) { $remoteHost = kDataCenterMgr::getRemoteDcExternalUrlByDcId($dc); kFile::dumpApiRequest($remoteHost); } }
public function configure() { $this->tempDirectory = isset(KBatchBase::$taskConfig->params->tempDirectoryPath) ? KBatchBase::$taskConfig->params->tempDirectoryPath : sys_get_temp_dir(); if (!is_dir($this->tempDirectory)) { kFile::fullMkfileDir($this->tempDirectory, 0700, true); } }
/** * @param CaptionAsset $captionAsset * @param BatchJob $parentJob * @throws kCoreException FILE_NOT_FOUND * @return BatchJob */ public function addParseCaptionAssetJob(CaptionAsset $captionAsset, BatchJob $parentJob = null) { $syncKey = $captionAsset->getSyncKey(asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET); $fileSync = kFileSyncUtils::getReadyInternalFileSyncForKey($syncKey); if (!$fileSync) { if (!PermissionPeer::isValidForPartner(CaptionPermissionName::IMPORT_REMOTE_CAPTION_FOR_INDEXING, $captionAsset->getPartnerId())) { throw new kCoreException("File sync not found: {$syncKey}", kCoreException::FILE_NOT_FOUND); } $fileSync = kFileSyncUtils::getReadyExternalFileSyncForKey($syncKey); if (!$fileSync) { throw new kCoreException("File sync not found: {$syncKey}", kCoreException::FILE_NOT_FOUND); } $fullPath = myContentStorage::getFSUploadsPath() . '/' . $captionAsset->getId() . '.tmp'; if (!kFile::downloadUrlToFile($fileSync->getExternalUrl($captionAsset->getEntryId()), $fullPath)) { throw new kCoreException("File sync not found: {$syncKey}", kCoreException::FILE_NOT_FOUND); } kFileSyncUtils::moveFromFile($fullPath, $syncKey, true, false, true); } $jobData = new kParseCaptionAssetJobData(); $jobData->setCaptionAssetId($captionAsset->getId()); $batchJob = null; if ($parentJob) { $batchJob = $parentJob->createChild(); } else { $batchJob = new BatchJob(); $batchJob->setEntryId($captionAsset->getEntryId()); $batchJob->setPartnerId($captionAsset->getPartnerId()); } return kJobsManager::addJob($batchJob, $jobData, CaptionSearchPlugin::getBatchJobTypeCoreValue(CaptionSearchBatchJobType::PARSE_CAPTION_ASSET)); }
private function moveFile(KalturaBatchJob $job, $fromPath, $toPath) { KalturaLog::debug("moveFile from[{$fromPath}] to[{$toPath}]"); // move file/dir to the new location $res = @rename($fromPath, $toPath); // chmod + chown + check file seen by apache - for each moved file/directory if ($res) { if (is_dir($toPath)) { $contents = kFile::listDir($toPath); sort($contents, SORT_STRING); foreach ($contents as $current) { $res = $res && $this->setAndCheck($toPath . '/' . $current); } } else { $res = $this->setAndCheck($toPath); } } if ($res) { $job->status = KalturaBatchJobStatus::FINISHED; $job->message = "File moved to final destination"; } else { $job->status = KalturaBatchJobStatus::FAILED; $job->message = "File not moved correctly"; } return $this->closeJob($job, null, null, $job->message, $job->status, null, $job->data); }
/** * Executes addComment action, which returns a form enabling the insertion of a comment * The request may include 1 fields: entry id. */ protected function executeImpl(kshow $kshow, entry &$entry) { $version = @$_REQUEST["version"]; // it's a path on the disk if (kString::beginsWith($version, ".")) { // someone is trying to hack in the system return sfView::ERROR; } // in case we're making a roughcut out of a regular invite, we start from scratch if ($entry->getMediaType() != entry::ENTRY_MEDIA_TYPE_SHOW || $entry->getDataPath($version) === null) { $this->xml_content = "<xml></xml>"; return; } // fetch content of file from disk - it should hold the XML $file_name = myContentStorage::getFSContentRootPath() . "/" . $entry->getDataPath($version); //echo "[$file_name]"; if (kString::endsWith($file_name, "xml")) { if (file_exists($file_name)) { $this->xml_content = kFile::getFileContent($file_name); // echo "[" . $this->xml_content . "]" ; } else { $this->xml_content = "<xml></xml>"; } myMetadataUtils::updateEntryForPending($entry, $version, $this->xml_content); } else { return sfView::ERROR; } // this is NOT an xml file we are looking for ! }
public function crop($quality, $cropType, $width = 0, $height = 0, $cropX = 0, $cropY = 0, $cropWidth = 0, $cropHeight = 0, $scaleWidth = 1, $scaleHeight = 1, $bgcolor = 0xffffff, $density = 0, $forceRotation = null, $strip = false) { if (is_null($quality)) { $quality = 100; } if (is_null($cropType)) { $cropType = 1; } if (is_null($width)) { $width = 0; } if (is_null($height)) { $height = 0; } if (is_null($cropX)) { $cropX = 0; } if (is_null($cropY)) { $cropY = 0; } if (is_null($cropWidth)) { $cropWidth = 0; } if (is_null($cropHeight)) { $cropHeight = 0; } if (is_null($scaleWidth)) { $scaleWidth = 1; } if (is_null($scaleHeight)) { $scaleHeight = 1; } if (is_null($bgcolor)) { $bgcolor = 0; } $cmd = $this->getCommand($quality, $cropType, $width, $height, $cropX, $cropY, $cropWidth, $cropHeight, $scaleWidth, $scaleHeight, $bgcolor, $density, $forceRotation, $strip); if ($cmd) { KalturaLog::info("Executing: {$cmd}"); $returnValue = null; $output = system($cmd, $returnValue); KalturaLog::debug("Returned value: '{$returnValue}'"); if ($returnValue) { return false; } // Support animated gifs - KImageMagick generates multiple images with a postfix of '-<frame num>' if (!kFile::fileSize($this->targetPath)) { $targetFiledir = pathinfo($this->targetPath, PATHINFO_DIRNAME); $targetFilename = pathinfo($this->targetPath, PATHINFO_FILENAME); $targetFileext = pathinfo($this->targetPath, PATHINFO_EXTENSION); $firstFrameTargetFile = "{$targetFiledir}/{$targetFilename}-0.{$targetFileext}"; if (kFile::fileSize($firstFrameTargetFile)) { kFile::moveFile($firstFrameTargetFile, $this->targetPath); } } return true; } KalturaLog::info("No conversion required, copying source[{$this->srcPath}] to target[{$this->targetPath}]"); return copy($this->srcPath, $this->targetPath); }
/** * Append recorded video to live entry * * @action appendRecording * @param string $entryId Live entry id * @param string $assetId Live asset id * @param KalturaMediaServerIndex $mediaServerIndex * @param KalturaDataCenterContentResource $resource * @param float $duration in seconds * @param bool $isLastChunk Is this the last recorded chunk in the current session (i.e. following a stream stop event) * @return KalturaLiveEntry The updated live entry * * @throws KalturaErrors::ENTRY_ID_NOT_FOUND */ function appendRecordingAction($entryId, $assetId, $mediaServerIndex, KalturaDataCenterContentResource $resource, $duration, $isLastChunk = false) { $dbEntry = entryPeer::retrieveByPK($entryId); if (!$dbEntry || !$dbEntry instanceof LiveEntry) { throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId); } $dbAsset = assetPeer::retrieveById($assetId); if (!$dbAsset || !$dbAsset instanceof liveAsset) { throw new KalturaAPIException(KalturaErrors::ASSET_ID_NOT_FOUND, $assetId); } $lastDuration = $dbEntry->getLengthInMsecs(); if (!$lastDuration) { $lastDuration = 0; } $liveSegmentDurationInMsec = (int) ($duration * 1000); $currentDuration = $lastDuration + $liveSegmentDurationInMsec; $maxRecordingDuration = (kConf::get('max_live_recording_duration_hours') + 1) * 60 * 60 * 1000; if ($currentDuration > $maxRecordingDuration) { KalturaLog::err("Entry [{$entryId}] duration [" . $dbEntry->getLengthInMsecs() . "] and current duration [{$currentDuration}] is more than max allwoed duration [{$maxRecordingDuration}]"); throw new KalturaAPIException(KalturaErrors::LIVE_STREAM_EXCEEDED_MAX_RECORDED_DURATION, $entryId); } $kResource = $resource->toObject(); $filename = $kResource->getLocalFilePath(); if (!$resource instanceof KalturaServerFileResource) { $filename = kConf::get('uploaded_segment_destination') . basename($kResource->getLocalFilePath()); kFile::moveFile($kResource->getLocalFilePath(), $filename); chgrp($filename, kConf::get('content_group')); chmod($filename, 0640); } if ($dbAsset->hasTag(assetParams::TAG_RECORDING_ANCHOR) && $mediaServerIndex == KalturaMediaServerIndex::PRIMARY) { KalturaLog::debug("Appending assetId {$assetId} to entryId {$entryId}"); $dbEntry->setLengthInMsecs($currentDuration); // Extract the exact video segment duration from the recorded file $mediaInfoParser = new KMediaInfoMediaParser($filename, kConf::get('bin_path_mediainfo')); $recordedSegmentDurationInMsec = $mediaInfoParser->getMediaInfo()->videoDuration; $currentSegmentVodToLiveDeltaTime = $liveSegmentDurationInMsec - $recordedSegmentDurationInMsec; $recordedSegmentsInfo = $dbEntry->getRecordedSegmentsInfo(); $recordedSegmentsInfo->addSegment($lastDuration, $recordedSegmentDurationInMsec, $currentSegmentVodToLiveDeltaTime); $dbEntry->setRecordedSegmentsInfo($recordedSegmentsInfo); if ($isLastChunk) { // Save last elapsed recording time $dbEntry->setLastElapsedRecordingTime($currentDuration); } $dbEntry->save(); } kJobsManager::addConvertLiveSegmentJob(null, $dbAsset, $mediaServerIndex, $filename, $currentDuration); if ($mediaServerIndex == KalturaMediaServerIndex::PRIMARY) { if (!$dbEntry->getRecordedEntryId()) { $this->createRecordedEntry($dbEntry, $mediaServerIndex); } $recordedEntry = entryPeer::retrieveByPK($dbEntry->getRecordedEntryId()); if ($recordedEntry) { $this->ingestAsset($recordedEntry, $dbAsset, $filename); } } $entry = KalturaEntryFactory::getInstanceByType($dbEntry->getType()); $entry->fromObject($dbEntry, $this->getResponseProfile()); return $entry; }
private function getAssetDataFilesArray(kConvertLiveSegmentJobData $data) { $amfFilesDir = dirname($data->getDestDataFilePath()); $pattern = "/{$data->getEntryId()}_{$data->getAssetId()}_{$data->getMediaServerIndex()}_[0-9]*.data/"; $files = kFile::recursiveDirList($amfFilesDir, true, false, $pattern); natsort($files); return $files; }
/** * Will forward to the regular swf player according to the widget_id */ public function execute() { $ui_conf_id = $this->getRequestParameter("ui_conf_id"); $preloader_path = myContentStorage::getFSContentRootPath() . "/content" . myContentStorage::getFSUiconfRootPath() . "/preloader_{$ui_conf_id}.swf"; if (!file_exists($preloader_path)) { $preloader_path = myContentStorage::getFSContentRootPath() . "/content" . myContentStorage::getFSUiconfRootPath() . "/preloader_2.swf"; } kFile::dumpFile($preloader_path); }
/** * Will forward to the regular swf player according to the widget_id */ public function execute() { $uiconf_id = $this->getRequestParameter('uiconf_id'); if (!$uiconf_id) { KExternalErrors::dieError(KExternalErrors::MISSING_PARAMETER, 'uiconf_id'); } $uiConf = uiConfPeer::retrieveByPK($uiconf_id); if (!$uiConf) { KExternalErrors::dieError(KExternalErrors::UI_CONF_NOT_FOUND); } $partner_id = $this->getRequestParameter('partner_id', $uiConf->getPartnerId()); if (!$partner_id) { KExternalErrors::dieError(KExternalErrors::MISSING_PARAMETER, 'partner_id'); } $partner_host = myPartnerUtils::getHost($partner_id); $partner_cdnHost = myPartnerUtils::getCdnHost($partner_id); $use_cdn = $uiConf->getUseCdn(); $host = $use_cdn ? $partner_cdnHost : $partner_host; $ui_conf_html5_url = $uiConf->getHtml5Url(); if (kConf::hasMap("optimized_playback")) { $optimizedPlayback = kConf::getMap("optimized_playback"); if (array_key_exists($partner_id, $optimizedPlayback)) { // force a specific kdp for the partner $params = $optimizedPlayback[$partner_id]; if (array_key_exists('html5_url', $params)) { $ui_conf_html5_url = $params['html5_url']; } } } if (kString::beginsWith($ui_conf_html5_url, "http")) { $url = $ui_conf_html5_url; // absolute URL } else { if ($ui_conf_html5_url) { $url = $host . $ui_conf_html5_url; } else { $html5_version = kConf::get('html5_version'); $url = "{$host}/html5/html5lib/{$html5_version}/mwEmbedLoader.php"; } } // append uiconf_id and partner id for optimizing loading of html5 library. append them only for "standard" urls by looking for the mwEmbedLoader.php suffix if (kString::endsWith($url, "mwEmbedLoader.php")) { $url .= "/p/{$partner_id}/uiconf_id/{$uiconf_id}"; $entry_id = $this->getRequestParameter('entry_id'); if ($entry_id) { $url .= "/entry_id/{$entry_id}"; } } requestUtils::sendCachingHeaders(60); header("Pragma:"); kFile::cacheRedirect($url); header("Location:{$url}"); die; }
private static function search($searchText, $page, $pageSize) { if (!$pageSize) { $pageSize = 100; } $pageSize = min($pageSize, 100); $startIndex = ($page - 1) * $pageSize; $url = self::$domain . "/api/videos/?vq=" . urlencode($searchText) . "&max-results=" . $pageSize . "&start-index=" . $startIndex . "&time=all_time"; $content = kFile::downloadUrlToString($url); return $content; }
public function operate(kOperator $operator = null, $inFilePath, $configFilePath = null) { //$this->outFilePath = "k:".$this->outFilePath; KalturaLog::debug("creating directory:" . $this->outFilePath); kFile::fullMkfileDir($this->outFilePath, 0777, true); $res = parent::operate($operator, $inFilePath, $configFilePath); rename("{$this->outFilePath}//playlist.m3u8", "{$this->outFilePath}//playlist.tmp"); self::parsePlayList("{$this->outFilePath}//playlist.tmp", "{$this->outFilePath}//playlist.m3u8"); // rename("out_dummy.m3u8", "$this->outFilePath//out_dummy.m3u8"); // KalturaLog::info("operator($operator), inFilePath($inFilePath), configFilePath($configFilePath)"); return $res; }
/** * @see IDistributionEngine::configure() */ public function configure(KSchedularTaskConfig $taskConfig) { if ($taskConfig->params->tempFilePath) { $this->tempFilePath = $taskConfig->params->tempFilePath; if (!is_dir($this->tempFilePath)) { kFile::fullMkfileDir($this->tempFilePath, 0777, true); } } else { $this->tempFilePath = sys_get_temp_dir(); KalturaLog::info('params.tempFilePath configuration not supplied, using default system directory [' . $this->tempFilePath . ']'); } }
private function createImagesListXML($outDirPath) { $imagesList = kFile::dirList($outDirPath, false); sort($imagesList); $imagesListXML = new SimpleXMLElement('<' . self::IMAGES_LIST_XML_LABEL_ITEMS . '/>'); foreach ($imagesList as $image) { $imageNode = $imagesListXML->addChild(self::IMAGES_LIST_XML_LABEL_ITEM); $imageNode->addChild(self::IMAGES_LIST_XML_LABEL_NAME, $image); } $imagesListXML->addAttribute(self::IMAGES_LIST_XML_ATTRIBUTE_COUNT, count($imagesList)); return $imagesListXML; }
public function configure(KSchedularTaskConfig $taskConfig) { if ($taskConfig->params->tempXmlPath) { $this->tempXmlPath = $taskConfig->params->tempXmlPath; if (!is_dir($this->tempXmlPath)) { kFile::fullMkfileDir($this->tempXmlPath, 0777, true); } } else { KalturaLog::err("params.tempXmlPath configuration not supplied"); $this->tempXmlPath = sys_get_temp_dir(); } }
/** * Generic add entry using an uploaded file, should be used when the uploaded entry type is not known * * @action addFromUploadedFile * @param KalturaBaseEntry $entry * @param string $uploadTokenId * @param KalturaEntryType $type * @return KalturaBaseEntry */ function addFromUploadedFileAction(KalturaBaseEntry $entry, $uploadTokenId, $type = -1) { try { // check that the uploaded file exists $entryFullPath = kUploadTokenMgr::getFullPathByUploadTokenId($uploadTokenId); } catch (kCoreException $ex) { if ($ex->getCode() == kUploadTokenException::UPLOAD_TOKEN_INVALID_STATUS) { } throw new KalturaAPIException(KalturaErrors::UPLOAD_TOKEN_INVALID_STATUS_FOR_ADD_ENTRY); throw $ex; } if (!file_exists($entryFullPath)) { $remoteDCHost = kUploadTokenMgr::getRemoteHostForUploadToken($uploadTokenId, kDataCenterMgr::getCurrentDcId()); if ($remoteDCHost) { kFile::dumpApiRequest($remoteDCHost); } else { throw new KalturaAPIException(KalturaErrors::UPLOADED_FILE_NOT_FOUND_BY_TOKEN); } } // validate the input object //$entry->validatePropertyMinLength("name", 1); if (!$entry->name) { $entry->name = $this->getPartnerId() . '_' . time(); } // first copy all the properties to the db entry, then we'll check for security stuff $dbEntry = $entry->toInsertableObject(new entry()); $dbEntry->setType($type); $dbEntry->setMediaType(entry::ENTRY_MEDIA_TYPE_AUTOMATIC); $this->checkAndSetValidUser($entry, $dbEntry); $this->checkAdminOnlyInsertProperties($entry); $this->validateAccessControlId($entry); $this->validateEntryScheduleDates($entry); $dbEntry->setPartnerId($this->getPartnerId()); $dbEntry->setSubpId($this->getPartnerId() * 100); $dbEntry->setSourceId($uploadTokenId); $dbEntry->setSourceLink($entryFullPath); $dbEntry->setDefaultModerationStatus(); $dbEntry->save(); $kshow = $this->createDummyKShow(); $kshowId = $kshow->getId(); myEntryUtils::setEntryTypeAndMediaTypeFromFile($dbEntry, $entryFullPath); // setup the needed params for my insert entry helper $paramsArray = array("entry_media_source" => KalturaSourceType::FILE, "entry_media_type" => $dbEntry->getMediaType(), "entry_full_path" => $entryFullPath, "entry_license" => $dbEntry->getLicenseType(), "entry_credit" => $dbEntry->getCredit(), "entry_source_link" => $dbEntry->getSourceLink(), "entry_tags" => $dbEntry->getTags()); $token = $this->getKsUniqueString(); $insert_entry_helper = new myInsertEntryHelper(null, $dbEntry->getKuserId(), $kshowId, $paramsArray); $insert_entry_helper->setPartnerId($this->getPartnerId(), $this->getPartnerId() * 100); $insert_entry_helper->insertEntry($token, $dbEntry->getType(), $dbEntry->getId(), $dbEntry->getName(), $dbEntry->getTags(), $dbEntry); $dbEntry = $insert_entry_helper->getEntry(); kUploadTokenMgr::closeUploadTokenById($uploadTokenId); myNotificationMgr::createNotification(kNotificationJobData::NOTIFICATION_TYPE_ENTRY_ADD, $dbEntry); $entry->fromObject($dbEntry); return $entry; }
public function exec(KalturaBatchJob $job) { $sharedPath = $this->getAdditionalParams('sharedTempPath'); if (!is_dir($sharedPath)) { kFile::fullMkfileDir($sharedPath); if (!is_dir($sharedPath)) { throw new Exception('Shared path [' . $sharedPath . '] doesn\'t exist and could not be created'); } } KalturaLog::debug('Temp shared path: ' . $sharedPath); /** @var KalturaScheduledTaskJobData $jobData */ $jobData = $job->data; $profileId = $job->jobObjectId; $maxResults = $jobData->maxResults ? $jobData->maxResults : 500; $scheduledTaskClient = $this->getScheduledTaskClient(); $scheduledTaskProfile = $scheduledTaskClient->scheduledTaskProfile->get($profileId); $pager = new KalturaFilterPager(); $pager->pageSize = 500; $pager->pageIndex = 1; $response = new KalturaObjectListResponse(); $response->objects = array(); $response->totalCount = 0; $resultsCount = 0; while (true) { $client = $this->getClient(); $ks = $this->createKs($client, $jobData); $client->setKs($ks); $this->impersonate($scheduledTaskProfile->partnerId); try { $results = ScheduledTaskBatchHelper::query($client, $scheduledTaskProfile, $pager); $this->unimpersonate(); } catch (Exception $ex) { $this->unimpersonate(); throw $ex; } if (!count($results->objects)) { break; } $resultsCount += count($results->objects); if ($resultsCount >= $maxResults) { break; } $response->objects = array_merge($response->objects, $results->objects); $response->totalCount += count($results->objects); $pager->pageIndex++; } $sharedFilePath = $sharedPath . '/' . uniqid('sheduledtask_'); KalturaLog::debug('Temp shared file: ' . $sharedFilePath); file_put_contents($sharedFilePath, serialize($response)); $jobData->resultsFilePath = $sharedFilePath; return $this->closeJob($job, null, null, 'Dry run finished', KalturaBatchJobStatus::FINISHED, $jobData); }
public function convert(kConversionCommand $conv_cmd, kConversionResult $conv_result, $start_params_index = 0, $end_params_index = -1) { if (!file_exists($conv_cmd->source_file)) { TRACE("File [{$conv_cmd->source_file} does not exist"); return array(false, 0); } // make sure all the output directories exist - if not create kFile::fullMkdir($conv_cmd->target_file); kFile::fullMkdir($conv_cmd->log_file); self::fixConvParams($conv_cmd); $conv_params_list = $conv_cmd->conversion_params_list; if ($end_params_index == -1) { $end_params_index = count($conv_params_list); } $start_i = max($start_params_index, 0); $end_i = min($end_params_index, count($conv_params_list)); for ($i = $start_i; $i < $end_i; ++$i) { $conv_res_info = new kConvResInfo(); $conv_res_info->engine = $this->getName(); $conv_res_info->index = $i; $conv_params = @$conv_cmd->conversion_params_list[$i]; if ($conv_params) { $conv_res_info->conv_params_name = $conv_params->name; } $log_file = $conv_cmd->getLogFileWithSuffix($i); $conv_res_info->target = $conv_cmd->getTargetFileWithSuffix($i); list($execution_command_str, $conversion_str) = $this->getExecutionCommandAndConversionString($conv_cmd, $i); $conv_res_info->conv_str = $conversion_str; // assume there always will be this index self::logMediaInfo($conv_cmd->source_file); self::addToLogFile($log_file, $execution_command_str); self::addToLogFile($log_file, $conversion_str); $return_value = ""; $conv_result->appendResult($this->getName() . ": " . $execution_command_str); TRACE($execution_command_str); $start = microtime(true); exec($execution_command_str, $output, $return_value); $end = microtime(true); TRACE($this->getName() . ": [{$return_value}]"); // $return_value == 0 is success. if not - return the index of the failed conversion $conv_result->appendResult($this->getName() . ": [{$return_value}]"); $conv_res_info->duration = $end - $start; $conv_res_info->res = $return_value; $conv_result->appendResInfo($conv_res_info); if ($return_value != 0) { return array(false, $i); } self::logMediaInfo($conv_cmd->getTargetFileWithSuffix($i)); } return array(true, -1); // indicate all was converted properly }
/** * @param KalturaBatchJob $job * @param KalturaConcatJobData $data * @param string $localTempFilePath * @param string $sharedTempFilePath * @return KalturaBatchJob */ protected function moveFile(KalturaBatchJob $job, KalturaConvertLiveSegmentJobData $data, $localTempFilePath, $sharedTempFilePath) { $this->updateJob($job, "Moving file from [{$localTempFilePath}] to [{$sharedTempFilePath}]", KalturaBatchJobStatus::MOVEFILE); kFile::moveFile($localTempFilePath, $sharedTempFilePath, true); clearstatcache(); $fileSize = kFile::fileSize($sharedTempFilePath); $this->setFilePermissions($sharedTempFilePath); if (!$this->checkFileExists($sharedTempFilePath, $fileSize)) { return $this->closeJob($job, KalturaBatchJobErrorTypes::APP, KalturaBatchJobAppErrors::NFS_FILE_DOESNT_EXIST, 'File not moved correctly', KalturaBatchJobStatus::RETRY); } $data->destFilePath = $sharedTempFilePath; return $this->closeJob($job, null, null, 'Succesfully moved file', KalturaBatchJobStatus::FINISHED, $data); }
public function configure() { parent::configure(); if (KBatchBase::$taskConfig->params->tempXmlPath) { $this->tempXmlPath = KBatchBase::$taskConfig->params->tempXmlPath; if (!is_dir($this->tempXmlPath)) { kFile::fullMkfileDir($this->tempXmlPath, 0777, true); } } else { KalturaLog::err("params.tempXmlPath configuration not supplied"); $this->tempXmlPath = sys_get_temp_dir(); } }
protected function moveFile(KalturaBatchJob $job, KalturaLiveReportExportJobData $data, $partnerId) { $fileName = basename($data->outputPath); $sharedLocation = self::$taskConfig->params->sharedPath . DIRECTORY_SEPARATOR . $partnerId . "_" . $fileName; $fileSize = kFile::fileSize($data->outputPath); rename($data->outputPath, $sharedLocation); $data->outputPath = $sharedLocation; $this->setFilePermissions($sharedLocation); if (!$this->checkFileExists($sharedLocation, $fileSize)) { return $this->closeJob($job, KalturaBatchJobErrorTypes::APP, KalturaBatchJobAppErrors::NFS_FILE_DOESNT_EXIST, 'Failed to move report file', KalturaBatchJobStatus::RETRY); } return $this->closeJob($job, null, null, 'CSV created successfully', KalturaBatchJobStatus::FINISHED, $data); }
public function execute() { $this->forceSystemAuthentication(); $file_path = $this->getP("file_path"); if (!file_exists($file_path)) { echo "Cannot find file [{$file_path}]"; die; } $mime_type = kFile::mimeType($file_path); // echo "[[$mime_type]]"; kFile::dumpFile($file_path, $mime_type); die; }
public function validateEntry(entry $dbEntry) { parent::validateEntry($dbEntry); $dc = $this->getDc(); if ($dc == kDataCenterMgr::getCurrentDcId()) { return; } $remoteDCHost = kDataCenterMgr::getRemoteDcExternalUrlByDcId($dc); if ($remoteDCHost) { kFile::dumpApiRequest($remoteDCHost); } throw new KalturaAPIException(KalturaErrors::REMOTE_DC_NOT_FOUND, $dc); }
private static function readLog($name, $size) { $pattern = "/" . $name . "\$/"; $files = kFile::recursiveDirList(self::LOG_DIR, true, false, $pattern); $result = array(); if ($files) { foreach ($files as $file) { $data = kFile::getFileData($file); $data->content = kFile::readLastBytesFromFile($file, $size); $result[] = $data; } } return $result; }
public function removeIndicator() { // delete any of the indicators available $indicator_list = kFile::recursiveDirList(self::$s_indicator_path, true, false, $this->pattern); if (count($indicator_list) > 0) { kFile::deleteFile($indicator_list[0]); } if (count($indicator_list) > 100) { // many file indicator - no real reason to leave them all for ($i = 1; $i < 50; $i++) { kFile::deleteFile($indicator_list[$i]); } } }