Removing lots of old code that is no longer used.
This commit is contained in:
paul.baranowski
parent
cb119802df
commit
90b46d8eb3
30 changed files with 9 additions and 12517 deletions
|
|
@ -19,33 +19,6 @@ class Alib {
|
|||
/* ----------------------------------------------- session/authentication */
|
||||
|
||||
/* -------------------------------------------------------- authorization */
|
||||
/**
|
||||
* Insert permission record
|
||||
*
|
||||
* @param int $sid
|
||||
* local user/group id
|
||||
* @param string $action
|
||||
* @param int $oid
|
||||
* local object id
|
||||
* @param string $type
|
||||
* 'A'|'D' (allow/deny)
|
||||
* @return int
|
||||
* local permission id
|
||||
*/
|
||||
public static function AddPerm($sid, $action, $oid, $type='A')
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
$permid = $CC_DBC->nextId($CC_CONFIG['permSequence']);
|
||||
$sql = "INSERT INTO ".$CC_CONFIG['permTable']." (permid, subj, action, obj, type)"
|
||||
." VALUES ($permid, $sid, '$action', $oid, '$type')";
|
||||
$r = $CC_DBC->query($sql);
|
||||
if (PEAR::isError($r)) {
|
||||
return($r);
|
||||
}
|
||||
return $permid;
|
||||
} // fn addPerm
|
||||
|
||||
|
||||
/**
|
||||
* Remove permission record
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1,486 +0,0 @@
|
|||
<?php
|
||||
define('BACKUP_EXT', 'tar');
|
||||
define('ACCESS_TYPE', 'backup');
|
||||
|
||||
/**
|
||||
* @package Airtime
|
||||
* @subpackage StorageServer
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
*/
|
||||
class Backup
|
||||
{
|
||||
/**
|
||||
* Name of logfile
|
||||
* @var string
|
||||
*/
|
||||
private $logFile;
|
||||
|
||||
/**
|
||||
* Session id
|
||||
* @var string
|
||||
*/
|
||||
private $sessid;
|
||||
|
||||
/**
|
||||
* struct - see search criteria
|
||||
* @var array
|
||||
*/
|
||||
private $criteria;
|
||||
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $token;
|
||||
|
||||
/**
|
||||
* name of statusfile
|
||||
* @var string
|
||||
*/
|
||||
private $statusFile;
|
||||
|
||||
/**
|
||||
* Affected gunids
|
||||
* @var array
|
||||
*/
|
||||
private $ids;
|
||||
|
||||
/**
|
||||
* Array of affected filenames
|
||||
* @var array
|
||||
*/
|
||||
private $filenames = array();
|
||||
|
||||
/**
|
||||
* Base tmp name
|
||||
* @var string
|
||||
*/
|
||||
private $tmpName;
|
||||
|
||||
/**
|
||||
* Name of temporary tarball file
|
||||
* @var string
|
||||
*/
|
||||
private $tmpFile;
|
||||
|
||||
/**
|
||||
* Name of temporary directory
|
||||
* @var string
|
||||
*/
|
||||
private $tmpDir;
|
||||
|
||||
/**
|
||||
* Name of temporary playlist directory
|
||||
* @var string
|
||||
*/
|
||||
private $tmpDirPlaylist;
|
||||
|
||||
/**
|
||||
* Name of temporary audioclip directory
|
||||
* @var string
|
||||
*/
|
||||
private $tmpDirClip;
|
||||
|
||||
/**
|
||||
* Name of temporary metafile directory
|
||||
* @var string
|
||||
*/
|
||||
private $tmpDirMeta;
|
||||
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $loglevel = 'warn'; # 'debug';
|
||||
|
||||
/**
|
||||
* @var GreenBox
|
||||
*/
|
||||
private $gb;
|
||||
|
||||
/**
|
||||
* @param GreeenBox $gb
|
||||
*/
|
||||
public function __construct(&$gb)
|
||||
{
|
||||
global $CC_CONFIG;
|
||||
$this->gb =& $gb;
|
||||
$this->token = null;
|
||||
$this->logFile = $CC_CONFIG['bufferDir'].'/'.ACCESS_TYPE.'.log';
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." construct\n");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Open a backup
|
||||
* Create a backup file (tarball)
|
||||
*
|
||||
* @param string $sessid
|
||||
* @param array $criteria
|
||||
* struct - see search criteria
|
||||
* @return array
|
||||
* hasharray with field:
|
||||
* token string: backup token
|
||||
*/
|
||||
public function openBackup($sessid, $criteria='')
|
||||
{
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." openBackup - sessid:$sessid\n");
|
||||
}
|
||||
$this->sessid = $sessid;
|
||||
$this->criteria = $criteria;
|
||||
|
||||
// get ids (and real filenames) which files match with criteria
|
||||
$srch = $this->gb->localSearch($this->criteria,$this->sessid);
|
||||
if (PEAR::isError($srch)) {
|
||||
return $srch;
|
||||
}
|
||||
$this->setIDs($srch);
|
||||
|
||||
// get real filenames
|
||||
if (is_array($this->ids)) {
|
||||
$this->setFilenames();
|
||||
|
||||
$this->setEnviroment(true);
|
||||
|
||||
// write a status file
|
||||
file_put_contents($this->statusFile, 'working');
|
||||
|
||||
// save the metafile to tmpdir
|
||||
$hostname = trim(`hostname`);
|
||||
$ctime = time();
|
||||
$ctime_f = date("Ymd-H:i:s");
|
||||
file_put_contents("{$this->tmpDirMeta}/storage.xml",
|
||||
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n".
|
||||
"<storage\n".
|
||||
" type=\"".ACCESS_TYPE."\"\n".
|
||||
" version=\"1.0\"\n".
|
||||
" ctime=\"$ctime\"\n".
|
||||
" hostname=\"$hostname\"\n".
|
||||
"/><!-- $ctime_f -->\n"
|
||||
);
|
||||
|
||||
// copy all file to tmpdir
|
||||
$this->copyAllFiles();
|
||||
|
||||
// do everything
|
||||
$this->doIt();
|
||||
|
||||
return array('token'=>$this->token);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Check the status of backup.
|
||||
*
|
||||
* @param unknown $token
|
||||
* @return array
|
||||
* status : string - susccess | working | fault
|
||||
* faultString: string - description of fault
|
||||
* token : stirng - backup token
|
||||
* url : string - access url
|
||||
* tmpfile : string - access filename
|
||||
*/
|
||||
public function checkBackup($token)
|
||||
{
|
||||
global $CC_CONFIG;
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." checkBackup - token:$token\n");
|
||||
}
|
||||
$this->token = $token;
|
||||
$this->setEnviroment();
|
||||
$status = file_get_contents($this->statusFile);
|
||||
if (strpos($status,'fault')!==false) {
|
||||
list($status,$faultString) = explode('|',$status);
|
||||
}
|
||||
switch ($status) {
|
||||
case 'success':
|
||||
$r['url'] = BasicStor::GetUrlPart()."access/$token.".BACKUP_EXT;
|
||||
$r['tmpfile'] = $CC_CONFIG['accessDir']."/$token.".BACKUP_EXT;
|
||||
case 'working':
|
||||
case 'fault':
|
||||
$r['status'] = $status;
|
||||
$r['faultString'] = $faultString;
|
||||
$r['token'] = $token;
|
||||
break;
|
||||
}
|
||||
return $r;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Close a backup
|
||||
*
|
||||
* @param unknown $token
|
||||
* @return boolean
|
||||
*/
|
||||
public function closeBackup($token)
|
||||
{
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." closeBackup - token:$token\n");
|
||||
}
|
||||
# post procedures
|
||||
$this->token = $token;
|
||||
$this->setEnviroment();
|
||||
BasicStor::bsRelease($token, ACCESS_TYPE);
|
||||
Backup::rRmDir($this->tmpDir);
|
||||
unlink($this->statusFile);
|
||||
unlink($this->tmpFile);
|
||||
if (is_file($this->tmpName)) {
|
||||
unlink($this->tmpName);
|
||||
}
|
||||
return !is_file($this->tmpFile);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* list of unclosed backups
|
||||
*
|
||||
* @param string $stat
|
||||
* if this parameter is not set, then return with all unclosed backups
|
||||
* @return array of hasharray with field:
|
||||
* status : string - susccess | working | fault
|
||||
* token : stirng - backup token
|
||||
* url : string - access url
|
||||
*/
|
||||
public function listBackups($stat='')
|
||||
{
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." listBackups - stat:$stat\n");
|
||||
}
|
||||
// open temporary dir
|
||||
$tokens = BasicStor::GetTokensByType(ACCESS_TYPE);
|
||||
// echo '<XMP>tokens:'; print_r($tokens); echo '</XMP>';
|
||||
foreach ($tokens as $token) {
|
||||
$st = $this->checkBackup($token);
|
||||
if ($stat=='' || $st['status']==$stat) {
|
||||
$r[] = $st;
|
||||
}
|
||||
}
|
||||
return $r;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set the ids from searchResult
|
||||
*
|
||||
* @param array $searchResult : array of gunids
|
||||
*/
|
||||
private function setIDs($searchResult)
|
||||
{
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." setIDs\n");
|
||||
}
|
||||
if (is_array($searchResult['results'])) {
|
||||
$this->ids = $searchResult['results'];
|
||||
} else {
|
||||
$this->addLogItem("-E- ".date("Ymd-H:i:s")." setIDs - the parameter is not array!\n");
|
||||
return PEAR::raiseError('The IDs variable isn\'t array.');
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set the filenames from ids.
|
||||
*
|
||||
*/
|
||||
private function setFilenames()
|
||||
{
|
||||
// if ($this->loglevel=='debug') {
|
||||
// $this->addLogItem("-I- ".date("Ymd-H:i:s")." setFilenames\n");
|
||||
// }
|
||||
// if (is_array($this->ids)) {
|
||||
// foreach ($this->ids as $i => $item) {
|
||||
// $gunid = $item['gunid'];
|
||||
// // get a stored file object of this gunid
|
||||
// $sf = StoredFile::RecallByGunid($gunid);
|
||||
// if (is_null($sf) || PEAR::isError($sf)) {
|
||||
// return $sf;
|
||||
// }
|
||||
// $lid = BasicStor::IdFromGunid($gunid);
|
||||
// if (($res = BasicStor::Authorize('read', $lid, $this->sessid)) !== TRUE) {
|
||||
// $this->addLogItem("-E- ".date("Ymd-H:i:s")." setFilenames - authorize gunid:$gunid\n");
|
||||
// return PEAR::raiseError('Backup::setFilenames : Authorize ... error.');
|
||||
// }
|
||||
// // if the file is a playlist then it has only a meta file
|
||||
// if (strtolower($sf->md->format) != 'playlist') {
|
||||
// $this->filenames[] = array(
|
||||
// 'filename' => $sf->getRealFileName(),
|
||||
// 'format' => $sf->md->format
|
||||
// );
|
||||
// }
|
||||
// $this->filenames[] = array(
|
||||
// 'filename' => $sf->getRealMetadataFileName(),
|
||||
// 'format' => $sf->md->format
|
||||
// );
|
||||
// if ($this->loglevel=='debug') {
|
||||
// $this->addLogItem("-I- ".date("Ymd-H:i:s")." setFilenames - add file: {$sf->md->format}|".$sf->getRealMetadataFileName()."\n");
|
||||
// }
|
||||
// }
|
||||
// return $this->filenames;
|
||||
// } else {
|
||||
// $this->addLogItem("-E- ".date("Ymd-H:i:s")." setFilenames - The IDs variable isn't array.\n");
|
||||
// return PEAR::raiseError('Backup::setFilenames : The IDs variable isn\'t array.');
|
||||
// }
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create the tarball - call the shell script
|
||||
*
|
||||
*/
|
||||
private function doIt()
|
||||
{
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." doIt\n");
|
||||
}
|
||||
$command = dirname(__FILe__)."/../bin/backup.sh"
|
||||
." {$this->tmpDir}"
|
||||
." {$this->tmpFile}"
|
||||
." {$this->statusFile}"
|
||||
." >> {$this->logFile} &";
|
||||
$res = system("$command");
|
||||
sleep(2);
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." doIt - command:$command\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Copy the real files into the tmp dirs to tar they.
|
||||
*
|
||||
*/
|
||||
private function copyAllFiles()
|
||||
{
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." copyAllFiles\n");
|
||||
}
|
||||
//echo '<XMP>this->filenames:'; print_r($this->filenames); echo '</XMP>';
|
||||
if (is_array($this->filenames)) {
|
||||
foreach ($this->filenames as $v) {
|
||||
# get the filename from full path
|
||||
$fn = substr($v['filename'],strrpos($v['filename'],'/'));
|
||||
switch (strtolower($v['format'])) {
|
||||
case 'playlist':
|
||||
# if playlist then copy to the playlist dir
|
||||
copy($v['filename'],$this->tmpDirPlaylist.$fn);
|
||||
break;
|
||||
case 'audioclip':
|
||||
# if audioclip then copy to the audioclip dir
|
||||
copy($v['filename'],$this->tmpDirClip.$fn);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Figure out the enviroment to the backup
|
||||
*
|
||||
*/
|
||||
private function setEnviroment($createDir=false)
|
||||
{
|
||||
global $CC_CONFIG;
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." setEnviroment - createDirs:$createDir\n");
|
||||
}
|
||||
// create temporary directories
|
||||
if (is_null($this->token) && $createDir) {
|
||||
$this->tmpName = tempnam($CC_CONFIG['bufferDir'], ACCESS_TYPE.'_');
|
||||
$this->tmpFile = $this->tmpName.'.'.BACKUP_EXT;
|
||||
$this->tmpDir = $this->tmpName.'.dir';
|
||||
$this->tmpDirPlaylist = $this->tmpDir. '/playlist';
|
||||
$this->tmpDirClip = $this->tmpDir. '/audioClip';
|
||||
$this->tmpDirMeta = $this->tmpDir. '/meta-inf';
|
||||
touch($this->tmpFile);
|
||||
mkdir($this->tmpDir);
|
||||
mkdir($this->tmpDirPlaylist);
|
||||
mkdir($this->tmpDirClip);
|
||||
mkdir($this->tmpDirMeta);
|
||||
$this->genToken();
|
||||
} else {
|
||||
$symlink = $CC_CONFIG['accessDir'].'/'.$this->token.'.'.BACKUP_EXT;
|
||||
if (is_link($symlink) && is_file(readlink($symlink))) {
|
||||
$this->tmpName = str_replace('.tar','',readlink($symlink));
|
||||
$this->tmpFile = $this->tmpName.'.'.BACKUP_EXT;
|
||||
$this->tmpDir = $this->tmpName.'.dir';
|
||||
$this->tmpDirPlaylist = $this->tmpDir. '/playlist';
|
||||
$this->tmpDirClip = $this->tmpDir. '/audioClip';
|
||||
$this->tmpDirMeta = $this->tmpDir. '/meta-inf';
|
||||
} else {
|
||||
$this->addLogItem("-E- ".date("Ymd-H:i:s")." setEnviroment - Corrupt symbolic link.\n");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
$this->statusFile = $CC_CONFIG['accessDir'].'/'.$this->token.'.'.BACKUP_EXT.'.status';
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("this->tmpName: $this->tmpName\n");
|
||||
$this->addLogItem("this->tmpFile: $this->tmpFile\n");
|
||||
$this->addLogItem("this->tmpDir: $this->tmpDir\n");
|
||||
$this->addLogItem("this->tmpDirPlaylist: $this->tmpDirPlaylist\n");
|
||||
$this->addLogItem("this->tmpDirClip: $this->tmpDirClip\n");
|
||||
$this->addLogItem("this->tmpDirMeta: $this->tmpDirMeta\n");
|
||||
$this->addLogItem("this->token: $this->token\n");
|
||||
$this->addLogItem("this->statusFile: $this->statusFile\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Generate a new token.
|
||||
* @return void
|
||||
*/
|
||||
private function genToken()
|
||||
{
|
||||
$acc = BasicStor::bsAccess($this->tmpFile, BACKUP_EXT, null, ACCESS_TYPE);
|
||||
if (PEAR::isError($acc)) {
|
||||
return $acc;
|
||||
}
|
||||
$this->token = $acc['token'];
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Add a line to the logfile.
|
||||
*
|
||||
* @param string $item
|
||||
* the new row of log file
|
||||
*/
|
||||
private function addLogItem($item)
|
||||
{
|
||||
$f = fopen($this->logFile,'a');
|
||||
fwrite($f,$item);
|
||||
fclose($f);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Delete a directory recursive
|
||||
*
|
||||
* @param string $dirname
|
||||
* path of dir.
|
||||
*/
|
||||
private static function rRmDir($dirname)
|
||||
{
|
||||
if (is_dir($dirname)) {
|
||||
$dir_handle = opendir($dirname);
|
||||
}
|
||||
while ($file = readdir($dir_handle)) {
|
||||
if ( ($file != ".") && ($file != "..") ) {
|
||||
if (!is_dir($dirname."/".$file)) {
|
||||
unlink ($dirname."/".$file);
|
||||
} else {
|
||||
Backup::rRmDir($dirname."/".$file);
|
||||
}
|
||||
}
|
||||
}
|
||||
closedir($dir_handle);
|
||||
rmdir($dirname);
|
||||
return true;
|
||||
}
|
||||
|
||||
} // classs Backup
|
||||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -996,370 +996,6 @@ class LocStor extends BasicStor {
|
|||
}
|
||||
|
||||
|
||||
/* ------------------------------------------------------- render methods */
|
||||
/**
|
||||
* Render playlist to ogg file (open handle)
|
||||
*
|
||||
* @param string $sessid
|
||||
* session id
|
||||
* @param string $plid
|
||||
* playlist gunid
|
||||
* @return hasharray
|
||||
* token: string - render token
|
||||
*/
|
||||
protected function renderPlaylistToFileOpen($sessid, $plid)
|
||||
{
|
||||
require_once("Renderer.php");
|
||||
$r = Renderer::rnRender2FileOpen($this, $plid);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return $r;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to ogg file (check results)
|
||||
*
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return hasharray:
|
||||
* status : string - success | working | fault
|
||||
* url : string - readable url
|
||||
*/
|
||||
protected function renderPlaylistToFileCheck($token)
|
||||
{
|
||||
require_once("Renderer.php");
|
||||
$r = Renderer::rnRender2FileCheck($this, $token);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return array('status'=>$r['status'], 'url'=>$r['url']);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to ogg file (close handle)
|
||||
*
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return boolean status
|
||||
*/
|
||||
protected function renderPlaylistToFileClose($token)
|
||||
{
|
||||
require_once("Renderer.php");
|
||||
$r = Renderer::rnRender2FileClose($this, $token);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return array(TRUE);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to storage media clip (open handle)
|
||||
*
|
||||
* @param string $sessid
|
||||
* session id
|
||||
* @param string $plid
|
||||
* playlist gunid
|
||||
* @return string
|
||||
* render token
|
||||
*/
|
||||
protected function renderPlaylistToStorageOpen($sessid, $plid)
|
||||
{
|
||||
require_once("Renderer.php");
|
||||
$owner = Alib::GetSessUserId($sessid);
|
||||
if (PEAR::isError($owner)) {
|
||||
return $owner;
|
||||
}
|
||||
$r = Renderer::rnRender2FileOpen($this, $plid, $owner);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return $r;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to storage media clip (check results)
|
||||
*
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return hasharray:
|
||||
* status : string - success | working | fault
|
||||
* gunid : string - gunid of result file
|
||||
*/
|
||||
protected function renderPlaylistToStorageCheck($token)
|
||||
{
|
||||
require_once("Renderer.php");
|
||||
$r = Renderer::rnRender2StorageCheck($this, $token);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return $r;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to RSS file (open handle)
|
||||
*
|
||||
* @param string $sessid
|
||||
* session id
|
||||
* @param string $plid
|
||||
* playlist gunid
|
||||
* @return string
|
||||
* render token
|
||||
*/
|
||||
protected function renderPlaylistToRSSOpen($sessid, $plid)
|
||||
{
|
||||
global $CC_CONFIG;
|
||||
$token = '123456789abcdeff';
|
||||
$fakeFile = $CC_CONFIG['accessDir']."/$token.rss";
|
||||
file_put_contents($fakeFile, "fake rendered file");
|
||||
return array('token'=>$token);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to RSS file (check results)
|
||||
*
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return hasharray :
|
||||
* status : string - success | working | fault
|
||||
* url : string - readable url
|
||||
*/
|
||||
protected function renderPlaylistToRSSCheck($token)
|
||||
{
|
||||
$fakeFile = $CC_CONFIG['accessDir']."/$token.rss";
|
||||
if ($token != '123456789abcdeff' || !file_exists($fakeFile)) {
|
||||
return PEAR::raiseError(
|
||||
"LocStor::renderPlaylistToRSSCheck: invalid token ($token)"
|
||||
);
|
||||
}
|
||||
$fakeFUrl = BasicStor::GetUrlPart()."access/$token.rss";
|
||||
return array(
|
||||
'status'=> 'success',
|
||||
'url' => $fakeFUrl,
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to RSS file (close handle)
|
||||
*
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return boolean
|
||||
* status
|
||||
*/
|
||||
protected function renderPlaylistToRSSClose($token)
|
||||
{
|
||||
if ($token != '123456789abcdeff') {
|
||||
return PEAR::raiseError(
|
||||
"LocStor::renderPlaylistToRSSClose: invalid token"
|
||||
);
|
||||
}
|
||||
$fakeFile = $CC_CONFIG['accessDir']."/$token.rss";
|
||||
unlink($fakeFile);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/*================================================= storage admin methods */
|
||||
|
||||
/* ------------------------------------------------------- backup methods */
|
||||
|
||||
/**
|
||||
* Create backup of storage (open handle)
|
||||
*
|
||||
* @param string $sessid
|
||||
* session id
|
||||
* @param array $criteria
|
||||
* see search criteria
|
||||
* @return array
|
||||
* token : string - backup token
|
||||
*/
|
||||
protected function createBackupOpen($sessid, $criteria='')
|
||||
{
|
||||
require_once("Backup.php");
|
||||
$bu = new Backup($this);
|
||||
if (PEAR::isError($bu)) {
|
||||
return $bu;
|
||||
}
|
||||
$r = $bu->openBackup($sessid,$criteria);
|
||||
if ($r === FALSE) {
|
||||
return PEAR::raiseError(
|
||||
"LocStor::createBackupOpen: false returned from Backup"
|
||||
);
|
||||
}
|
||||
return $r;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create backup of storage (check results)
|
||||
*
|
||||
* @param string $token
|
||||
* backup token
|
||||
* @return hasharray
|
||||
* with field:
|
||||
* status : string - susccess | working | fault
|
||||
* faultString: string - description of fault
|
||||
* token : stirng - backup token
|
||||
* url : string - access url
|
||||
*/
|
||||
protected function createBackupCheck($token)
|
||||
{
|
||||
require_once("Backup.php");
|
||||
$bu = new Backup($this);
|
||||
if (PEAR::isError($bu)) {
|
||||
return $bu;
|
||||
}
|
||||
return $bu->checkBackup($token);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create backup of storage (list results)
|
||||
*
|
||||
* @param string $sessid
|
||||
* session id
|
||||
* @param status $stat
|
||||
* if this parameter is not set, then return with all unclosed backups
|
||||
* @return array
|
||||
* array of hasharray with field:
|
||||
* status : string - susccess | working | fault
|
||||
* token : stirng - backup token
|
||||
* url : string - access url
|
||||
*/
|
||||
protected function createBackupList($sessid, $stat='')
|
||||
{
|
||||
require_once("Backup.php");
|
||||
$bu = new Backup($this);
|
||||
if (PEAR::isError($bu)) {
|
||||
return $bu;
|
||||
}
|
||||
return $bu->listBackups($stat);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create backup of storage (close handle)
|
||||
*
|
||||
* @param string $token
|
||||
* backup token
|
||||
* @return boolean
|
||||
* status
|
||||
*/
|
||||
protected function createBackupClose($token)
|
||||
{
|
||||
require_once("Backup.php");
|
||||
$bu = new Backup($this);
|
||||
if (PEAR::isError($bu)) {
|
||||
return $bu;
|
||||
}
|
||||
return $bu->closeBackup($token);
|
||||
}
|
||||
|
||||
|
||||
/* ------------------------------------------------------ restore methods */
|
||||
|
||||
/**
|
||||
* Restore a backup file (open handle)
|
||||
*
|
||||
* @param string $sessid
|
||||
* session id
|
||||
* @param string $chsum
|
||||
* md5 checksum of imported file
|
||||
* @return array
|
||||
* array with:
|
||||
* url string: writable URL
|
||||
* fname string: writable local filename
|
||||
* token string: PUT token
|
||||
*/
|
||||
protected function restoreBackupOpen($sessid, $chsum)
|
||||
{
|
||||
$userid = Alib::getSessUserId($sessid);
|
||||
if (PEAR::isError($userid)) {
|
||||
return $userid;
|
||||
}
|
||||
$r = $this->bsOpenPut($chsum, NULL, $userid);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return $r;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Restore a backup file (close put handle)
|
||||
*
|
||||
* @param string $sessid
|
||||
* session id
|
||||
* @param string $token
|
||||
* "put" token
|
||||
* @return string $token
|
||||
* restore token
|
||||
*/
|
||||
protected function restoreBackupClosePut($sessid, $token) {
|
||||
$arr = $this->bsClosePut($token);
|
||||
if (PEAR::isError($arr)) {
|
||||
return $arr;
|
||||
}
|
||||
$fname = $arr['fname'];
|
||||
require_once('Restore.php');
|
||||
$rs = new Restore($this);
|
||||
if (PEAR::isError($rs)) {
|
||||
return $rs;
|
||||
}
|
||||
return $rs->openRestore($sessid, $fname);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Restore a backup file (check state)
|
||||
*
|
||||
* @param string $token
|
||||
* restore token
|
||||
* @return array
|
||||
* status - fields:
|
||||
* token: string - restore token
|
||||
* status: string - working | fault | success
|
||||
* faultString: string - description of fault
|
||||
*/
|
||||
protected function restoreBackupCheck($token)
|
||||
{
|
||||
require_once('Restore.php');
|
||||
$rs = new Restore($this);
|
||||
if (PEAR::isError($rs)) {
|
||||
return $rs;
|
||||
}
|
||||
return $rs->checkRestore($token);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Restore a backup file (close handle)
|
||||
*
|
||||
* @param string $token
|
||||
* restore token
|
||||
* @return array
|
||||
* status - fields:
|
||||
* token: string - restore token
|
||||
* status: string - working | fault | success
|
||||
*/
|
||||
protected function restoreBackupClose($token) {
|
||||
require_once('Restore.php');
|
||||
$rs = new Restore($this);
|
||||
if (PEAR::isError($rs)) {
|
||||
return $rs;
|
||||
}
|
||||
return $rs->closeRestore($token);
|
||||
}
|
||||
|
||||
|
||||
/*===================================================== auxiliary methods */
|
||||
/**
|
||||
* Dummy method - only returns Airtime version
|
||||
|
|
|
|||
|
|
@ -1,351 +0,0 @@
|
|||
<?
|
||||
define('INDCH', ' ');
|
||||
|
||||
/**
|
||||
* M3uPlaylist class
|
||||
*
|
||||
* @package Airtime
|
||||
* @subpackage StorageServer
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
*/
|
||||
class M3uPlaylist {
|
||||
|
||||
/**
|
||||
* Parse M3U file or string
|
||||
*
|
||||
* @param string $data
|
||||
* local path to M3U file or M3U string
|
||||
* @param string $loc
|
||||
* location: 'file'|'string'
|
||||
* @return array
|
||||
* reference, parse result tree (or PEAR::error)
|
||||
*/
|
||||
function &parse($data='', $loc='file')
|
||||
{
|
||||
switch ($loc) {
|
||||
case "file":
|
||||
if (!is_file($data)) {
|
||||
return PEAR::raiseError(
|
||||
"M3uPlaylist::parse: file not found ($data)"
|
||||
);
|
||||
}
|
||||
if (!is_readable($data)) {
|
||||
return PEAR::raiseError(
|
||||
"M3uPlaylist::parse: can't read file ($data)"
|
||||
);
|
||||
}
|
||||
$data = file_get_contents($data);
|
||||
case "string":
|
||||
$arr = preg_split("|\n#EXTINF: |", $data);
|
||||
if ($arr[0] != '#EXTM3U') {
|
||||
return PEAR::raiseError(
|
||||
"M3uPlaylist::parse: invalid M3U header"
|
||||
);
|
||||
}
|
||||
array_shift($arr);
|
||||
break;
|
||||
default:
|
||||
return PEAR::raiseError(
|
||||
"M3uPlaylist::parse: unsupported data location ($loc)"
|
||||
);
|
||||
}
|
||||
return $arr;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Import M3U file to storage
|
||||
*
|
||||
* @param GreenBox $gb
|
||||
* @param string $aPath
|
||||
* absolute path part of imported file (e.g. /home/user/airtime)
|
||||
* @param string $rPath
|
||||
* relative path/filename part of imported file
|
||||
* (e.g. playlists/playlist_1.smil)
|
||||
* @param array $gunids
|
||||
* hash relation from filenames to gunids
|
||||
* @param string $plid
|
||||
* playlist gunid
|
||||
* @param int $subjid
|
||||
* local subject (user) id (id of user doing the import)
|
||||
* @return Playlist
|
||||
*/
|
||||
function import(&$gb, $aPath, $rPath, &$gunids, $plid, $subjid=NULL)
|
||||
{
|
||||
// $path = realpath("$aPath/$rPath");
|
||||
// if (FALSE === $path) {
|
||||
// return PEAR::raiseError(
|
||||
// "M3uPlaylist::import: file doesn't exist ($aPath/$rPath)"
|
||||
// );
|
||||
// }
|
||||
// $arr = M3uPlaylist::parse($path);
|
||||
// if (PEAR::isError($arr)) {
|
||||
// return $arr;
|
||||
// }
|
||||
// require_once("Playlist.php");
|
||||
// $pl =& Playlist::create($gb, $plid, "imported_M3U");
|
||||
// if (PEAR::isError($pl)) {
|
||||
// return $pl;
|
||||
// }
|
||||
// $r = $pl->lock($gb, $subjid);
|
||||
// if (PEAR::isError($r)) {
|
||||
// return $r;
|
||||
// }
|
||||
// foreach ($arr as $i => $it) {
|
||||
// list($md, $uri) = preg_split("|\n|", $it);
|
||||
// list($length, $title) = preg_split("|, *|", $md);
|
||||
// // $gunid = StoredFile::CreateGunid();
|
||||
// $gunid = ( isset($gunids[basename($uri)]) ? $gunids[basename($uri)] : NULL);
|
||||
// $acId = BasicStor::IdFromGunid($gunid);
|
||||
// if (PEAR::isError($acId)) {
|
||||
// return $acId;
|
||||
// }
|
||||
// $length = Playlist::secondsToPlaylistTime($length);
|
||||
// $offset = '???';
|
||||
// if (preg_match("|\.([a-zA-Z0-9]+)$|", $uri, $va)) {
|
||||
// switch (strtolower($ext = $va[1])) {
|
||||
// case "lspl":
|
||||
// case "xml":
|
||||
// case "smil":
|
||||
// case "m3u":
|
||||
// $acId = $gb->bsImportPlaylistRaw($gunid,
|
||||
// $aPath, $uri, $ext, $gunids, $subjid);
|
||||
// if (PEAR::isError($acId)) {
|
||||
// break;
|
||||
// }
|
||||
// //no break!
|
||||
// default:
|
||||
// if (is_null($gunid)) {
|
||||
// return PEAR::raiseError(
|
||||
// "M3uPlaylist::import: no gunid");
|
||||
// }
|
||||
// $r = $pl->addAudioClip($acId);
|
||||
// if (PEAR::isError($r)) {
|
||||
// return $r;
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// $r = $pl->unlock($gb);
|
||||
// if (PEAR::isError($r)) {
|
||||
// return $r;
|
||||
// }
|
||||
// return $pl;
|
||||
}
|
||||
|
||||
/**
|
||||
* Import M3U file to storage
|
||||
*
|
||||
* @param GreenBox $gb
|
||||
* @param string $data
|
||||
* local path to M3U file
|
||||
* @return string
|
||||
* XML playlist in Airtime playlist format
|
||||
*/
|
||||
function convert2lspl(&$gb, $data)
|
||||
{
|
||||
$arr = M3uPlaylist::parse($data);
|
||||
if (PEAR::isError($arr)) {
|
||||
return $arr;
|
||||
}
|
||||
$ind = '';
|
||||
$ind2 = $ind.INDCH;
|
||||
$ind3 = $ind2.INDCH;
|
||||
$res = '';
|
||||
foreach ($arr as $i => $it) {
|
||||
list($md, $uri) = preg_split("|\n|", $it);
|
||||
list($length, $title) = preg_split("|, *|", $md);
|
||||
$gunid = StoredFile::CreateGunid();
|
||||
$gunid2 = StoredFile::CreateGunid();
|
||||
$length = Playlist::secondsToPlaylistTime($length);
|
||||
$offset = '???';
|
||||
$clipStart = '???';
|
||||
$clipEnd = '???';
|
||||
$clipLength = '???';
|
||||
$uri_h = preg_replace("|--|", "d;d;", htmlspecialchars("$uri"));
|
||||
if (preg_match("|\.([a-zA-Z0-9]+)$|", $uri, $va)) {
|
||||
switch (strtolower($ext = $va[1])) {
|
||||
case "lspl":
|
||||
case "xml":
|
||||
case "smil":
|
||||
case "m3u":
|
||||
$acOrPl = "$ind3<playlist id=\"$gunid2\" ".
|
||||
"playlength=\"$length\" title=\"$title\"/> ".
|
||||
"<!-- $uri_h -->\n";
|
||||
break;
|
||||
default:
|
||||
$acOrPl = "$ind3<audioClip id=\"$gunid2\" ".
|
||||
"playlength=\"$length\" title=\"$title\"/> ".
|
||||
"<!-- $uri_h -->\n";
|
||||
break;
|
||||
}
|
||||
}
|
||||
$res .= "$ind2<playlistElement id=\"$gunid\" relativeOffset=\"$offset\" clipStart=\"$clipStart\" clipEnd=\"$clipEnd\" clipLength=\"$clipLength\">\n".
|
||||
$acOrPl.
|
||||
"$ind2</playlistElement>\n";
|
||||
}
|
||||
$res = "$ind<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n".
|
||||
"$ind<playlist id=\"$gunid\" playlength=\"$playlength\" title=\"\">\n".
|
||||
"$ind2<metadata/>\n".
|
||||
"$res".
|
||||
"$ind</playlist>\n";
|
||||
return $res;
|
||||
}
|
||||
} // class M3uPlaylist
|
||||
|
||||
|
||||
/**
|
||||
* @package Airtime
|
||||
* @subpackage StorageServer
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
*/
|
||||
class M3uPlaylistBodyElement {
|
||||
function convert2lspl(&$tree, $ind='')
|
||||
{
|
||||
$ind2 = $ind.INDCH;
|
||||
if ($tree->name != 'body') {
|
||||
return PEAR::raiseError("M3uPlaylist::parse: body tag expected");
|
||||
}
|
||||
if (isset($tree->children[1])) {
|
||||
return PEAR::raiseError(sprintf(
|
||||
"M3uPlaylist::parse: unexpected tag %s in tag body",
|
||||
$tree->children[1]->name
|
||||
));
|
||||
}
|
||||
$res = M3uPlaylistParElement::convert2lspl($tree->children[0], $ind2);
|
||||
if (PEAR::isError($res)) {
|
||||
return $res;
|
||||
}
|
||||
$gunid = StoredFile::CreateGunid();
|
||||
$playlength = '???'; // ***
|
||||
$res = "$ind<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n".
|
||||
"$ind<playlist id=\"$gunid\" playlength=\"$playlength\" title=\"\">\n".
|
||||
"$ind2<metadata/>\n".
|
||||
"$res".
|
||||
"$ind</playlist>\n";
|
||||
return $res;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @package Airtime
|
||||
* @subpackage StorageServer
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
*/
|
||||
class M3uPlaylistParElement {
|
||||
function convert2lspl(&$tree, $ind='')
|
||||
{
|
||||
if ($tree->name != 'par') {
|
||||
return PEAR::raiseError("M3uPlaylist::parse: par tag expected");
|
||||
}
|
||||
$res = '';
|
||||
foreach ($tree->children as $i => $ch) {
|
||||
$ch =& $tree->children[$i];
|
||||
$r = M3uPlaylistAudioElement::convert2lspl($ch, $ind.INDCH);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
$res .= $r;
|
||||
}
|
||||
return $res;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @package Airtime
|
||||
* @subpackage StorageServer
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
*/
|
||||
class M3uPlaylistAudioElement {
|
||||
function convert2lspl(&$tree, $ind='')
|
||||
{
|
||||
$ind2 = $ind.INDCH;
|
||||
if ($tree->name != 'audio') {
|
||||
return PEAR::raiseError("M3uPlaylist::parse: audio tag expected");
|
||||
}
|
||||
if (isset($tree->children[2])) {
|
||||
return PEAR::raiseError(sprintf(
|
||||
"M3uPlaylist::parse: unexpected tag %s in tag audio",
|
||||
$tree->children[2]->name
|
||||
));
|
||||
}
|
||||
$res = ''; $fadeIn = 0; $fadeOut = 0;
|
||||
foreach ($tree->children as $i => $ch) {
|
||||
$ch =& $tree->children[$i];
|
||||
$r = M3uPlaylistAnimateElement::convert2lspl($ch, $ind2);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
switch ($r['type']) {
|
||||
case "fadeIn":
|
||||
$fadeIn = $r['val'];
|
||||
break;
|
||||
case "fadeOut":
|
||||
$fadeOut = $r['val'];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ($fadeIn > 0 || $fadeOut > 0) {
|
||||
$fadeIn = Playlist::secondsToPlaylistTime($fadeIn);
|
||||
$fadeOut = Playlist::secondsToPlaylistTime($fadeOut);
|
||||
$fInfo = "$ind2<fadeInfo fadeIn=\"$fadeIn\" fadeOut=\"$fadeOut\"/>\n";
|
||||
} else {
|
||||
$fInfo = '';
|
||||
}
|
||||
$plElGunid = StoredFile::CreateGunid();
|
||||
$aGunid = StoredFile::CreateGunid();
|
||||
$title = basename($tree->attrs['src']->val);
|
||||
$offset = Playlist::secondsToPlaylistTime($tree->attrs['begin']->val);
|
||||
$playlength = '???'; # ***
|
||||
$res = "$ind<playlistElement id=\"$plElGunid\" relativeOffset=\"$offset\">\n".
|
||||
"$ind2<audioClip id=\"$aGunid\" playlength=\"$playlength\" title=\"$title\"/>\n".
|
||||
$fInfo.
|
||||
"$ind</playlistElement>\n";
|
||||
return $res;
|
||||
}
|
||||
} // class M3uPlaylistAudioElement
|
||||
|
||||
|
||||
/**
|
||||
* @package Airtime
|
||||
* @subpackage StorageServer
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
*/
|
||||
class M3uPlaylistAnimateElement {
|
||||
function convert2lspl(&$tree, $ind='') {
|
||||
if ($tree->name != 'animate') {
|
||||
return PEAR::raiseError("M3uPlaylist::parse: animate tag expected");
|
||||
}
|
||||
if ($tree->attrs['attributeName']->val == 'soundLevel' &&
|
||||
$tree->attrs['from']->val == '0%' &&
|
||||
$tree->attrs['to']->val == '100%' &&
|
||||
$tree->attrs['calcMode']->val == 'linear' &&
|
||||
$tree->attrs['fill']->val == 'freeze' &&
|
||||
$tree->attrs['begin']->val == '0s' &&
|
||||
preg_match("|^([0-9.]+)s$|", $tree->attrs['end']->val, $va)
|
||||
) {
|
||||
return array('type'=>'fadeIn', 'val'=>$va[1]);
|
||||
}
|
||||
if ($tree->attrs['attributeName']->val == 'soundLevel' &&
|
||||
$tree->attrs['from']->val == '100%' &&
|
||||
$tree->attrs['to']->val == '0%' &&
|
||||
$tree->attrs['calcMode']->val == 'linear' &&
|
||||
$tree->attrs['fill']->val == 'freeze' &&
|
||||
preg_match("|^([0-9.]+)s$|", $tree->attrs['begin']->val, $vaBegin) &&
|
||||
preg_match("|^([0-9.]+)s$|", $tree->attrs['end']->val, $vaEnd)
|
||||
) {
|
||||
return array('type'=>'fadeOut', 'val'=>($vaEnd[1] - $vaBegin[1]));
|
||||
}
|
||||
return PEAR::raiseError(
|
||||
"M3uPlaylistAnimateElement::convert2lspl: animate parameters too general"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -42,7 +42,7 @@ class Prefs {
|
|||
*/
|
||||
function loadPref($sessid, $key)
|
||||
{
|
||||
$subjid = GreenBox::GetSessUserId($sessid);
|
||||
$subjid = Alib::GetSessUserId($sessid);
|
||||
if (PEAR::isError($subjid)) {
|
||||
return $subjid;
|
||||
}
|
||||
|
|
@ -75,7 +75,7 @@ class Prefs {
|
|||
*/
|
||||
function savePref($sessid, $key, $value)
|
||||
{
|
||||
$subjid = GreenBox::GetSessUserId($sessid);
|
||||
$subjid = Alib::GetSessUserId($sessid);
|
||||
if (PEAR::isError($subjid)) {
|
||||
return $subjid;
|
||||
}
|
||||
|
|
@ -107,7 +107,7 @@ class Prefs {
|
|||
*/
|
||||
function delPref($sessid, $key)
|
||||
{
|
||||
$subjid = GreenBox::GetSessUserId($sessid);
|
||||
$subjid = Alib::GetSessUserId($sessid);
|
||||
if (PEAR::isError($subjid)) {
|
||||
return $subjid;
|
||||
}
|
||||
|
|
@ -180,7 +180,7 @@ class Prefs {
|
|||
*/
|
||||
function saveGroupPref($sessid, $group, $key, $value)
|
||||
{
|
||||
$uid = GreenBox::GetSessUserId($sessid);
|
||||
$uid = Alib::GetSessUserId($sessid);
|
||||
if (PEAR::isError($uid)) {
|
||||
return $uid;
|
||||
}
|
||||
|
|
@ -230,7 +230,7 @@ class Prefs {
|
|||
*/
|
||||
function delGroupPref($sessid, $group, $key)
|
||||
{
|
||||
$uid = GreenBox::GetSessUserId($sessid);
|
||||
$uid = Alib::GetSessUserId($sessid);
|
||||
if (PEAR::isError($uid)) {
|
||||
return $uid;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,289 +0,0 @@
|
|||
<?php
|
||||
define('RENDER_EXT', 'ogg');
|
||||
|
||||
require_once("Playlist.php");
|
||||
|
||||
/**
|
||||
* Renderer caller class
|
||||
*
|
||||
* Playlist to file rendering - PHP layer, caller to the renderer executable
|
||||
*
|
||||
* @package Airtime
|
||||
* @subpackage StorageServer
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
* @see LocStor
|
||||
*/
|
||||
class Renderer
|
||||
{
|
||||
|
||||
/**
|
||||
* Render playlist to ogg file (open handle)
|
||||
*
|
||||
* @param GreenBox $gb
|
||||
* greenbox object reference
|
||||
* @param string $plid
|
||||
* playlist gunid
|
||||
* @param int $owner
|
||||
* local subject id, owner of token
|
||||
* @return array
|
||||
* token: string - render token
|
||||
*/
|
||||
function rnRender2FileOpen(&$gb, $plid, $owner=NULL)
|
||||
{
|
||||
global $CC_CONFIG;
|
||||
// recall playlist:
|
||||
$pl = StoredFile::RecallByGunid($plid);
|
||||
if (is_null($pl) || PEAR::isError($pl)) {
|
||||
return $pl;
|
||||
}
|
||||
// smil export:
|
||||
$smil = $pl->outputToSmil();
|
||||
if (PEAR::isError($smil)) {
|
||||
return $smil;
|
||||
}
|
||||
// temporary file for smil:
|
||||
$tmpn = tempnam($CC_CONFIG['bufferDir'], 'plRender_');
|
||||
$smilf = "$tmpn.smil";
|
||||
file_put_contents($smilf, $smil);
|
||||
$url = "file://$smilf";
|
||||
// output file:
|
||||
$outf = "$tmpn.".RENDER_EXT;
|
||||
touch($outf);
|
||||
// logging:
|
||||
$logf = $CC_CONFIG['bufferDir']."/renderer.log";
|
||||
file_put_contents($logf, "--- ".date("Ymd-H:i:s")."\n", FILE_APPEND);
|
||||
// open access to output file: /*gunid*/ /*parent*/
|
||||
$acc = BasicStor::bsAccess($outf, RENDER_EXT, $plid, 'render', 0, $owner);
|
||||
if (PEAR::isError($acc)) {
|
||||
return $acc;
|
||||
}
|
||||
extract($acc);
|
||||
$statf = Renderer::getStatusFile($gb, $token);
|
||||
file_put_contents($statf, "working");
|
||||
// command:
|
||||
$stServDir = dirname(__FILE__)."/..";
|
||||
$renderExe = "$stServDir/bin/renderer.sh";
|
||||
$command = "$renderExe -p $url -o $outf -s $statf >> $logf &";
|
||||
file_put_contents($logf, "$command\n", FILE_APPEND);
|
||||
$res = system($command);
|
||||
if ($res === FALSE) {
|
||||
return PEAR::raiseError(
|
||||
'Renderer::rnRender2File: Error running renderer'
|
||||
);
|
||||
}
|
||||
return array('token'=>$token);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to ogg file (check results)
|
||||
*
|
||||
* @param GreenBox $gb
|
||||
* GreenBox object reference
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return array
|
||||
* status : string - success | working | fault
|
||||
* url : string - readable url
|
||||
*/
|
||||
function rnRender2FileCheck(&$gb, $token)
|
||||
{
|
||||
$statf = Renderer::getStatusFile($gb, $token);
|
||||
if (!file_exists($statf)) {
|
||||
return PEAR::raiseError(
|
||||
'Renderer::rnRender2FileCheck: Invalid token'
|
||||
);
|
||||
}
|
||||
$status = trim(file_get_contents($statf));
|
||||
$url = Renderer::getUrl($gb, $token);
|
||||
$tmpfile= Renderer::getLocalFile($gb, $token);
|
||||
return array('status'=>$status, 'url'=>$url, 'tmpfile'=>$tmpfile);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to ogg file (list results)
|
||||
*
|
||||
* @param GreenBox $gb
|
||||
* greenbox object reference
|
||||
* @param string $stat
|
||||
* status (optional) if this parameter is not set, then return with all unclosed backups
|
||||
* @return array
|
||||
* array of hasharray:
|
||||
* status : string - success | working | fault
|
||||
* url : string - readable url
|
||||
*/
|
||||
function rnRender2FileList(&$gb,$stat='') {
|
||||
// open temporary dir
|
||||
$tokens = BasicStor::GetTokensByType('render');
|
||||
foreach ($tokens as $token) {
|
||||
$st = Renderer::rnRender2FileCheck($gb, $token);
|
||||
if ( ($stat=='') || ($st['status']==$stat) ) {
|
||||
$r[] = $st;
|
||||
}
|
||||
}
|
||||
return $r;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to ogg file (close handle)
|
||||
*
|
||||
* @param GreenBox $gb
|
||||
* greenbox object reference
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return mixed
|
||||
* TRUE or PEAR_Error
|
||||
*/
|
||||
function rnRender2FileClose(&$gb, $token)
|
||||
{
|
||||
global $CC_CONFIG;
|
||||
$r = BasicStor::bsRelease($token, 'render');
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
$realOgg = $r['realFname'];
|
||||
$tmpn = $CC_CONFIG['bufferDir']."/".basename($realOgg, '.'.RENDER_EXT);
|
||||
$smilf = "$tmpn.smil";
|
||||
$statf = Renderer::getStatusFile($gb, $token);
|
||||
@unlink($statf);
|
||||
@unlink($realOgg);
|
||||
@unlink($smilf);
|
||||
@unlink($tmpn);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to storage as audioClip (check results)
|
||||
*
|
||||
* @param GreenBox $gb
|
||||
* greenbox object reference
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return array
|
||||
* status : string - success | working | fault
|
||||
* gunid: string - global unique id of result file
|
||||
*/
|
||||
function rnRender2StorageCheck(&$gb, $token)
|
||||
{
|
||||
$r = Renderer::rnRender2FileCheck($gb, $token);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
$status = $r['status'];
|
||||
$res = array('status' => $status, 'gunid'=>'NULL');
|
||||
switch ($status) {
|
||||
case "fault":
|
||||
$res['faultString'] = "Error runing renderer";
|
||||
break;
|
||||
case "success":
|
||||
$r = Renderer::rnRender2StorageCore($gb, $token);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
$res['gunid'] = $r['gunid'];
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return $res;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Render playlist to storage as audioClip (core method)
|
||||
*
|
||||
* @param GreenBox $gb
|
||||
* greenbox object reference
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return array:
|
||||
* gunid: string - global unique id of result file
|
||||
*/
|
||||
function rnRender2StorageCore(&$gb, $token)
|
||||
{
|
||||
// $r = BasicStor::bsRelease($token, 'render');
|
||||
// if (PEAR::isError($r)) {
|
||||
// return $r;
|
||||
// }
|
||||
// $realOgg = $r['realFname'];
|
||||
// $owner = $r['owner'];
|
||||
// $gunid = $r['gunid'];
|
||||
// $fileName = 'rendered_playlist';
|
||||
// $id = BasicStor::IdFromGunid($gunid);
|
||||
// if (PEAR::isError($id)) {
|
||||
// return $id;
|
||||
// }
|
||||
// $mdata = '';
|
||||
// foreach (array('dc:title', 'dcterms:extent', 'dc:creator', 'dc:description') as $item) {
|
||||
// $val = $gb->bsGetMetadataValue($id, $item);
|
||||
// $mdata .= " <$item>$val</$item>\n";
|
||||
// }
|
||||
// $mdata = "<audioClip>\n <metadata>\n$mdata </metadata>\n</audioClip>\n";
|
||||
// //$mdata = "<audioClip>\n <metadata>\n$mdata<dcterms:extent>0</dcterms:extent>\n</metadata>\n</audioClip>\n";
|
||||
// $values = array(
|
||||
// "filename" => $fileName,
|
||||
// "filepath" => $realOgg,
|
||||
// "metadata" => $mdata,
|
||||
// "filetype" => "audioclip"
|
||||
// );
|
||||
// $storedFile = $gb->bsPutFile($values);
|
||||
// if (PEAR::isError($storedFile)) {
|
||||
// return $storedFile;
|
||||
// }
|
||||
// return array('gunid' => $storedFile->getGunid());
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Return local filepath of rendered file
|
||||
*
|
||||
* @param Greenbox $gb
|
||||
* greenbox object reference
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return array
|
||||
*/
|
||||
function getLocalFile(&$gb, $token)
|
||||
{
|
||||
global $CC_CONFIG;
|
||||
$token = StoredFile::NormalizeGunid($token);
|
||||
return $CC_CONFIG['accessDir']."/$token.".RENDER_EXT;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Return filepath of render status file
|
||||
*
|
||||
* @param GreenBox $gb
|
||||
* greenbox object reference
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return array
|
||||
*/
|
||||
function getStatusFile(&$gb, $token)
|
||||
{
|
||||
return Renderer::getLocalFile($gb, $token).".status";
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Return remote accessible URL for rendered file
|
||||
*
|
||||
* @param GreenBox $gb
|
||||
* greenbox object reference
|
||||
* @param string $token
|
||||
* render token
|
||||
* @return array
|
||||
*/
|
||||
function getUrl(&$gb, $token)
|
||||
{
|
||||
$token = StoredFile::NormalizeGunid($token);
|
||||
return BasicStor::GetUrlPart()."access/$token.".RENDER_EXT;
|
||||
}
|
||||
|
||||
} // class Renderer
|
||||
|
||||
|
|
@ -1,436 +0,0 @@
|
|||
<?php
|
||||
|
||||
/**
|
||||
* @package Airtime
|
||||
* @subpackage StorageServer
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
*/
|
||||
class Restore {
|
||||
/**
|
||||
* Name of logfile
|
||||
* @var string
|
||||
*/
|
||||
private $logFile;
|
||||
|
||||
/**
|
||||
* session id
|
||||
* @var string
|
||||
*/
|
||||
private $sessid;
|
||||
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $token;
|
||||
|
||||
/**
|
||||
* Name of statusfile
|
||||
* @var string
|
||||
*/
|
||||
private $statusFile;
|
||||
|
||||
/**
|
||||
* Name of temporary directory, to here extract the backup tarball
|
||||
* @var string
|
||||
*/
|
||||
private $tmpDir;
|
||||
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
// private $loglevel = 'warn';
|
||||
public $loglevel = 'warn';
|
||||
// public $loglevel = 'debug';
|
||||
|
||||
/**
|
||||
* @var GreenBox
|
||||
*/
|
||||
private $gb;
|
||||
|
||||
private $ACCESS_TYPE = 'restore';
|
||||
|
||||
/**
|
||||
* @param GreenBox $gb
|
||||
* greenbox object reference
|
||||
*/
|
||||
public function __construct(&$gb)
|
||||
{
|
||||
global $CC_CONFIG;
|
||||
$this->gb =& $gb;
|
||||
$this->token = null;
|
||||
$this->logFile = $CC_CONFIG['bufferDir'].'/'.$this->ACCESS_TYPE.'.log';
|
||||
if ($this->loglevel == 'debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." construct\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Call asyncronously the restore procedure. Restore from backup.
|
||||
*
|
||||
* @param string $sessid
|
||||
* session id
|
||||
* @param string $backup_file
|
||||
* path of the backup file
|
||||
* @return array
|
||||
* hasharray with field:
|
||||
* token string: backup token
|
||||
*/
|
||||
function openRestore($sessid, $backup_file)
|
||||
{
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I-".date("Ymd-H:i:s")." doRestore - sessid:$sessid\n");
|
||||
}
|
||||
$this->sessid = $sessid;
|
||||
|
||||
// generate token
|
||||
$this->token = StoredFile::CreateGunid();
|
||||
|
||||
// status file -> working
|
||||
$this->setEnviroment();
|
||||
file_put_contents($this->statusFile, 'working');
|
||||
|
||||
//call the restore script in background
|
||||
$command = dirname(__FILE__).'/../bin/restore.php';
|
||||
$runLog = "/dev/null";
|
||||
$params = "{$backup_file} {$this->statusFile} {$this->token} {$sessid}>> $runLog &";
|
||||
$ret = system("$command $params", $st);
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I-".date("Ymd-H:i:s")." restore.php call: $st/$ret\n");
|
||||
}
|
||||
|
||||
return array('token'=>$this->token);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Check the status of restore
|
||||
*
|
||||
* @param string $token
|
||||
* @return array
|
||||
* hasharray with field:
|
||||
* status : string - susccess | working | fault
|
||||
* faultString : string - description of fault
|
||||
* token : stirng - backup token
|
||||
* url : string - access url
|
||||
* tmpfile : string - access filename
|
||||
*/
|
||||
function checkRestore($token)
|
||||
{
|
||||
if ($this->loglevel == 'debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." checkBackup - token:$token\n");
|
||||
}
|
||||
$this->token = $token;
|
||||
$this->setEnviroment();
|
||||
if (is_file($this->statusFile)) {
|
||||
$r = array();
|
||||
$stat = file_get_contents($this->statusFile);
|
||||
if (strpos($stat,'fault|') !== false) {
|
||||
list($stat,$message) = explode('|',$stat);
|
||||
}
|
||||
$r['status'] = $stat;
|
||||
if ($stat=='fault') {
|
||||
$r['faultString'] = $message;
|
||||
} else {
|
||||
$r['faultString'] = '';
|
||||
}
|
||||
return $r;
|
||||
} else {
|
||||
return PEAR::raiseError('Restore::checkRestore: invalid token!');
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Check the status of restore.
|
||||
*
|
||||
* @param string $token
|
||||
* @return array
|
||||
* hasharray with field:
|
||||
* status : boolean - is success
|
||||
*/
|
||||
function closeRestore($token)
|
||||
{
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." checkBackup - token:$token\n");
|
||||
}
|
||||
$this->token = $token;
|
||||
$this->setEnviroment();
|
||||
$this->rRmDir($this->tmpDir);
|
||||
unlink($this->statusFile);
|
||||
return array("status" => !is_file($this->statusFile));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Do restore in background
|
||||
*
|
||||
* this function is called from the asyncron commandline script
|
||||
* ../bin/restore.php
|
||||
*
|
||||
* @param string $backupfile
|
||||
* path of backupfile
|
||||
* @param string $token
|
||||
* restore token
|
||||
* @param string $sessid
|
||||
* session id
|
||||
*/
|
||||
function startRestore($backupfile, $token, $sessid)
|
||||
{
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." startRestore - bufile:$backupfile | token:$token\n");
|
||||
}
|
||||
$this->token = $token;
|
||||
$this->sessid = $sessid;
|
||||
$this->setEnviroment();
|
||||
|
||||
// extract tarball
|
||||
$command = 'tar -xf '.$backupfile .' --directory '.$this->tmpDir;
|
||||
$res = system($command);
|
||||
//$this->addLogItem('command: '.$command."\n");
|
||||
//$this->addLogItem('res: '.$res."\n");
|
||||
|
||||
//simple check of archive format
|
||||
if (is_dir($this->tmpDir.'audioClip/') &&
|
||||
is_dir($this->tmpDir.'meta-inf/') &&
|
||||
is_dir($this->tmpDir.'playlist/')) {
|
||||
//search metafiles
|
||||
$this->metafiles = $this->getMetaFiles();
|
||||
#$this->addLogItem('metafiles:'.print_r($this->metafiles,true));
|
||||
//add to storage server
|
||||
foreach ($this->metafiles as $info) {
|
||||
$r = $this->addFileToStorage($info['file'],$info['type'],$info['id']);
|
||||
if (PEAR::isError($r)) {
|
||||
$this->addLogItem("-E- ".date("Ymd-H:i:s").
|
||||
" startRestore - addFileToStorage \n".
|
||||
"(".$put->getMessage()."/".$put->getUserInfo().")\n"
|
||||
);
|
||||
file_put_contents($this->statusFile, 'fault|'.$put->getMessage()."/".$put->getUserInfo());
|
||||
return;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$this->addLogItem("-E- ".date("Ymd-H:i:s")." startRestore - invalid archive format\n");
|
||||
file_put_contents($this->statusFile, 'fault|invalid archive format');
|
||||
return;
|
||||
}
|
||||
file_put_contents($this->statusFile, 'success');
|
||||
// unlink($backupfile);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the metafiles.
|
||||
*
|
||||
* @return array
|
||||
* array of hasharray with field:
|
||||
* file : string - metafile path
|
||||
* type : stirng - audioClip | playlist
|
||||
* id : string - the backuped gunid
|
||||
*/
|
||||
function getMetaFiles()
|
||||
{
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." getMetaFiles - tmpDir:{$this->tmpDir}\n");
|
||||
}
|
||||
$audioclips = scandir($this->tmpDir.'audioClip/');
|
||||
$playlists = scandir($this->tmpDir.'playlist/');
|
||||
for ($i = 0; $i < count($audioclips); $i++) {
|
||||
if (strpos($audioclips[$i],'xml')!==false)
|
||||
$r[] = array('file' => $this->tmpDir.'audioClip/'.$audioclips[$i],
|
||||
'type' => 'audioClip',
|
||||
'id' => str_replace('.xml','',$audioclips[$i]));
|
||||
}
|
||||
for ($i = 0; $i < count($playlists); $i++) {
|
||||
if (strpos($playlists[$i],'xml') !== false)
|
||||
$r[] = array('file' => $this->tmpDir.'playlist/'.$playlists[$i],
|
||||
'type' => 'playlist',
|
||||
'id' => str_replace('.xml','',$playlists[$i]));
|
||||
}
|
||||
return $r;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Add the file to the storage server.
|
||||
*
|
||||
* @param string $file
|
||||
* path of metafile
|
||||
* @param string $type
|
||||
* restore token
|
||||
* @param string $sessid
|
||||
* session id
|
||||
*
|
||||
* @return mixed
|
||||
* true if success or PEAR_error
|
||||
*/
|
||||
// function addFileToStorage($file,$type,$gunid)
|
||||
// {
|
||||
// if ($this->loglevel=='debug') {
|
||||
// $this->addLogItem("-I- ".date("Ymd-H:i:s")." addFileToStorage - file:$file | type:$type | id:$gunid\n");
|
||||
// }
|
||||
// require_once("XmlParser.php");
|
||||
// $tree = XmlParser::parse($file);
|
||||
// $mediaFileLP = str_replace('.xml','',$file);
|
||||
// $mediaFileLP = ($type=='audioClip' && is_file($mediaFileLP))?$mediaFileLP:'';
|
||||
// $ex = $this->gb->existsFile($this->sessid,$gunid);
|
||||
// if (PEAR::isError($ex)) {
|
||||
// $this->addLogItem("-E- ".date("Ymd-H:i:s").
|
||||
// " addFileToStorage - existsFile($gunid) ".
|
||||
// "(".$ex->getMessage()."/".$ex->getUserInfo().")\n"
|
||||
// );
|
||||
// }
|
||||
// if (!PEAR::isError($ex) && $ex) { // file is exists in storage server
|
||||
// //replace it
|
||||
// $id = BasicStor::IdFromGunid($gunid);
|
||||
// $replace = $this->gb->replaceFile(
|
||||
// $id, # id int, virt.file's local id
|
||||
// $mediaFileLP, # mediaFileLP string, local path of media file
|
||||
// $file, # mdataFileLP string, local path of metadata file
|
||||
// $this->sessid); # sessid string, session id
|
||||
// if (PEAR::isError($replace)) {
|
||||
// $this->addLogItem("-E- ".date("Ymd-H:i:s").
|
||||
// " addFileToStorage - replaceFile Error ".
|
||||
// "(".$replace->getMessage()."/".$replace->getUserInfo().")\n"
|
||||
// );
|
||||
// file_put_contents($this->statusFile, 'fault|'.$replace->getMessage()."/".$replace->getUserInfo());
|
||||
// return $replace;
|
||||
// }
|
||||
// #$this->addLogItem("replace it \n");
|
||||
// } else {
|
||||
// // add as new
|
||||
// $name = $tree->children[0]->children[0]->content;
|
||||
// if (empty($name)) {
|
||||
// $name = $tree->attrs['title']->val;
|
||||
// }
|
||||
// if (empty($name)) {
|
||||
// $name = '???';
|
||||
// }
|
||||
// if ($this->loglevel=='debug') {
|
||||
// $this->addLogItem("-I- ".date("Ymd-H:i:s")." putFile\n".
|
||||
// "$name, $mediaFileLP, $file, {$this->sessid}, $gunid, $type \n"
|
||||
// );
|
||||
// }
|
||||
// $values = array(
|
||||
// "filename" => $name,
|
||||
// "filepath" => $mediaFileLP,
|
||||
// "metadata" => $file,
|
||||
// "gunid" => $gunid,
|
||||
// "filetype" => $type
|
||||
// );
|
||||
// $put = $this->gb->putFile($values, $this->sessid);
|
||||
// //$this->addLogItem("add as new \n");
|
||||
// if (PEAR::isError($put)) {
|
||||
// $this->addLogItem("-E- ".date("Ymd-H:i:s").
|
||||
// " addFileToStorage - putFile Error ".
|
||||
// "(".$put->getMessage()."/".$put->getUserInfo().")\n"
|
||||
// ."\n---\n".file_get_contents($file)."\n---\n"
|
||||
// );
|
||||
// file_put_contents($this->statusFile, 'fault|'.$put->getMessage()."/".$put->getUserInfo());
|
||||
// //$this->addLogItem("Error Object: ".print_r($put,true)."\n");
|
||||
// return $put;
|
||||
// }
|
||||
// }
|
||||
// $ac = StoredFile::RecallByGunid($gunid);
|
||||
// if (is_null($ac) || PEAR::isError($ac)) {
|
||||
// return $ac;
|
||||
// }
|
||||
// $res = $ac->setState('ready');
|
||||
// if (PEAR::isError($res)) {
|
||||
// return $res;
|
||||
// }
|
||||
// return true;
|
||||
// }
|
||||
|
||||
|
||||
/**
|
||||
* Figure out the environment to the backup.
|
||||
*
|
||||
*/
|
||||
function setEnviroment()
|
||||
{
|
||||
global $CC_CONFIG;
|
||||
if ($this->loglevel=='debug') {
|
||||
$this->addLogItem("-I- ".date("Ymd-H:i:s")." setEnviroment\n");
|
||||
}
|
||||
$this->statusFile = $CC_CONFIG['accessDir'].'/'.$this->token.'.status';
|
||||
$this->tmpDir = '/tmp/ls_restore/'.$this->token.'/';
|
||||
$this->rMkDir($this->tmpDir);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Add a line to the logfile.
|
||||
*
|
||||
* @param string $item
|
||||
* the new row of log file
|
||||
*/
|
||||
function addLogItem($item)
|
||||
{
|
||||
$f = fopen ($this->logFile,'a');
|
||||
flock($f,LOCK_SH);
|
||||
fwrite($f,$item);
|
||||
flock($f,LOCK_UN);
|
||||
fclose($f);
|
||||
//echo file_get_contents($this->logFile)."<BR><BR>\n\n";
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Delete a directory recursive
|
||||
*
|
||||
* @param string $dirname
|
||||
* path of dir
|
||||
*
|
||||
* @return boolean
|
||||
* is success
|
||||
*/
|
||||
function rRmDir($dirname)
|
||||
{
|
||||
if (is_dir($dirname)) {
|
||||
$dir_handle = opendir($dirname);
|
||||
}
|
||||
while ($file = readdir($dir_handle)) {
|
||||
if ($file!="." && $file!="..") {
|
||||
if (!is_dir($dirname."/".$file)) {
|
||||
unlink ($dirname."/".$file);
|
||||
} else {
|
||||
Restore::rRmDir($dirname."/".$file);
|
||||
}
|
||||
}
|
||||
}
|
||||
closedir($dir_handle);
|
||||
rmdir($dirname);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a directory recursive
|
||||
*
|
||||
* @param string $dirname
|
||||
* path of dir.
|
||||
* @param int $mode
|
||||
* octal - rights of dir.
|
||||
* @param boolean $recursive
|
||||
* do it recursive.
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
function rMkDir($dirname, $mode=0777, $recursive=true)
|
||||
{
|
||||
if (is_null($dirname) || $dirname === "" ) {
|
||||
return false;
|
||||
}
|
||||
if (is_dir($dirname) || $dirname === "/" ) {
|
||||
return true;
|
||||
}
|
||||
if ($this->rMkDir(dirname($dirname), $mode, $recursive)) {
|
||||
return mkdir($dirname, $mode);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
} // class Restore
|
||||
|
||||
|
|
@ -1271,14 +1271,14 @@ class StoredFile {
|
|||
if (!file_exists($this->filepath) || @unlink($this->filepath)) {
|
||||
$this->exists = FALSE;
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
else {
|
||||
return PEAR::raiseError(
|
||||
"StoredFile::deleteFile: unlink failed ({$this->filepath})",
|
||||
GBERR_FILEIO
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
$this->exists = FALSE;
|
||||
return TRUE;
|
||||
|
|
@ -1304,7 +1304,7 @@ class StoredFile {
|
|||
|
||||
Playlist::DeleteFileFromAllPlaylists($this->id);
|
||||
}
|
||||
|
||||
|
||||
$sql = "DELETE FROM ".$CC_CONFIG['filesTable']
|
||||
." WHERE gunid='{$this->gunid}'";
|
||||
$res = $CC_DBC->query($sql);
|
||||
|
|
@ -1717,7 +1717,7 @@ class StoredFile {
|
|||
|
||||
foreach($searchCols as $col) {
|
||||
$escapedTerm = pg_escape_string($term);
|
||||
$innerCond[] = "{$col}::text ILIKE '%{$escapedTerm}%'";
|
||||
$innerCond[] = "{$col}::text ILIKE '%{$escapedTerm}%'";
|
||||
}
|
||||
$outerCond[] = "(".join(" OR ", $innerCond).")";
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,48 +13,11 @@ define('ALIBERR_BADSMEMB', 21);
|
|||
* @subpackage Alib
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
* @see ObjClasses
|
||||
* @see Alib
|
||||
*/
|
||||
class Subjects {
|
||||
|
||||
/* ======================================================= public methods */
|
||||
|
||||
/**
|
||||
* Add new subject (a.k.a. "user")
|
||||
*
|
||||
* @param string $p_login
|
||||
* @param string $p_pass
|
||||
* @param string $p_realname
|
||||
* @param boolean $p_passenc
|
||||
* password already encrypted if true
|
||||
* @return int|PEAR_Error
|
||||
*/
|
||||
public static function AddSubj($p_login, $p_pass=NULL, $p_realname='', $p_passenc=FALSE)
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
if (!$p_login) {
|
||||
return $CC_DBC->raiseError("Subjects::AddSubj: empty login");
|
||||
}
|
||||
$id = $CC_DBC->nextId($CC_CONFIG['subjSequence']);
|
||||
if (PEAR::isError($id)) {
|
||||
return $id;
|
||||
}
|
||||
if (!is_null($p_pass) && !$p_passenc) {
|
||||
$p_pass = md5($p_pass);
|
||||
}
|
||||
$sql = "INSERT INTO ".$CC_CONFIG['subjTable']." (id, login, pass, type, realname)"
|
||||
." VALUES ($id, '$p_login', ".
|
||||
(is_null($p_pass) ? "'!', 'G'" : "'$p_pass', 'U'").",
|
||||
'$p_realname')";
|
||||
$r = $CC_DBC->query($sql);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return $id;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Check login and password
|
||||
*
|
||||
|
|
@ -77,28 +40,6 @@ class Subjects {
|
|||
} // fn authenticate
|
||||
|
||||
|
||||
/**
|
||||
* Set lastlogin or lastfail timestamp
|
||||
*
|
||||
* @param string $login
|
||||
* @param boolean $failed
|
||||
* true=> set lastfail, false=> set lastlogin
|
||||
* @return boolean|int|PEAR_Error
|
||||
*/
|
||||
public static function SetTimeStamp($login, $failed=FALSE)
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
$fld = ($failed ? 'lastfail' : 'lastlogin');
|
||||
$sql = "UPDATE ".$CC_CONFIG['subjTable']." SET $fld=now()"
|
||||
." WHERE login='$login'";
|
||||
$r = $CC_DBC->query($sql);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return TRUE;
|
||||
} // fn setTimeStamp
|
||||
|
||||
|
||||
/**
|
||||
* Change user password
|
||||
*
|
||||
|
|
@ -137,52 +78,6 @@ class Subjects {
|
|||
|
||||
/* --------------------------------------------------------------- groups */
|
||||
|
||||
/**
|
||||
* Add {login} and direct/indirect members to {gname} and to groups,
|
||||
* where {gname} is [in]direct member
|
||||
*
|
||||
* @param string $login
|
||||
* @param string $gname
|
||||
* @return int|PEAR_Error
|
||||
*/
|
||||
public static function AddSubjectToGroup($login, $gname)
|
||||
{
|
||||
$uid = Subjects::GetSubjId($login);
|
||||
if (PEAR::isError($uid)) {
|
||||
return $uid;
|
||||
}
|
||||
$gid = Subjects::GetSubjId($gname);
|
||||
if (PEAR::isError($gid)) {
|
||||
return $gid;
|
||||
}
|
||||
$isgr = Subjects::IsGroup($gid);
|
||||
if (PEAR::isError($isgr)) {
|
||||
return $isgr;
|
||||
}
|
||||
if (!$isgr) {
|
||||
return PEAR::raiseError("Subjects::addSubj2Gr: Not a group ($gname)", ALIBERR_NOTGR);
|
||||
}
|
||||
// add subject and all [in]direct members to group $gname:
|
||||
$mid = Subjects::_plainAddSubjectToGroup($uid, $gid);
|
||||
if (PEAR::isError($mid)) {
|
||||
return $mid;
|
||||
}
|
||||
// add it to all groups where $gname is [in]direct member:
|
||||
$marr = Subjects::_listRMemb($gid);
|
||||
if (PEAR::isError($marr)) {
|
||||
return $marr;
|
||||
}
|
||||
foreach ($marr as $k => $v) {
|
||||
$r = Subjects::_plainAddSubjectToGroup(
|
||||
$uid, $v['gid'], intval($v['level'])+1, $v['id']);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
}
|
||||
return $mid;
|
||||
} // fn addSubj2Gr
|
||||
|
||||
|
||||
/* --------------------------------------------------------- info methods */
|
||||
|
||||
/**
|
||||
|
|
@ -201,114 +96,6 @@ class Subjects {
|
|||
} // fn getSubjId
|
||||
|
||||
|
||||
/**
|
||||
* Get subject name (login) from id
|
||||
*
|
||||
* @param int $id
|
||||
* @param string $fld
|
||||
* @return string|PEAR_Error
|
||||
*/
|
||||
public static function GetSubjName($id, $fld='login')
|
||||
{
|
||||
global $CC_CONFIG;
|
||||
global $CC_DBC;
|
||||
$sql = "SELECT $fld FROM ".$CC_CONFIG['subjTable']
|
||||
." WHERE id='$id'";
|
||||
return $CC_DBC->getOne($sql);
|
||||
} // fn getSubjName
|
||||
|
||||
|
||||
/**
|
||||
* Get one subject from the table.
|
||||
*
|
||||
* @param string $p_fieldValue
|
||||
* @param string $p_fieldName
|
||||
* @return array
|
||||
*/
|
||||
public static function GetSubject($p_fieldValue, $p_fieldName='login')
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
if (!in_array($p_fieldName, array("login", "id"))) {
|
||||
return null;
|
||||
}
|
||||
$escapedValue = pg_escape_string($p_fieldValue);
|
||||
$sql = "SELECT * FROM ".$CC_CONFIG['subjTable']
|
||||
." WHERE $p_fieldName='$escapedValue'";
|
||||
$row = $CC_DBC->GetRow($sql);
|
||||
return $row;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get all subjects
|
||||
*
|
||||
* @param string $flds
|
||||
* @return array|PEAR_Error
|
||||
*/
|
||||
public static function GetSubjects($flds='id, login')
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
$sql = "SELECT $flds FROM ".$CC_CONFIG['subjTable'];
|
||||
return $CC_DBC->getAll($sql);
|
||||
} // fn getSubjects
|
||||
|
||||
|
||||
/**
|
||||
* Get subjects with count of direct members
|
||||
*
|
||||
* @return array|PEAR_Error
|
||||
*/
|
||||
public static function GetSubjectsWCnt()
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
$sql = "SELECT count(m.uid)as cnt, s.id, s.login, s.type"
|
||||
." FROM ".$CC_CONFIG['subjTable']." s"
|
||||
." LEFT JOIN ".$CC_CONFIG['smembTable']." m ON m.gid=s.id"
|
||||
." WHERE m.mid is null"
|
||||
." GROUP BY s.id, s.login, s.type"
|
||||
." ORDER BY s.id";
|
||||
return $CC_DBC->getAll($sql);
|
||||
} // fn getSubjectsWCnt
|
||||
|
||||
|
||||
/**
|
||||
* Return true if subject is a group
|
||||
*
|
||||
* @param int $gid
|
||||
* @return boolean|PEAR_Error
|
||||
*/
|
||||
public static function IsGroup($gid)
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
if (empty($gid)) {
|
||||
return FALSE;
|
||||
}
|
||||
$sql = "SELECT type FROM ".$CC_CONFIG['subjTable']
|
||||
." WHERE id='$gid'";
|
||||
$r = $CC_DBC->getOne($sql);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return ($r === 'G');
|
||||
} // fn isGroup
|
||||
|
||||
|
||||
/**
|
||||
* List direct members of group
|
||||
*
|
||||
* @param int $gid
|
||||
* @return array|PEAR_Error
|
||||
*/
|
||||
public static function ListGroup($gid)
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
$sql = "SELECT s.id, s.login, s.type"
|
||||
." FROM ".$CC_CONFIG['smembTable']." m, ".$CC_CONFIG['subjTable']." s"
|
||||
." WHERE m.uid=s.id AND m.mid is null AND m.gid='$gid'";
|
||||
return $CC_DBC->getAll($sql);
|
||||
} // fn listGroup
|
||||
|
||||
|
||||
/**
|
||||
* Return true if uid is [id]direct member of gid
|
||||
*
|
||||
|
|
@ -332,180 +119,5 @@ class Subjects {
|
|||
} // fn isMemberOf
|
||||
|
||||
|
||||
/* ==================================================== "private" methods */
|
||||
|
||||
/**
|
||||
* Create membership record
|
||||
*
|
||||
* @param int $uid
|
||||
* @param int $gid
|
||||
* @param int $level
|
||||
* @param int $mid
|
||||
* @return int|PEAR_Error
|
||||
*/
|
||||
private static function _addMemb($uid, $gid, $level=0, $mid='null')
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
if ($uid == $gid) {
|
||||
return PEAR::raiseError("Subjects::_addMemb: uid==gid ($uid)", ALIBERR_BADSMEMB);
|
||||
}
|
||||
$sql = "SELECT id, level, mid FROM ".$CC_CONFIG['smembTable']
|
||||
." WHERE uid='$uid' AND gid='$gid' ORDER BY level ASC";
|
||||
$a = $CC_DBC->getAll($sql);
|
||||
if (PEAR::isError($a)) {
|
||||
return $a;
|
||||
}
|
||||
if (count($a) > 0) {
|
||||
$a0 = $a[0];
|
||||
$id = $a0['id'];
|
||||
if ($level < intval($a0['level'])){
|
||||
$sql2 = "UPDATE ".$CC_CONFIG['smembTable']
|
||||
." SET level='$level', mid=$mid WHERE id='{$a0['id']}'";
|
||||
$r = $CC_DBC->query($sql2);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$id = $CC_DBC->nextId($CC_CONFIG['smembSequence']);
|
||||
if (PEAR::isError($id)) {
|
||||
return $id;
|
||||
}
|
||||
$sql3 = "INSERT INTO ".$CC_CONFIG['smembTable']." (id, uid, gid, level, mid)"
|
||||
." VALUES ($id, $uid, $gid, $level, $mid)";
|
||||
$r = $CC_DBC->query($sql3);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
}
|
||||
return $id;
|
||||
} // fn _addMemb
|
||||
|
||||
|
||||
/**
|
||||
* Remove membership record
|
||||
*
|
||||
* @param int $mid
|
||||
* @return null|PEAR_Error
|
||||
*/
|
||||
private static function _removeMemb($mid)
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
$sql = "DELETE FROM ".$CC_CONFIG['smembTable']
|
||||
." WHERE id='$mid'";
|
||||
return $CC_DBC->query($sql);
|
||||
} // fn _removeMemb
|
||||
|
||||
|
||||
/**
|
||||
* List [in]direct members of group
|
||||
*
|
||||
* @param int $gid
|
||||
* @param int $uid
|
||||
* @return array|PEAR_Error
|
||||
*/
|
||||
private static function _listMemb($gid, $uid=NULL)
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
$sql = "SELECT id, uid, level FROM ".$CC_CONFIG['smembTable']
|
||||
." WHERE gid='$gid'".(is_null($uid) ? '' : " AND uid='$uid'");
|
||||
return $CC_DBC->getAll($sql);
|
||||
} // fn _listMemb
|
||||
|
||||
|
||||
/**
|
||||
* List groups where uid is [in]direct member
|
||||
*
|
||||
* @param int $gid
|
||||
* @param int $uid
|
||||
* @return array|PEAR_Error
|
||||
*/
|
||||
private static function _listRMemb($uid, $gid=NULL)
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
$sql = "SELECT id, gid, level FROM ".$CC_CONFIG['smembTable']
|
||||
." WHERE uid='$uid'".(is_null($gid) ? '' : " AND gid='$gid'");
|
||||
return $CC_DBC->getAll($sql);
|
||||
} // fn listRMemb
|
||||
|
||||
|
||||
/**
|
||||
* Add uid and its [in]direct members to gid
|
||||
*
|
||||
* @param int $uid
|
||||
* @param int $gid
|
||||
* @param int $level
|
||||
* @param int $rmid
|
||||
* @return int|PEAR_Error
|
||||
*/
|
||||
private static function _plainAddSubjectToGroup($uid, $gid, $level=0, $rmid='null')
|
||||
{
|
||||
$mid = Subjects::_addMemb($uid, $gid, $level, $rmid);
|
||||
if (PEAR::isError($mid)) {
|
||||
return $mid;
|
||||
}
|
||||
$marr = Subjects::_listMemb($uid);
|
||||
if (PEAR::isError($marr)) {
|
||||
return $marr;
|
||||
}
|
||||
foreach ($marr as $k => $v) {
|
||||
$r = Subjects::_addMemb(
|
||||
$v['uid'], $gid, intval($v['level'])+$level+1, $mid
|
||||
);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
}
|
||||
return $mid;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Rebuild indirect membership records<br>
|
||||
* it's probably more complicated to do removing without rebuild ...
|
||||
*
|
||||
* @return true|PEAR_Error
|
||||
*/
|
||||
private static function _rebuildRels()
|
||||
{
|
||||
global $CC_CONFIG, $CC_DBC;
|
||||
$CC_DBC->query("BEGIN");
|
||||
$r = $CC_DBC->query("LOCK TABLE ".$CC_CONFIG['smembTable']);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
$sql = "DELETE FROM ".$CC_CONFIG['smembTable']
|
||||
." WHERE mid is not null";
|
||||
$r = $CC_DBC->query($sql);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
$arr = $CC_DBC->getAll("SELECT uid, gid FROM ".$CC_CONFIG['smembTable']);
|
||||
// WHERE mid is null
|
||||
if (PEAR::isError($arr)) {
|
||||
return $arr;
|
||||
}
|
||||
foreach ($arr as $it) {
|
||||
$marr = Subjects::_listRMemb($it['gid']);
|
||||
if (PEAR::isError($marr)) {
|
||||
return $marr;
|
||||
}
|
||||
foreach ($marr as $k => $v) {
|
||||
$r = Subjects::_plainAddSubjectToGroup(
|
||||
$it['uid'], $v['gid'], intval($v['level'])+1, $v['id']
|
||||
);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
}
|
||||
}
|
||||
$r = $CC_DBC->query("COMMIT");
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return TRUE;
|
||||
} // fn _rebuildRels
|
||||
|
||||
|
||||
} // class Subjects
|
||||
|
||||
|
|
|
|||
|
|
@ -1,385 +0,0 @@
|
|||
<?php
|
||||
define('VAL_ROOT', 110);
|
||||
define('VAL_NOREQE', 111);
|
||||
define('VAL_NOONEOF', 112);
|
||||
define('VAL_UNKNOWNE', 113);
|
||||
define('VAL_UNKNOWNA', 114);
|
||||
define('VAL_NOTDEF', 115);
|
||||
define('VAL_UNEXPONEOF', 116);
|
||||
define('VAL_FORMAT', 117);
|
||||
define('VAL_CONTENT', 118);
|
||||
define('VAL_NOREQA', 119);
|
||||
define('VAL_ATTRIB', 120);
|
||||
define('VAL_PREDXML', 121);
|
||||
|
||||
/**
|
||||
* Simple XML validator against structure stored in PHP hash-array hierarchy.
|
||||
*
|
||||
* Basic format files:
|
||||
* <ul>
|
||||
* <li>audioClipFormat.php</li>
|
||||
* <li>webstreamFormat.php</li>
|
||||
* <li>playlistFormat.php</li>
|
||||
* </ul>
|
||||
* It probably should be replaced by XML schema validation in the future.
|
||||
*
|
||||
* @package Airtime
|
||||
* @subpackage StorageServer
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
*/
|
||||
class Validator {
|
||||
/**
|
||||
* Format type of validated document
|
||||
* @var string
|
||||
*/
|
||||
private $format = NULL;
|
||||
|
||||
/**
|
||||
* Preloaded format tree structure
|
||||
* @var array
|
||||
*/
|
||||
private $formTree = NULL;
|
||||
|
||||
/**
|
||||
* Gunid of validated file for identification in mass input
|
||||
* @var string
|
||||
*/
|
||||
private $gunid = NULL;
|
||||
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* @param string $format
|
||||
* format type of validated document
|
||||
* @param string $gunid
|
||||
* gunid of validated file for identification in mass input
|
||||
*/
|
||||
public function __construct($format, $gunid)
|
||||
{
|
||||
$format = strtolower($format);
|
||||
$this->format = $format;
|
||||
$this->gunid = $gunid;
|
||||
$formats = array(
|
||||
'audioclip' => "audioClipFormat",
|
||||
'playlist' => "playlistFormat",
|
||||
'webstream' => "webstreamFormat",
|
||||
);
|
||||
if (!isset($formats[$format])) {
|
||||
return $this->_err(VAL_FORMAT);
|
||||
}
|
||||
$formatName = $formats[$format];
|
||||
$formatFile = dirname(__FILE__)."/$formatName.php";
|
||||
if (!file_exists($formatFile)) {
|
||||
return $this->_err(VAL_FORMAT);
|
||||
}
|
||||
require($formatFile);
|
||||
$this->formTree = $$formatName;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Validate document - only wrapper for validateNode method
|
||||
*
|
||||
* @param object $data
|
||||
* validated object tree
|
||||
* @return mixed
|
||||
* TRUE or PEAR::error
|
||||
*/
|
||||
function validate(&$data)
|
||||
{
|
||||
$r = $this->validateNode($data, $this->formTree['_root']);
|
||||
return $r;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Validate one metadata value (on insert/update)
|
||||
*
|
||||
* @param string $fname
|
||||
* parent element name
|
||||
* @param string $category
|
||||
* qualif.category name
|
||||
* @param string $predxml
|
||||
* 'A' | 'T' (attr or tag)
|
||||
* @param string $value
|
||||
* validated element value
|
||||
* @return TRUE|PEAR_Error
|
||||
*/
|
||||
function validateOneValue($fname, $category, $predxml, $value)
|
||||
{
|
||||
$formTree =& $this->formTree;
|
||||
switch ($predxml) {
|
||||
case 'T':
|
||||
if (!$this->isChildInFormat($fname, $category)) {
|
||||
return $this->_err(VAL_UNKNOWNE, "$category in $fname");
|
||||
}
|
||||
break;
|
||||
case 'A':
|
||||
if (!$this->isAttrInFormat($fname, $category)) {
|
||||
return $this->_err(VAL_UNKNOWNA, "$category in $fname");
|
||||
}
|
||||
break;
|
||||
case 'N':
|
||||
return TRUE;
|
||||
break;
|
||||
default:
|
||||
return $this->_err(VAL_PREDXML, $predxml);
|
||||
}
|
||||
if (isset($formTree[$category]['regexp'])) {
|
||||
// echo "XXX {$formTree[$fname]['regexp']} / ".$node->content."\n";
|
||||
if (!preg_match("|{$formTree[$category]['regexp']}|", $value)) {
|
||||
return $this->_err(VAL_CONTENT, "$category/$value");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Validation of one element node from object tree
|
||||
*
|
||||
* @param object $node
|
||||
* validated node
|
||||
* @param string $fname
|
||||
* actual name in format structure
|
||||
* @return mixed
|
||||
* TRUE or PEAR::error
|
||||
*/
|
||||
function validateNode(&$node, $fname)
|
||||
{
|
||||
$dname = (($node->ns? $node->ns.":" : '').$node->name);
|
||||
$formTree =& $this->formTree;
|
||||
if (DEBUG) {
|
||||
echo"\nVAL::validateNode: 1 $dname/$fname\n";
|
||||
}
|
||||
// check root node name:
|
||||
if ($dname != $fname) {
|
||||
return $this->_err(VAL_ROOT, $fname);
|
||||
}
|
||||
// check if this element is defined in format:
|
||||
if (!isset($formTree[$fname])) {
|
||||
return $this->_err(VAL_NOTDEF, $fname);
|
||||
}
|
||||
// check element content
|
||||
if (isset($formTree[$fname]['regexp'])) {
|
||||
// echo "XXX {$formTree[$fname]['regexp']} / ".$node->content."\n";
|
||||
if (!preg_match("|{$formTree[$fname]['regexp']}|", $node->content)) {
|
||||
return $this->_err(VAL_CONTENT, "$fname/{$node->content}");
|
||||
}
|
||||
}
|
||||
// validate attributes:
|
||||
$ra = $this->validateAttributes($node, $fname);
|
||||
if (PEAR::isError($ra)) {
|
||||
return $ra;
|
||||
}
|
||||
// validate children:
|
||||
$r = $this->validateChildren($node, $fname);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Validation of attributes
|
||||
*
|
||||
* @param object $node
|
||||
* validated node
|
||||
* @param string $fname
|
||||
* actual name in format structure
|
||||
* @return mixed
|
||||
* TRUE or PEAR::error
|
||||
*/
|
||||
function validateAttributes(&$node, $fname)
|
||||
{
|
||||
$formTree =& $this->formTree;
|
||||
$attrs = array();
|
||||
// check if all attrs are permitted here:
|
||||
foreach ($node->attrs as $i => $attr) {
|
||||
$aname = (($attr->ns? $attr->ns.":" : '').$attr->name);
|
||||
$attrs[$aname] =& $node->attrs[$i];
|
||||
if (!$this->isAttrInFormat($fname, $aname)) {
|
||||
return $this->_err(VAL_UNKNOWNA, $aname);
|
||||
}
|
||||
// check attribute format
|
||||
// echo "XXA $aname\n";
|
||||
if (isset($formTree[$aname]['regexp'])) {
|
||||
// echo "XAR {$formTree[$fname]['regexp']} / ".$node->content."\n";
|
||||
if (!preg_match("|{$formTree[$aname]['regexp']}|", $attr->val)) {
|
||||
return $this->_err(VAL_ATTRIB, "$aname [".var_export($attr->val,TRUE)."]");
|
||||
}
|
||||
}
|
||||
}
|
||||
// check if all required attrs are here:
|
||||
if (isset($formTree[$fname]['attrs'])) {
|
||||
$fattrs =& $formTree[$fname]['attrs'];
|
||||
if (isset($fattrs['required'])) {
|
||||
foreach ($fattrs['required'] as $i => $attr) {
|
||||
if (!isset($attrs[$attr])) {
|
||||
return $this->_err(VAL_NOREQA, $attr);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Validation children nodes
|
||||
*
|
||||
* @param object $node
|
||||
* validated node
|
||||
* @param string $fname
|
||||
* actual name in format structure
|
||||
* @return mixed
|
||||
* TRUE or PEAR::error
|
||||
*/
|
||||
function validateChildren(&$node, $fname)
|
||||
{
|
||||
$formTree =& $this->formTree;
|
||||
$childs = array();
|
||||
// check if all children are permitted here:
|
||||
foreach ($node->children as $i => $ch) {
|
||||
$chname = (($ch->ns? $ch->ns.":" : '').$ch->name);
|
||||
// echo "XXE $chname\n";
|
||||
if (!$this->isChildInFormat($fname, $chname)) {
|
||||
return $this->_err(VAL_UNKNOWNE, $chname);
|
||||
}
|
||||
// call children recursive:
|
||||
$r = $this->validateNode($node->children[$i], $chname);
|
||||
if (PEAR::isError($r)) {
|
||||
return $r;
|
||||
}
|
||||
$childs[$chname] = TRUE;
|
||||
}
|
||||
// check if all required children are here:
|
||||
if (isset($formTree[$fname]['childs'])) {
|
||||
$fchilds =& $formTree[$fname]['childs'];
|
||||
if (isset($fchilds['required'])) {
|
||||
foreach ($fchilds['required'] as $i => $ch) {
|
||||
if (!isset($childs[$ch])) return $this->_err(VAL_NOREQE, $ch);
|
||||
}
|
||||
}
|
||||
// required one from set
|
||||
if (isset($fchilds['oneof'])) {
|
||||
$one = FALSE;
|
||||
foreach ($fchilds['oneof'] as $i => $ch) {
|
||||
if (isset($childs[$ch])) {
|
||||
if ($one) {
|
||||
return $this->_err(VAL_UNEXPONEOF, "$ch in $fname");
|
||||
}
|
||||
$one = TRUE;
|
||||
}
|
||||
}
|
||||
if (!$one) {
|
||||
return $this->_err(VAL_NOONEOF);
|
||||
}
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Test if child is presented in format structure
|
||||
*
|
||||
* @param string $fname
|
||||
* node name in format structure
|
||||
* @param string $chname
|
||||
* child node name
|
||||
* @return boolean
|
||||
*/
|
||||
function isChildInFormat($fname, $chname)
|
||||
{
|
||||
$listo = $this->isInFormatAs($fname, $chname, 'childs', 'optional');
|
||||
$listr = $this->isInFormatAs($fname, $chname, 'childs', 'required');
|
||||
$list1 = $this->isInFormatAs($fname, $chname, 'childs', 'oneof');
|
||||
return ($listo!==FALSE || $listr!==FALSE || $list1!==FALSE);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Test if attribute is presented in format structure
|
||||
*
|
||||
* @param string $fname
|
||||
* node name in format structure
|
||||
* @param string $aname
|
||||
* attribute name
|
||||
* @return boolean
|
||||
*/
|
||||
function isAttrInFormat($fname, $aname)
|
||||
{
|
||||
$listr = $this->isInFormatAs($fname, $aname, 'attrs', 'required');
|
||||
$listi = $this->isInFormatAs($fname, $aname, 'attrs', 'implied');
|
||||
$listn = $this->isInFormatAs($fname, $aname, 'attrs', 'normal');
|
||||
return ($listr!==FALSE || $listi!==FALSE || $listn!==FALSE);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Check if node/attribute is presented in format structure
|
||||
*
|
||||
* @param string $fname
|
||||
* node name in format structure
|
||||
* @param string $chname
|
||||
* node/attribute name
|
||||
* @param string $nType
|
||||
* 'childs' | 'attrs'
|
||||
* @param string $reqType
|
||||
* <ul>
|
||||
* <li>for elements: 'required' | 'optional' | 'oneof'</li>
|
||||
* <li>for attributes: 'required' | 'implied' | 'normal'</li>
|
||||
* </ul>
|
||||
* @return mixed
|
||||
* boolean/int (index int format array returned if found)
|
||||
*/
|
||||
function isInFormatAs($fname, $chname, $nType='childs', $reqType='required')
|
||||
{
|
||||
$formTree =& $this->formTree;
|
||||
$listed = (
|
||||
isset($formTree[$fname][$nType][$reqType]) ?
|
||||
array_search($chname, $formTree[$fname][$nType][$reqType]) :
|
||||
FALSE
|
||||
);
|
||||
return $listed;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Error exception generator
|
||||
*
|
||||
* @param int $errno
|
||||
* erron code
|
||||
* @param string $par
|
||||
* optional string for more descriptive error messages
|
||||
* @return PEAR_Error
|
||||
*/
|
||||
function _err($errno, $par='')
|
||||
{
|
||||
$msg = array(
|
||||
VAL_ROOT => 'Wrong root element',
|
||||
VAL_NOREQE => 'Required element missing',
|
||||
VAL_NOONEOF => 'One-of element missing',
|
||||
VAL_UNKNOWNE => 'Unknown element',
|
||||
VAL_UNKNOWNA => 'Unknown attribute',
|
||||
VAL_NOTDEF => 'Not defined',
|
||||
VAL_UNEXPONEOF => 'Unexpected second object from one-of set',
|
||||
VAL_FORMAT => 'Unknown format',
|
||||
VAL_CONTENT => 'Invalid content',
|
||||
VAL_NOREQA => 'Required attribute missing',
|
||||
VAL_ATTRIB => 'Invalid attribute format',
|
||||
VAL_PREDXML => 'Invalid predicate type',
|
||||
);
|
||||
return PEAR::raiseError(
|
||||
"Validator: {$msg[$errno]} #$errno ($par, gunid={$this->gunid})",
|
||||
$errno
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
} // class Validator
|
||||
|
||||
|
||||
|
|
@ -1,326 +0,0 @@
|
|||
<?php
|
||||
$audioClipFormat = array(
|
||||
'_root'=>'audioClip',
|
||||
'audioClip'=>array(
|
||||
'childs'=>array(
|
||||
'required'=>array('metadata'),
|
||||
),
|
||||
),
|
||||
'metadata'=>array(
|
||||
'childs'=>array(
|
||||
'required'=>array(
|
||||
'dc:title', 'dcterms:extent'
|
||||
),
|
||||
'optional'=>array(
|
||||
'dc:identifier',
|
||||
'dc:creator', 'dc:source', 'ls:genre',
|
||||
'ls:year', 'dc:type', 'dc:description', 'dc:format',
|
||||
'ls:bpm', 'ls:rating', 'ls:encoded_by', 'ls:track_num',
|
||||
'ls:disc_num', 'ls:disc_num', 'dc:publisher', 'ls:composer',
|
||||
'ls:bitrate', 'ls:channels', 'ls:samplerate', 'ls:encoder',
|
||||
'ls:crc', 'ls:lyrics', 'ls:orchestra', 'ls:conductor',
|
||||
'ls:lyricist', 'ls:originallyricist', 'ls:radiostationname',
|
||||
'ls:audiofileinfourl', 'ls:artisturl', 'ls:audiosourceurl',
|
||||
'ls:radiostationurl', 'ls:buycdurl', 'ls:isrcnumber',
|
||||
'ls:catalognumber', 'ls:originalartist', 'dc:rights',
|
||||
'ls:license', 'dc:title', 'dcterms:temporal',
|
||||
'dcterms:spatial', 'dcterms:entity', 'dc:description',
|
||||
'dc:creator', 'dc:subject', 'dc:type', 'dc:format',
|
||||
'dc:contributor', 'dc:language', 'dc:rights',
|
||||
'dcterms:isPartOf', 'dc:date',
|
||||
'dc:publisher',
|
||||
// extra
|
||||
'dcterms:alternative', 'ls:filename', 'ls:mtime',
|
||||
// added lately by sebastian
|
||||
'ls:mood',
|
||||
),
|
||||
),
|
||||
'namespaces'=>array(
|
||||
'dc'=>"http://purl.org/dc/elements/1.1/",
|
||||
'dcterms'=>"http://purl.org/dc/terms/",
|
||||
'xbmf'=>"http://www.streamonthefly.org/xbmf",
|
||||
'xsi'=>"http://www.w3.org/2001/XMLSchema-instance",
|
||||
'xml'=>"http://www.w3.org/XML/1998/namespace",
|
||||
),
|
||||
),
|
||||
'dc:identifier'=>array(
|
||||
'type'=>'Text',
|
||||
'auto'=>TRUE,
|
||||
),
|
||||
'dc:title'=>array(
|
||||
'type'=>'Text',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:alternative'=>array(
|
||||
'type'=>'Text',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:extent'=>array(
|
||||
'type'=>'Time',
|
||||
// 'regexp'=>'^\d{2}:\d{2}:\d{2}.\d{6}$',
|
||||
'regexp'=>'^((\d{1,2}:)?\d{1,2}:)?\d{1,20}(.\d{1,6})?$',
|
||||
),
|
||||
'dc:creator'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:source'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:genre'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:year'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
),
|
||||
'dc:type'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:description'=>array(
|
||||
'type'=>'Longtext',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:format'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:bpm'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:rating'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:encoded_by'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:track_num'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:disc_num'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:disc_num'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:publisher'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:composer'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:bitrate'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:channels'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:samplerate'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:encoder'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:crc'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:lyrics'=>array(
|
||||
'type'=>'Longtext',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:orchestra'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:conductor'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:lyricist'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:originallyricist'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:radiostationname'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:audiofileinfourl'=>array(
|
||||
'type'=>'URL',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:artisturl'=>array(
|
||||
'type'=>'URL',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:audiosourceurl'=>array(
|
||||
'type'=>'URL',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:radiostationurl'=>array(
|
||||
'type'=>'URL',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:buycdurl'=>array(
|
||||
'type'=>'URL',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:isrcnumber'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:catalognumber'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:originalartist'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:rights'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:license'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:title'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:temporal'=>array(
|
||||
'type'=>'Time/Date',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:spatial'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:entity'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:description'=>array(
|
||||
'type'=>'Longtext',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:creator'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:subject'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:type'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:format'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:contributor'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:language'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:rights'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:isPartOf'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:date'=>array(
|
||||
'type'=>'Date',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:publisher'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
|
||||
'ls:filename'=>array(
|
||||
'type'=>'Text',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:mtime'=>array(
|
||||
'type'=>'Int',
|
||||
// 'regexp'=>'^\d{4}(-\d{2}(-\d{2}(T\d{2}:\d{2}(:\d{2}\.\d+)?(Z)|([\+\-]?\d{2}:\d{2}))?)?)?$',
|
||||
),
|
||||
);
|
||||
|
|
@ -1,112 +0,0 @@
|
|||
<?php
|
||||
/**
|
||||
* @package Airtime
|
||||
* @subpackage StorageServer
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
*/
|
||||
|
||||
|
||||
$playlistFormat = array(
|
||||
'_root'=>'playlist',
|
||||
'playlist'=>array(
|
||||
'childs'=>array(
|
||||
// 'repeatable'=>array('playlistElement'),
|
||||
'optional'=>array('metadata', 'playlistElement'),
|
||||
),
|
||||
'attrs'=>array(
|
||||
'required'=>array('id'),
|
||||
'implied'=>array('title', 'playlength'),
|
||||
),
|
||||
),
|
||||
'playlistElement'=>array(
|
||||
'childs'=>array(
|
||||
'oneof'=>array('audioClip', 'playlist'),
|
||||
'optional'=>array('fadeInfo'),
|
||||
),
|
||||
'attrs'=>array(
|
||||
'required'=>array('id', 'relativeOffset', 'clipStart', 'clipEnd', 'clipLength'),
|
||||
),
|
||||
),
|
||||
'audioClip'=>array(
|
||||
'childs'=>array(
|
||||
'optional'=>array('metadata'),
|
||||
),
|
||||
'attrs'=>array(
|
||||
'implied'=>array('id', 'title', 'playlength', 'uri'),
|
||||
),
|
||||
),
|
||||
'fadeInfo'=>array(
|
||||
'attrs'=>array(
|
||||
'required'=>array('id', 'fadeIn', 'fadeOut'),
|
||||
),
|
||||
),
|
||||
'metadata'=>array(
|
||||
'childs'=>array(
|
||||
'optional'=>array(
|
||||
'dc:title', 'dcterms:extent', 'dc:creator', 'dc:description',
|
||||
'dcterms:alternative', 'ls:filename', 'ls:mtime',
|
||||
),
|
||||
),
|
||||
'namespaces'=>array(
|
||||
'dc'=>"http://purl.org/dc/elements/1.1/",
|
||||
'dcterms'=>"http://purl.org/dc/terms/",
|
||||
'xbmf'=>"http://www.streamonthefly.org/xbmf",
|
||||
'xsi'=>"http://www.w3.org/2001/XMLSchema-instance",
|
||||
'xml'=>"http://www.w3.org/XML/1998/namespace",
|
||||
),
|
||||
),
|
||||
'dc:title'=>array(
|
||||
'type'=>'Text',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:alternative'=>array(
|
||||
'type'=>'Text',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:extent'=>array(
|
||||
'type'=>'Time',
|
||||
'regexp'=>'^\d{2}:\d{2}:\d{2}.\d{6}$',
|
||||
),
|
||||
'dc:creator'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:description'=>array(
|
||||
'type'=>'Longtext',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'playlength'=>array(
|
||||
'type'=>'Time',
|
||||
'regexp'=>'^((\d{2}:)?\d{2}:)?\d{1,2}(.\d{6})?$',
|
||||
),
|
||||
'id'=>array(
|
||||
'type'=>'Attribute',
|
||||
'regexp'=>'^[0-9a-f]{16}$',
|
||||
),
|
||||
'fadeIn'=>array(
|
||||
'type'=>'Attribute',
|
||||
'regexp'=>'^((\d{2}:)?\d{2}:)?\d{1,2}(.\d{6})?$',
|
||||
),
|
||||
'fadeOut'=>array(
|
||||
'type'=>'Attribute',
|
||||
'regexp'=>'^((\d{2}:)?\d{2}:)?\d{1,2}(.\d{6})?$',
|
||||
),
|
||||
'ls:filename'=>array(
|
||||
'type'=>'Text',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:mtime'=>array(
|
||||
'type'=>'Int',
|
||||
// 'regexp'=>'^\d{4}(-\d{2}(-\d{2}(T\d{2}:\d{2}(:\d{2}\.\d+)?(Z)|([\+\-]?\d{2}:\d{2}))?)?)?$',
|
||||
),
|
||||
/*
|
||||
''=>array(
|
||||
'childs'=>array(''),
|
||||
'attrs'=>array('implied'=>array()),
|
||||
),
|
||||
*/
|
||||
);
|
||||
|
||||
|
|
@ -118,64 +118,6 @@ class PlaylistTests extends PHPUnit_TestCase {
|
|||
}
|
||||
}
|
||||
|
||||
function testAddAudioClip() {
|
||||
|
||||
$pl = new Playlist();
|
||||
$pl_id = $pl->create("Playlist Unit Test ". date("g:i a"));
|
||||
$res = $this->greenbox->addAudioClipToPlaylist($pl_id, $this->storedFile->getId());
|
||||
if($res !== TRUE) {
|
||||
$this->fail("problems adding audioclip to playlist.");
|
||||
return;
|
||||
}
|
||||
|
||||
$res = $this->greenbox->addAudioClipToPlaylist($pl_id, $this->storedFile2->getId());
|
||||
if($res !== TRUE) {
|
||||
$this->fail("problems adding audioclip 2 to playlist.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
function testMoveAudioClip() {
|
||||
$pl = new Playlist();
|
||||
$pl_id = $pl->create("Playlist Unit Test: Move ". date("g:i a"));
|
||||
|
||||
$this->greenbox->addAudioClipToPlaylist($pl_id, $this->storedFile->getId());
|
||||
$this->greenbox->addAudioClipToPlaylist($pl_id, $this->storedFile2->getId());
|
||||
|
||||
$res = $this->greenbox->moveAudioClipInPlaylist($pl_id, 0, 1);
|
||||
|
||||
if($res !== TRUE) {
|
||||
$this->fail("problems moving audioclip in playlist.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
function testDeleteAudioClip() {
|
||||
$pl = new Playlist();
|
||||
$pl_id = $pl->create("Playlist UnitTest: Delete ".date("g:i a"));
|
||||
|
||||
$this->greenbox->addAudioClipToPlaylist($pl_id, $this->storedFile->getId());
|
||||
$res = $this->greenbox->delAudioClipFromPlaylist($pl_id, 0);
|
||||
|
||||
if($res !== TRUE) {
|
||||
$this->fail("problems deleting audioclip from playlist.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
function testFadeInfo() {
|
||||
$pl = new Playlist();
|
||||
$pl_id = $pl->create("Playlist Unit Test: Fade Info " . date("g:i a"));
|
||||
|
||||
$this->greenbox->addAudioClipToPlaylist($pl_id, $this->storedFile2->getId());
|
||||
|
||||
$res = $this->greenbox->changeFadeInfo($pl_id, 0, '00:00:01.14', null);
|
||||
|
||||
if(!is_array($res) && count($res) !== 2) {
|
||||
$this->fail("problems setting fade in playlist.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,340 +0,0 @@
|
|||
<?php
|
||||
/**
|
||||
* @copyright 2010 Sourcefabric O.P.S.
|
||||
* @license http://www.gnu.org/licenses/gpl.txt
|
||||
*/
|
||||
|
||||
$webstreamFormat = array(
|
||||
'_root'=>'audioClip',
|
||||
'audioClip'=>array(
|
||||
'childs'=>array(
|
||||
'required'=>array('metadata'),
|
||||
),
|
||||
),
|
||||
'metadata'=>array(
|
||||
'childs'=>array(
|
||||
'required'=>array(
|
||||
'dc:title', 'dcterms:extent', 'ls:url'
|
||||
),
|
||||
'optional'=>array(
|
||||
'dc:identifier',
|
||||
'dc:creator', 'dc:source', 'ls:genre',
|
||||
'ls:year', 'dc:type', 'dc:description', 'dc:format',
|
||||
'ls:bpm', 'ls:rating', 'ls:encoded_by', 'ls:track_num',
|
||||
'ls:disc_num', 'ls:disc_num', 'dc:publisher', 'ls:composer',
|
||||
'ls:bitrate', 'ls:channels', 'ls:samplerate', 'ls:encoder',
|
||||
'ls:crc', 'ls:lyrics', 'ls:orchestra', 'ls:conductor',
|
||||
'ls:lyricist', 'ls:originallyricist', 'ls:radiostationname',
|
||||
'ls:audiofileinfourl', 'ls:artisturl', 'ls:audiosourceurl',
|
||||
'ls:radiostationurl', 'ls:buycdurl', 'ls:isrcnumber',
|
||||
'ls:catalognumber', 'ls:originalartist', 'dc:rights',
|
||||
'ls:license', 'dc:title', 'dcterms:temporal',
|
||||
'dcterms:spatial', 'dcterms:entity', 'dc:description',
|
||||
'dc:creator', 'dc:subject', 'dc:type', 'dc:format',
|
||||
'dc:contributor', 'dc:language', 'dc:rights',
|
||||
'dcterms:isPartOf', 'dc:date',
|
||||
'dc:publisher',
|
||||
// extra
|
||||
'dcterms:alternative', 'ls:filename', 'ls:mtime',
|
||||
// added lately by sebastian
|
||||
'ls:mood',
|
||||
),
|
||||
),
|
||||
'namespaces'=>array(
|
||||
'dc'=>"http://purl.org/dc/elements/1.1/",
|
||||
'dcterms'=>"http://purl.org/dc/terms/",
|
||||
'xbmf'=>"http://www.streamonthefly.org/xbmf",
|
||||
'xsi'=>"http://www.w3.org/2001/XMLSchema-instance",
|
||||
'xml'=>"http://www.w3.org/XML/1998/namespace",
|
||||
),
|
||||
),
|
||||
'ls:url'=>array(
|
||||
'type'=>'URL',
|
||||
),
|
||||
'dc:identifier'=>array(
|
||||
'type'=>'Text',
|
||||
'auto'=>TRUE,
|
||||
),
|
||||
'dc:title'=>array(
|
||||
'type'=>'Text',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:alternative'=>array(
|
||||
'type'=>'Text',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:extent'=>array(
|
||||
'type'=>'Time',
|
||||
'regexp'=>'^\d{2}:\d{2}:\d{2}.\d{6}$',
|
||||
),
|
||||
'dc:creator'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:source'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:genre'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:year'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
),
|
||||
'dc:type'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:description'=>array(
|
||||
'type'=>'Longtext',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:format'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:bpm'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:rating'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:encoded_by'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:track_num'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:disc_num'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:disc_num'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:publisher'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:composer'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:bitrate'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:channels'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:samplerate'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:encoder'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:crc'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:lyrics'=>array(
|
||||
'type'=>'Longtext',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:orchestra'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:conductor'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:lyricist'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:originallyricist'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:radiostationname'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:audiofileinfourl'=>array(
|
||||
'type'=>'URL',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:artisturl'=>array(
|
||||
'type'=>'URL',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:audiosourceurl'=>array(
|
||||
'type'=>'URL',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:radiostationurl'=>array(
|
||||
'type'=>'URL',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:buycdurl'=>array(
|
||||
'type'=>'URL',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:isrcnumber'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:catalognumber'=>array(
|
||||
'type'=>'Number',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:originalartist'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:rights'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:license'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Music',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:title'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:temporal'=>array(
|
||||
'type'=>'Time/Date',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:spatial'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:entity'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:description'=>array(
|
||||
'type'=>'Longtext',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:creator'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:subject'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:type'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:format'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:contributor'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:language'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:rights'=>array(
|
||||
'type'=>'Menu',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dcterms:isPartOf'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:date'=>array(
|
||||
'type'=>'Date',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'dc:publisher'=>array(
|
||||
'type'=>'Text',
|
||||
'area'=>'Talk',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:filename'=>array(
|
||||
'type'=>'Text',
|
||||
'attrs'=>array('implied'=>array('xml:lang')),
|
||||
),
|
||||
'ls:mtime'=>array(
|
||||
'type'=>'Int',
|
||||
// 'regexp'=>'^\d{4}(-\d{2}(-\d{2}(T\d{2}:\d{2}(:\d{2}\.\d+)?(Z)|([\+\-]?\d{2}:\d{2}))?)?)?$',
|
||||
),
|
||||
/*
|
||||
''=>array(
|
||||
'type'=>'',
|
||||
'area'=>'',
|
||||
'attrs'=>array(),
|
||||
),
|
||||
*/
|
||||
);
|
||||
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,3 +0,0 @@
|
|||
<?php
|
||||
header ("location: xrLocStor.php");
|
||||
exit;
|
||||
|
|
@ -1,99 +0,0 @@
|
|||
<?php
|
||||
/**
|
||||
* Store PUT data as temporary file.
|
||||
*
|
||||
* put.php is remote callable script through HTTP PUT method.
|
||||
* Requires token returned by appropriate storageServer XMLRPC call.
|
||||
* Appropriate closing XMLRPC call should follow.
|
||||
*
|
||||
* This script accepts following HTTP GET parameter:
|
||||
* <ul>
|
||||
* <li>token : string, put token returned by appropriate
|
||||
* XMLRPC call</li>
|
||||
* </ul>
|
||||
*
|
||||
* On success, returns HTTP return code 200.
|
||||
*
|
||||
* On errors, returns HTTP return code >200
|
||||
* The possible error codes are:
|
||||
* <ul>
|
||||
* <li> 400 - Incorrect parameters passed to method</li>
|
||||
* <li> 403 - Access denied</li>
|
||||
* <li> 500 - Application error</li>
|
||||
* </ul>
|
||||
*
|
||||
* @see XR_LocStor
|
||||
* @package Airtime
|
||||
* @subpackage storageServer
|
||||
*/
|
||||
|
||||
define('USE_FLOCK', TRUE);
|
||||
|
||||
require_once(dirname(__FILE__).'/../../conf.php');
|
||||
require_once('DB.php');
|
||||
require_once(dirname(__FILE__).'/../LocStor.php');
|
||||
|
||||
PEAR::setErrorHandling(PEAR_ERROR_RETURN);
|
||||
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
|
||||
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
|
||||
$gb = new LocStor();
|
||||
|
||||
function http_error($code, $err)
|
||||
{
|
||||
header("HTTP/1.1 $code");
|
||||
header("Content-type: text/plain; charset=UTF-8");
|
||||
echo "$err\r\n";
|
||||
flush();
|
||||
exit;
|
||||
}
|
||||
|
||||
if (preg_match("|^[0-9a-fA-F]{16}$|", $_REQUEST['token'])) {
|
||||
$token = $_REQUEST['token'];
|
||||
} else {
|
||||
http_error(400, "Error on token parameter. ({$_REQUEST['token']})");
|
||||
}
|
||||
|
||||
$tc = BasicStor::bsCheckToken($token, 'put');
|
||||
if (PEAR::isError($tc)) {
|
||||
http_error(500, $ex->getMessage());
|
||||
}
|
||||
if (!$tc) {
|
||||
http_error(403, "put.php: Token not valid ($token).");
|
||||
}
|
||||
|
||||
header("Content-type: text/plain");
|
||||
|
||||
$destfile = $CC_CONFIG['accessDir']."/{$token}";
|
||||
|
||||
/* PUT data comes in on the input stream */
|
||||
$putdata = @fopen("php://input", "r") or
|
||||
http_error(500, "put.php: Can't read input");
|
||||
|
||||
/* Open a file for writing */
|
||||
$fp = @fopen($destfile, "ab") or
|
||||
http_error(500, "put.php: Can't write to destination file (token=$token)");
|
||||
|
||||
if ( USE_FLOCK ) {
|
||||
// lock the file
|
||||
$lockres = flock($fp,LOCK_EX+LOCK_NB);
|
||||
if ($lockres !== TRUE) {
|
||||
http_error(409, "put.php: file locked (token=$token)");
|
||||
}
|
||||
}
|
||||
|
||||
/* Read the data 1 KB at a time and write to the file */
|
||||
while ($data = fread($putdata, 1024)){
|
||||
fwrite($fp, $data);
|
||||
}
|
||||
|
||||
if ( USE_FLOCK ) {
|
||||
// unlock the file
|
||||
flock($fp,LOCK_UN);
|
||||
}
|
||||
|
||||
/* Close the streams */
|
||||
fclose($fp);
|
||||
fclose($putdata);
|
||||
|
||||
header("HTTP/1.1 200");
|
||||
|
||||
|
|
@ -1,510 +0,0 @@
|
|||
<?php
|
||||
/* ================================================================= includes */
|
||||
include_once(dirname(__FILE__)."/../conf.php");
|
||||
require_once('DB.php');
|
||||
include_once("XML/RPC.php");
|
||||
|
||||
/* ================================================== method definition array */
|
||||
/**
|
||||
* Array with methods description
|
||||
*
|
||||
* Each element has method name as key and contains four subfields:
|
||||
* <ul>
|
||||
* <li>m</li> full method name (include optional prefix)
|
||||
* <li>p</li> array of input parameter names
|
||||
* <li>t</li> array of input parameter types
|
||||
* <li>r</li> array of result element names (not used there at present)
|
||||
* <li>e</li> array of error codes/messages (not used there at present)
|
||||
* </ul>
|
||||
*/
|
||||
$mdefs = array(
|
||||
"listMethods" => array('m'=>"system.listMethods", 'p'=>NULL, 't'=>NULL),
|
||||
"AddAudioClipToPlaylistMethod" => array(
|
||||
'm'=>'addAudioClipToPlaylist',
|
||||
'p'=>array('sessionId'/*string*/, 'playlistId'/*string*/, 'audioClipId'/*string*/, 'relativeOffset'/*int*/, 'clipStart'/*int*/, 'clipEnd'/*int*/, 'clipLength'/*int*/),
|
||||
't'=>array('string', 'string', 'string', 'int', 'int', 'int', 'int'),
|
||||
'r'=>array('playlistElementId'/*string*/),
|
||||
'e'=>array(
|
||||
'301'=>'invalid argument format',
|
||||
'302'=>'missing playlist ID argument',
|
||||
'303'=>'missing audio clip ID argument',
|
||||
'304'=>'missing relative offset argument',
|
||||
'305'=>'playlist not found',
|
||||
'306'=>'playlist has not been opened for editing',
|
||||
'307'=>'audio clip does not exist',
|
||||
'308'=>'two audio clips at the same relative offset',
|
||||
'320'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"CreatePlaylistMethod" => array(
|
||||
'm'=>'createPlaylist',
|
||||
'p'=>array('sessionId'/*string*/),
|
||||
't'=>array('string'),
|
||||
'r'=>array('playlist'/*string*/),
|
||||
'e'=>array(
|
||||
'201'=>'invalid argument format',
|
||||
'202'=>'could not create playlist',
|
||||
'220'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"DeletePlaylistMethod" => array(
|
||||
'm'=>'deletePlaylist',
|
||||
'p'=>array('sessionId'/*string*/, 'playlistId'/*string*/),
|
||||
't'=>array('string', 'string'),
|
||||
'r'=>array(),
|
||||
'e'=>array(
|
||||
'901'=>'invalid argument format',
|
||||
'902'=>'missing playlist ID argument',
|
||||
'903'=>'playlist not found',
|
||||
'904'=>'playlist is locked',
|
||||
'905'=>'playlist could not be deleted',
|
||||
'920'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"DisplayAudioClipMethod" => array(
|
||||
'm'=>'displayAudioClip',
|
||||
'p'=>array('sessionId'/*string*/, 'audioClipId'/*string*/),
|
||||
't'=>array('string', 'string'),
|
||||
'r'=>array('audioClip'/*string*/),
|
||||
'e'=>array(
|
||||
'601'=>'invalid argument format',
|
||||
'602'=>'argument is not an audio clip ID',
|
||||
'603'=>'audio clip not found',
|
||||
'620'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"DisplayAudioClipsMethod" => array(
|
||||
'm'=>'displayAudioClips',
|
||||
'p'=>array('sessionId'/*string*/),
|
||||
't'=>array('string'),
|
||||
'r'=>array(array('audioClip'/*string*/)),
|
||||
'e'=>array(
|
||||
'1801'=>'invalid argument format',
|
||||
'1802'=>'XML-RPC error',
|
||||
'1820'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"DisplayPlaylistMethod" => array(
|
||||
'm'=>'displayPlaylist',
|
||||
'p'=>array('sessionId'/*string*/, 'playlistId'/*string*/),
|
||||
't'=>array('string', 'string'),
|
||||
'r'=>array('playlist'/*string*/),
|
||||
'e'=>array(
|
||||
'1001'=>'invalid argument format',
|
||||
'1002'=>'argument is not a playlist ID',
|
||||
'1003'=>'playlist not found',
|
||||
'1020'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"DisplayPlaylistsMethod" => array(
|
||||
'm'=>'displayPlaylists',
|
||||
'p'=>array('sessionId'/*string*/),
|
||||
't'=>array('string'),
|
||||
'r'=>array(array('playlist'/*string*/)),
|
||||
'e'=>array(
|
||||
'1701'=>'invalid argument format',
|
||||
'1702'=>'XML-RPC error',
|
||||
'1720'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"DisplayScheduleMethod" => array(
|
||||
'm'=>'displaySchedule',
|
||||
'p'=>array('sessionId'/*string*/, 'from'/*datetime*/, 'to'/*datetime*/),
|
||||
't'=>array('string', 'dateTime.iso8601', 'dateTime.iso8601'),
|
||||
'r'=>array(array('id'/*int*/, 'playlistId'/*string*/, 'start'/*datetime*/, 'end'/*datetime*/)),
|
||||
'e'=>array(
|
||||
'1101'=>'invalid argument format',
|
||||
'1102'=>"missing or invalid 'from' argument",
|
||||
'1103'=>"missing or invalid 'to' argument",
|
||||
'1120'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"GeneratePlayReportMethod" => array(
|
||||
'm'=>'generatePlayReport',
|
||||
'p'=>array('sessionId'/*string*/, 'from'/*datetime*/, 'to'/*datetime*/),
|
||||
't'=>array('string', 'dateTime.iso8601', 'dateTime.iso8601'),
|
||||
'r'=>array(array('audioClipId'/*string*/, 'timestamp'/*datetime*/)),
|
||||
'e'=>array(
|
||||
'1501'=>'invalid argument format',
|
||||
'1502'=>"missing or invalid 'from' argument",
|
||||
'1503'=>"missing or invalid 'to' argument",
|
||||
'1520'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"GetSchedulerTimeMethod" => array(
|
||||
'm'=>'getSchedulerTime',
|
||||
'p'=>array(),
|
||||
't'=>array(),
|
||||
'r'=>array('schedulerTime'/*datetime*/),
|
||||
'e'=>array(
|
||||
)
|
||||
),
|
||||
"GetVersionMethod" => array(
|
||||
'm'=>'getVersion',
|
||||
'p'=>array(),
|
||||
't'=>array(),
|
||||
'r'=>array('version'/*string*/),
|
||||
'e'=>array()
|
||||
),
|
||||
"LoginMethod" => array(
|
||||
'm'=>'login',
|
||||
'p'=>array('login'/*string*/, 'password'/*string*/),
|
||||
't'=>array('string', 'string'),
|
||||
'r'=>array('sessionId'/*string*/),
|
||||
'e'=>array(
|
||||
'2001'=>'invalid argument format',
|
||||
'2002'=>'missing login argument',
|
||||
'2003'=>'missing password argument',
|
||||
'2004'=>'the authentication server reported an error',
|
||||
)
|
||||
),
|
||||
"LogoutMethod" => array(
|
||||
'm'=>'logout',
|
||||
'p'=>array('sessionId'/*string*/),
|
||||
't'=>array('string'),
|
||||
'r'=>array(),
|
||||
'e'=>array(
|
||||
'2101'=>'invalid argument format',
|
||||
'2120'=>'missing session ID argument',
|
||||
'2104'=>'the authentication server reported an error',
|
||||
)
|
||||
),
|
||||
"OpenPlaylistForEditingMethod" => array(
|
||||
'm'=>'openPlaylistForEditing',
|
||||
'p'=>array('sessionId'/*string*/, 'playlistId'/*string*/),
|
||||
't'=>array('string', 'string'),
|
||||
'r'=>array('playlist'/*string*/),
|
||||
'e'=>array(
|
||||
'101'=>'invalid argument format',
|
||||
'102'=>'argument is not a playlist ID',
|
||||
'104'=>'could not open playlist for editing',
|
||||
'120'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"RemoveAudioClipFromPlaylistMethod" => array(
|
||||
'm'=>'removeAudioClipFromPlaylist',
|
||||
'p'=>array('sessionId'/*string*/, 'playlistId'/*string*/, 'playlistElementId'/*string*/),
|
||||
't'=>array('string', 'string', 'string'),
|
||||
'r'=>array(),
|
||||
'e'=>array(
|
||||
'401'=>'invalid argument format',
|
||||
'402'=>'missing playlist ID argument',
|
||||
'403'=>'missing relative offset argument',
|
||||
'404'=>'playlist does not exist',
|
||||
'405'=>'playlist has not been opened for editing',
|
||||
'406'=>'no audio clip at the specified relative offset',
|
||||
'420'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"RemoveFromScheduleMethod" => array(
|
||||
'm'=>'removeFromSchedule',
|
||||
'p'=>array('sessionId'/*string*/, 'scheduleEntryId'/*string*/),
|
||||
't'=>array('string', 'string'),
|
||||
'r'=>array(),
|
||||
'e'=>array(
|
||||
'1201'=>'invalid argument format',
|
||||
'1202'=>'missing schedule entry ID argument',
|
||||
'1203'=>'schedule entry not found',
|
||||
'1220'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"RescheduleMethod" => array(
|
||||
'm'=>'reschedule',
|
||||
'p'=>array('sessionId'/*string*/, 'scheduleEntryId'/*string*/, 'playtime'/*datetime*/),
|
||||
't'=>array('string', 'string', 'dateTime.iso8601'),
|
||||
'r'=>array(),
|
||||
'e'=>array(
|
||||
'1301'=>'invalid argument format',
|
||||
'1302'=>'missing schedule entry ID argument',
|
||||
'1303'=>'missing playtime argument',
|
||||
'1304'=>'schedule entry not found',
|
||||
'1305'=>'could not reschedule entry',
|
||||
'1320'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
// "ResetStorageMethod" => array(
|
||||
// 'm'=>'resetStorage',
|
||||
// 'p'=>array(),
|
||||
// 't'=>array(),
|
||||
// 'r'=>array(),
|
||||
// 'e'=>array('3001'=>'storage client reported an error'),
|
||||
// ),
|
||||
"RevertEditedPlaylistMethod" => array(
|
||||
'm'=>'revertEditedPlaylist',
|
||||
'p'=>array('sessionId'/*string*/, 'playlistId'/*string*/),
|
||||
't'=>array('string', 'string'),
|
||||
'r'=>array(),
|
||||
'e'=>array(
|
||||
'801'=>'invalid argument format',
|
||||
'802'=>'argument is not a playlist ID',
|
||||
'803'=>'playlist not found',
|
||||
'804'=>'could not revert playlist',
|
||||
'820'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"SavePlaylistMethod" => array(
|
||||
'm'=>'savePlaylist',
|
||||
'p'=>array('sessionId'/*string*/, 'playlistId'/*string*/),
|
||||
't'=>array('string', 'string'),
|
||||
'r'=>array(),
|
||||
'e'=>array(
|
||||
'701'=>'invalid argument format',
|
||||
'702'=>'argument is not a playlist ID',
|
||||
'703'=>'playlist not found',
|
||||
'705'=>'could not save playlist',
|
||||
'720'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"UpdateFadeInFadeOutMethod" => array(
|
||||
'm'=>'updateFadeInFadeOut',
|
||||
'p'=>array('sessionId'/*string*/, 'playlistId'/*string*/, 'playlistElementId'/*string*/, 'fadeIn'/*int*/, 'fadeOut'/*int*/),
|
||||
't'=>array('string', 'string', 'string', 'int', 'int'),
|
||||
'r'=>array(),
|
||||
'e'=>array(
|
||||
'1601'=>'invalid argument format',
|
||||
'1602'=>'missing playlist ID argument',
|
||||
'1603'=>'missing playlist element ID argument',
|
||||
'1604'=>'missing fade in argument',
|
||||
'1605'=>'missing fade out argument',
|
||||
'1606'=>'playlist does not exist',
|
||||
'1607'=>'playlist has not been opened for editing',
|
||||
'1608'=>'error executing setFadeInfo() method',
|
||||
'1620'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"UploadPlaylistMethod" => array(
|
||||
'm'=>'uploadPlaylist',
|
||||
'p'=>array('sessionId'/*string*/, 'playlistId'/*string*/, 'playtime'/*datetime*/),
|
||||
't'=>array('string', 'string', 'dateTime.iso8601'),
|
||||
'r'=>array('scheduleEntryId'/*string*/),
|
||||
'e'=>array(
|
||||
'1401'=>'invalid argument format',
|
||||
'1402'=>'missing playlist ID argument',
|
||||
'1403'=>'missing playtime argument',
|
||||
'1404'=>'playlist not found',
|
||||
'1405'=>'timeframe not available',
|
||||
'1406'=>'could not schedule playlist',
|
||||
'1420'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"ValidatePlaylistMethod" => array(
|
||||
'm'=>'validatePlaylist',
|
||||
'p'=>array('sessionId'/*string*/, 'playlistId'/*string*/),
|
||||
't'=>array('string', 'string'),
|
||||
'r'=>array('valid'/*bool*/),
|
||||
'e'=>array(
|
||||
'501'=>'invalid argument format',
|
||||
'502'=>'missing playlist ID argument',
|
||||
'503'=>'playlist does not exist',
|
||||
'504'=>'playlist has not been opened for editing',
|
||||
'520'=>'missing session ID argument',
|
||||
)
|
||||
),
|
||||
"LoginGB" => array(
|
||||
'm'=>'locstor.login',
|
||||
'p'=>array('login'/*string*/, 'pass'/*string*/),
|
||||
't'=>array('string', 'string'),
|
||||
'r'=>array('sessid'/*string*/),
|
||||
'e'=>array(
|
||||
'2001'=>'invalid argument format',
|
||||
'2002'=>'missing login argument',
|
||||
'2003'=>'missing password argument',
|
||||
'2004'=>'the authentication server reported an error',
|
||||
)
|
||||
),
|
||||
"LogoutGB" => array(
|
||||
'm'=>'locstor.logout',
|
||||
'p'=>array('sessid'/*string*/),
|
||||
't'=>array('string'),
|
||||
'r'=>array('status'/*boolean*/),
|
||||
'e'=>array(
|
||||
'2001'=>'invalid argument format',
|
||||
'2002'=>'missing login argument',
|
||||
'2003'=>'missing password argument',
|
||||
'2004'=>'the authentication server reported an error',
|
||||
)
|
||||
),
|
||||
);
|
||||
|
||||
/* ======================================================== class definitions */
|
||||
|
||||
class SchedulerPhpClient {
|
||||
/**
|
||||
* Array with methods description
|
||||
* @var array
|
||||
*/
|
||||
private $mdefs = array();
|
||||
|
||||
/**
|
||||
* XMLRPC client object reference
|
||||
*/
|
||||
private $client = NULL;
|
||||
|
||||
/**
|
||||
* Verbosity flag
|
||||
*/
|
||||
private $verbose = FALSE;
|
||||
|
||||
/**
|
||||
* XMLRPC debug flag
|
||||
*/
|
||||
private $debug = 0;
|
||||
|
||||
/**
|
||||
* Constructor - please DON'T CALL IT, use factory method instead
|
||||
*
|
||||
* @param DB $dbc
|
||||
* @param array $mdefs
|
||||
* hash array with methods description
|
||||
* @param array $config
|
||||
* hash array with configuration
|
||||
* @param int $debug
|
||||
* XMLRPC debug flag
|
||||
* @param boolean $verbose
|
||||
* verbosity flag
|
||||
*/
|
||||
public function __construct($mdefs, $debug=0, $verbose=FALSE)
|
||||
{
|
||||
global $CC_DBC, $CC_CONFIG;
|
||||
$this->mdefs = $mdefs;
|
||||
$this->debug = $debug;
|
||||
$this->verbose = $verbose;
|
||||
$confPrefix = "scheduler";
|
||||
//$confPrefix = "storage";
|
||||
$serverPath =
|
||||
"http://{$CC_CONFIG["{$confPrefix}UrlHost"]}:{$CC_CONFIG["{$confPrefix}UrlPort"]}".
|
||||
"{$CC_CONFIG["{$confPrefix}UrlPath"]}/{$CC_CONFIG["{$confPrefix}XMLRPC"]}";
|
||||
//$serverPath = "http://localhost:80/campcasterStorageServerCVS/xmlrpc/xrLocStor.php";
|
||||
if ($this->verbose) {
|
||||
echo "serverPath: $serverPath\n";
|
||||
}
|
||||
$url = parse_url($serverPath);
|
||||
$this->client = new XML_RPC_Client($url['path'], $url['host'], $url['port']);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Factory, create object instance
|
||||
*
|
||||
* In fact it doesn't create instance of SchedulerPhpClient, but
|
||||
* dynamically extend this class with set of methods based on $mdefs array
|
||||
* (using eval function) and instantiate resulting class
|
||||
* SchedulerPhpClientCore instead.
|
||||
* Each new method in this subclass accepts parameters according to $mdefs
|
||||
* array, call wrapper callMethod(methodname, parameters) and return its
|
||||
* result.
|
||||
*
|
||||
* @param array $mdefs
|
||||
* hash array with methods description
|
||||
* @param int $debug
|
||||
* XMLRPC debug flag
|
||||
* @param boolean $verbose
|
||||
* verbosity flag
|
||||
* @return SchedulerPhpClientCore
|
||||
*/
|
||||
function &factory($mdefs, $debug=0, $verbose=FALSE)
|
||||
{
|
||||
global $CC_DBC, $CC_CONFIG;
|
||||
$f = '';
|
||||
foreach ($mdefs as $fn => $farr) {
|
||||
$f .=
|
||||
' function '.$fn.'(){'."\n".
|
||||
' $pars = func_get_args();'."\n".
|
||||
' $r = $this->callMethod("'.$fn.'", $pars);'."\n".
|
||||
' return $r;'."\n".
|
||||
' }'."\n";
|
||||
}
|
||||
$e =
|
||||
"class SchedulerPhpClientCore extends SchedulerPhpClient{\n".
|
||||
"$f\n".
|
||||
"}\n";
|
||||
# echo $e;
|
||||
if (FALSE === eval($e)) {
|
||||
return $CC_DBC->raiseError("Eval failed");
|
||||
}
|
||||
$spc = new SchedulerPhpClientCore($mdefs, $debug, $verbose);
|
||||
return $spc;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* XMLRPC methods wrapper
|
||||
* Encode XMLRPC request message, send it, receive and decode response.
|
||||
*
|
||||
* @param string $method
|
||||
* method name
|
||||
* @param array $gettedPars
|
||||
* returned by func_get_args() in called method
|
||||
* @return array
|
||||
* PHP hash with response
|
||||
*/
|
||||
function callMethod($method, $gettedPars)
|
||||
{
|
||||
$parr = array();
|
||||
$XML_RPC_val = new XML_RPC_Value;
|
||||
foreach ($this->mdefs[$method]['p'] as $i => $p) {
|
||||
$parr[$p] = new XML_RPC_Value;
|
||||
$parr[$p]->addScalar($gettedPars[$i], $this->mdefs[$method]['t'][$i]);
|
||||
}
|
||||
$XML_RPC_val->addStruct($parr);
|
||||
$fullmethod = $this->mdefs[$method]['m'];
|
||||
$msg = new XML_RPC_Message($fullmethod, array($XML_RPC_val));
|
||||
if ($this->verbose) {
|
||||
echo "parr:\n";
|
||||
var_dump($parr);
|
||||
echo "message:\n";
|
||||
echo $msg->serialize()."\n";
|
||||
}
|
||||
$this->client->setDebug($this->debug);
|
||||
$res = $this->client->send($msg);
|
||||
if ($res->faultCode() > 0) {
|
||||
return PEAR::raiseError(
|
||||
"SchedulerPhpClient::$method:".$res->faultString()." ".
|
||||
$res->faultCode()."\n", $res->faultCode(),
|
||||
PEAR_ERROR_RETURN
|
||||
);
|
||||
}
|
||||
if ($this->verbose) {
|
||||
echo "result:\n";
|
||||
echo $res->serialize();
|
||||
}
|
||||
$val = $res->value();
|
||||
$resp = XML_RPC_decode($res->value());
|
||||
return $resp;
|
||||
}
|
||||
|
||||
} // class SchedulerPhpClient
|
||||
|
||||
/* ======================================================== class definitions */
|
||||
|
||||
/**
|
||||
* Example of use:
|
||||
*
|
||||
* /
|
||||
|
||||
|
||||
// db object handling:
|
||||
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
|
||||
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
|
||||
$CC_DBC->setErrorHandling(PEAR_ERROR_RETURN);
|
||||
|
||||
// scheduler client instantiation:
|
||||
$spc = SchedulerPhpClient::factory($mdefs);
|
||||
#$spc = SchedulerPhpClient::factory($mdefs, 0, TRUE);
|
||||
if(PEAR::isError($spc)){ echo $spc->getMessage."\n"; exit; }
|
||||
|
||||
// call of chosen function by name according to key values in $mdefs array:
|
||||
// (for testing on storageServer XMLRPC I've changes confPrefix in
|
||||
// SchedulerPhpClient constructor from 'scheduler' to 'storage' value)
|
||||
#$r = $spc->LoginGB('root', 'q'); var_dump($r);
|
||||
#$r = $spc->LogoutGB(''); var_dump($r);
|
||||
|
||||
#$r = $spc->DisplayScheduleMethod($this->Base->sessid, '2005-01-01 00:00:00.000000', '2005-02-01 00:00:00.000000'); var_dump($r);
|
||||
#$r = $spc->DisplayScheduleMethod('dummySessionId2-1681692777', '2005-01-01 00:00:00.000000', '2005-02-01 00:00:00.000000'); var_dump($r);
|
||||
$r = $spc->DisplayScheduleMethod($this->Base->sessid, '20040101T00:00:00', '20050401T00:00:00'); var_dump($r);
|
||||
#$r = $spc->LoginMethod('root', 'q'); var_dump($r);
|
||||
#$r = $spc->LogoutMethod('dummySessionId3-1714636915'); var_dump($r);
|
||||
#$r = $spc->listMethods(); var_dump($r);
|
||||
#$r = $spc->GetSchedulerTimeMethod(); var_dump($r);
|
||||
================= */
|
||||
|
||||
|
|
@ -1,127 +0,0 @@
|
|||
<?php
|
||||
/**
|
||||
* Returns stored media file identified by global unique ID.
|
||||
*
|
||||
* simpleGet.php is remote callable script through HTTP GET method.
|
||||
* Requires valid session ID with read permission for requested file.
|
||||
*
|
||||
* This script accepts following HTTP GET parameters:
|
||||
* <ul>
|
||||
* <li>sessid : string, session ID</li>
|
||||
* <li>id : string, global unique ID of requested file</li>
|
||||
* </ul>
|
||||
*
|
||||
* On success, returns HTTP return code 200 and requested file.
|
||||
*
|
||||
* On errors, returns HTTP return code >200
|
||||
* The possible error codes are:
|
||||
* <ul>
|
||||
* <li> 400 - Incorrect parameters passed to method</li>
|
||||
* <li> 403 - Access denied</li>
|
||||
* <li> 404 - File not found</li>
|
||||
* <li> 500 - Application error</li>
|
||||
* </ul>
|
||||
*
|
||||
*/
|
||||
|
||||
require_once(dirname(__FILE__).'/../../conf.php');
|
||||
require_once('DB.php');
|
||||
require_once(dirname(__FILE__).'/../LocStor.php');
|
||||
require_once(dirname(__FILE__).'/../MetaData.php');
|
||||
|
||||
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
|
||||
$CC_DBC->setErrorHandling(PEAR_ERROR_RETURN);
|
||||
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
|
||||
|
||||
$locStor = new LocStor();
|
||||
|
||||
function http_error($code, $err)
|
||||
{
|
||||
header("HTTP/1.1 $code");
|
||||
header("Content-type: text/plain; charset=UTF-8");
|
||||
echo "$err\r\n";
|
||||
exit;
|
||||
}
|
||||
|
||||
/**
|
||||
* This function encodes an filename to
|
||||
* be transferred via HTTP header.
|
||||
*
|
||||
* @param string $p_string utf8 filename
|
||||
* @return string HTTP header encoded filename
|
||||
*/
|
||||
function sg_2hexstring($p_string)
|
||||
{
|
||||
for ($x=0; $x < strlen($p_string); $x++) {
|
||||
$return .= '%' . bin2hex($p_string[$x]);
|
||||
}
|
||||
return $return;
|
||||
}
|
||||
|
||||
// parameter checking:
|
||||
if (preg_match("|^[0-9a-fA-F]{32}$|", $_REQUEST['sessid'])) {
|
||||
$sessid = $_REQUEST['sessid'];
|
||||
} else {
|
||||
http_error(400, "Error on sessid parameter. ({$_REQUEST['sessid']})");
|
||||
}
|
||||
if (preg_match("|^[0-9a-fA-F]{16}$|", $_REQUEST['id'])) {
|
||||
$gunid = $_REQUEST['id'];
|
||||
} else {
|
||||
http_error(400, "Error on id parameter. ({$_REQUEST['id']})");
|
||||
}
|
||||
|
||||
// stored file recall:
|
||||
$ac = StoredFile::RecallByGunid($gunid);
|
||||
if (PEAR::isError($ac)) {
|
||||
switch ($ac->getCode()) {
|
||||
case GBERR_DENY:
|
||||
http_error(403, "403 ".$ac->getMessage());
|
||||
case GBERR_FILENEX:
|
||||
case GBERR_FOBJNEX:
|
||||
http_error(404, "404 File not found");
|
||||
default:
|
||||
http_error(500, "500 ".$ac->getMessage());
|
||||
}
|
||||
}
|
||||
$lid = BasicStor::IdFromGunid($gunid);
|
||||
if (PEAR::isError($lid)) {
|
||||
http_error(500, $lid->getMessage());
|
||||
}
|
||||
if (($res = BasicStor::Authorize('read', $lid, $sessid)) !== TRUE) {
|
||||
http_error(403, "403 Access denied");
|
||||
}
|
||||
$ftype = BasicStor::GetObjType($lid);
|
||||
if (PEAR::isError($ftype)) {
|
||||
http_error(500, $ftype->getMessage());
|
||||
}
|
||||
switch ($ftype) {
|
||||
case "audioclip":
|
||||
$realFname = $ac->getRealFileName();
|
||||
$mime = $ac->getMime();
|
||||
$md = new MetaData($ac->getGunId(), null);
|
||||
$fileName = $md->getMetadataValue('dc:title').'.'.$ac->getFileExtension();
|
||||
header("Content-type: $mime");
|
||||
header("Content-length: ".filesize($realFname));
|
||||
header("Content-Disposition: attachment; filename*=".sg_2hexstring($fileName).";");
|
||||
readfile($realFname);
|
||||
break;
|
||||
case "webstream":
|
||||
$url = $locStor->bsGetMetadataValue($lid, 'ls:url');
|
||||
if (empty($url)) {
|
||||
http_error(500, "Unable to get ls:url value");
|
||||
}
|
||||
$txt = "Location: $url";
|
||||
header($txt);
|
||||
// echo "$txt\n";
|
||||
break;
|
||||
case "playlist";
|
||||
// $md = $locStor->bsGetMetadata($ac->getId(), $sessid);
|
||||
$md = $locStor->getAudioClip($sessid, $gunid);
|
||||
// header("Content-type: text/xml");
|
||||
header("Content-type: application/smil");
|
||||
echo $md;
|
||||
break;
|
||||
default:
|
||||
// var_dump($ftype);
|
||||
http_error(500, "500 Unknown ftype ($ftype)");
|
||||
}
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
#!/usr/bin/php -q
|
||||
<?
|
||||
$fp = fopen("/dev/stdin", "r");
|
||||
$data = '';
|
||||
while($part = fgets($fp, 1024)) $data .= $part;
|
||||
echo urldecode($data);
|
||||
?>
|
||||
|
|
@ -1,172 +0,0 @@
|
|||
<?php
|
||||
/* ====================================================== specific PHP config */
|
||||
ini_set("mbstring.internal_encoding", 'UTF-8');
|
||||
ini_set("html_errors", FALSE);
|
||||
ini_set("error_prepend_string", "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
|
||||
<methodResponse>
|
||||
<fault>
|
||||
<value>
|
||||
<struct>
|
||||
<member>
|
||||
<name>faultCode</name>
|
||||
<value><int>804</int></value>
|
||||
</member>
|
||||
<member>
|
||||
<name>faultString</name>
|
||||
<value><string>");
|
||||
ini_set("error_append_string", "</string></value>
|
||||
</member>
|
||||
</struct>
|
||||
</value>
|
||||
</fault>
|
||||
</methodResponse>");
|
||||
header("Content-type: text/xml");
|
||||
|
||||
/* ================================================================= includes */
|
||||
require_once(dirname(__FILE__).'/../../conf.php');
|
||||
require_once('DB.php');
|
||||
require_once("XML/RPC/Server.php");
|
||||
require_once('XR_LocStor.php');
|
||||
|
||||
/* ============================================ setting default error handler */
|
||||
function errHndl($errno, $errmsg, $filename, $linenum, $vars)
|
||||
{
|
||||
switch ($errno) {
|
||||
case E_WARNING:
|
||||
case E_NOTICE:
|
||||
case E_USER_WARNING:
|
||||
case E_USER_NOTICE:
|
||||
return;
|
||||
break;
|
||||
default:
|
||||
$xr = new XML_RPC_Response(0, 805,
|
||||
htmlspecialchars("ERROR:xrLocStor: $errno $errmsg ($filename:$linenum)"));
|
||||
header("Content-type: text/xml");
|
||||
echo $xr->serialize();
|
||||
exit($errno);
|
||||
}
|
||||
}
|
||||
$old_error_handler = set_error_handler("errHndl", E_ALL);
|
||||
|
||||
/* ============================================================= runable code */
|
||||
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
|
||||
if (PEAR::isError($CC_DBC)) {
|
||||
trigger_error("DB::connect: ".$CC_DBC->getMessage()." ".$CC_DBC->getUserInfo(),E_USER_ERROR);
|
||||
}
|
||||
$CC_DBC->setErrorHandling(PEAR_ERROR_RETURN);
|
||||
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
|
||||
|
||||
$locStor = new XR_LocStor();
|
||||
|
||||
$methods = array(
|
||||
'test' => 'Tests toupper and checks sessid, params: '.
|
||||
'teststring, sessid.',
|
||||
'getVersion' => 'Get version of Airtime.',
|
||||
// 'authenticate' => 'Checks authentication.',
|
||||
'login' => 'Login to storage.',
|
||||
'logout' => 'Logout from storage.',
|
||||
'existsAudioClip' => 'Checks if an audio clip with the specified '.
|
||||
'id is stored in local storage.',
|
||||
'storeAudioClipOpen' => 'Open channel to store a new audio clip '.
|
||||
'or replace an existing one.',
|
||||
'storeAudioClipClose' => 'Close channel to store a new audio clip'.
|
||||
' or replace an existing one.',
|
||||
'downloadRawAudioDataOpen'=> 'Create and return downloadable URL'.
|
||||
'for audio file',
|
||||
'downloadRawAudioDataClose'=>'Discard downloadable URL for audio file',
|
||||
'downloadMetadataOpen' => 'Create and return downloadable URL'.
|
||||
'for metadata',
|
||||
'downloadMetadataClose' => 'Discard downloadable URL for metadata',
|
||||
'openPut' => 'openPut',
|
||||
'closePut' => 'closePut',
|
||||
'deleteAudioClip' => 'Delete an existing Audio clip.',
|
||||
'updateAudioClipMetadata' => 'Update the metadata of an Audio clip '.
|
||||
'stored in Local storage.',
|
||||
'searchMetadata' => 'Search through the metadata of stored '.
|
||||
'files, return all matching clip ids.',
|
||||
'browseCategory' =>'Return values of specified metadata category.',
|
||||
'accessRawAudioData' => 'Get access to raw audio data.',
|
||||
'releaseRawAudioData' => 'Release access to raw audio data.',
|
||||
'getAudioClip' => 'Return the contents of an Audio clip.',
|
||||
// 'resetStorage' => 'Reset storageServer for debugging.',
|
||||
'storeWebstream' => 'Store audio stream identified by URL',
|
||||
|
||||
'createPlaylist' => 'Create a new Playlist metafile.',
|
||||
'editPlaylist' => 'Open a Playlist metafile for editing.',
|
||||
'savePlaylist' => 'Save a Playlist metafile.',
|
||||
'revertEditedPlaylist' => 'RollBack playlist changes to the locked state.',
|
||||
'deletePlaylist' => 'Delete a Playlist metafile.',
|
||||
'accessPlaylist' => 'Open readable URL to a Playlist metafile.',
|
||||
'releasePlaylist' => 'Release readable URL from accessPlaylist.',
|
||||
'existsPlaylist' => 'Check whether a Playlist exists.',
|
||||
'playlistIsAvailable' => 'Check whether a Playlist is available '.
|
||||
'for editing.',
|
||||
'exportPlaylistOpen' => 'Create a tarfile with playlist export.',
|
||||
'exportPlaylistClose' => 'Close playlist export.',
|
||||
'importPlaylistOpen' => 'Open writable handle for playlist import.',
|
||||
'importPlaylistClose' => 'Close import-handle and import playlist.',
|
||||
|
||||
'renderPlaylistToFileOpen' => 'Render playlist to ogg file (open handle)',
|
||||
'renderPlaylistToFileCheck' => 'Render playlist to ogg file (check results)',
|
||||
'renderPlaylistToFileClose' => 'Render playlist to ogg file (close handle)',
|
||||
|
||||
'renderPlaylistToStorageOpen' => 'Render playlist to storage media clip (open handle)',
|
||||
'renderPlaylistToStorageCheck' => 'Render playlist to storage media clip (check results)',
|
||||
|
||||
'renderPlaylistToRSSOpen' => 'Render playlist to RSS file (open handle)',
|
||||
'renderPlaylistToRSSCheck' => 'Render playlist to RSS file (check results)',
|
||||
'renderPlaylistToRSSClose' => 'Render playlist to RSS file (close handle)',
|
||||
|
||||
'createBackupOpen' => 'Create backup of storage (open handle)',
|
||||
'createBackupCheck' => 'Create backup of storage (check results)',
|
||||
'createBackupClose' => 'Create backup of storage (close handle)',
|
||||
|
||||
'restoreBackupOpen' => 'Restore a backup file (open handle)',
|
||||
'restoreBackupClosePut' => 'Restore a backup file (close PUT handle)',
|
||||
'restoreBackupCheck' => 'Restore a backup file (check results)',
|
||||
'restoreBackupClose' => 'Restore a backup file (close handle)',
|
||||
|
||||
'loadPref' => 'Load user preference value.',
|
||||
'savePref' => 'Save user preference value.',
|
||||
'delPref' => 'Delete user preference record.',
|
||||
'loadGroupPref' => 'Read group preference record.',
|
||||
'saveGroupPref' => 'Delete user preference record.',
|
||||
|
||||
'getTransportInfo' => 'Common "check" method and info getter for transports',
|
||||
'turnOnOffTransports' => 'Turn transports on/off, optionaly return current state',
|
||||
'doTransportAction' => 'Pause, resume or cancel transport',
|
||||
'uploadFile2Hub' => 'Open async file transfer from local storageServer to network hub',
|
||||
'getHubInitiatedTransfers' => 'Get list of prepared transfers initiated by hub',
|
||||
'startHubInitiatedTransfer' => 'Start of download initiated by hub',
|
||||
'upload2Hub' => 'Start upload of audioclip or playlist from local storageServer to hub',
|
||||
'downloadFromHub' => 'Start download of audioclip or playlist from hub to local storageServer',
|
||||
// 'globalSearch' => 'Start search job on network hub',
|
||||
// 'getSearchResults' => 'Get results from search job on network hub',
|
||||
|
||||
'uploadOpen' => 'Open file-layer upload',
|
||||
'uploadCheck' => 'Check the checksum of uploaded file',
|
||||
'uploadClose' => 'Close file-layer upload',
|
||||
'downloadOpen' => 'Open file-layer download',
|
||||
// 'downloadCheck' => 'Check the checksum of downloaded file',
|
||||
'downloadClose' => 'Close file-layer download',
|
||||
'prepareHubInitiatedTransfer' => 'Prepare hub initiated transfer',
|
||||
'listHubInitiatedTransfers' => 'List hub initiated transfers',
|
||||
'setHubInitiatedTransfer' => 'Set state of hub initiated transfers',
|
||||
'ping' => 'Echo request',
|
||||
);
|
||||
|
||||
$defs = array();
|
||||
foreach ($methods as $method => $description) {
|
||||
$defs["locstor.$method"] = array(
|
||||
"function" => array(&$locStor, "xr_$method"),
|
||||
// NOTE: the way this signature is set up, every function must take at least one parameter!
|
||||
"signature" => array(
|
||||
array($GLOBALS['XML_RPC_Struct'], $GLOBALS['XML_RPC_Struct'])
|
||||
),
|
||||
"docstring" => $description
|
||||
);
|
||||
}
|
||||
|
||||
$s = new XML_RPC_Server($defs);
|
||||
|
||||
|
||||
|
|
@ -1,367 +0,0 @@
|
|||
<?php
|
||||
require_once(dirname(__FILE__).'/../../conf.php');
|
||||
include_once("XML/RPC.php");
|
||||
include_once("Console/Getopt.php");
|
||||
|
||||
function printUsage()
|
||||
{
|
||||
echo "Usage:\n";
|
||||
echo " -v Verbose output\n";
|
||||
echo " -s arg Server Path\n";
|
||||
echo " -o arg1:value1,arg2:value2 Function Arguments\n";
|
||||
echo " -h Help\n";
|
||||
echo "\n";
|
||||
}
|
||||
|
||||
$verbose = TRUE;
|
||||
$parsedCommandLine = Console_Getopt::getopt($argv, "vs:o:h");
|
||||
$options = null;
|
||||
$cmdLineOptions = $parsedCommandLine[0];
|
||||
|
||||
if (count($parsedCommandLine[1]) == 0) {
|
||||
printUsage();
|
||||
exit;
|
||||
}
|
||||
|
||||
$method = array_pop($parsedCommandLine[1]);
|
||||
|
||||
foreach ($cmdLineOptions as $tmpValue) {
|
||||
$optionName = $tmpValue[0];
|
||||
$optionValue = $tmpValue[1];
|
||||
switch ($optionName) {
|
||||
case "h":
|
||||
printUsage();
|
||||
exit;
|
||||
case "v":
|
||||
$verbose = TRUE;
|
||||
break;
|
||||
case "s":
|
||||
$serverPath = $optionValue;
|
||||
break;
|
||||
case "o":
|
||||
$optStr = $optionValue;
|
||||
$optArr = split(",", $optStr);
|
||||
foreach ($optArr as $opt) {
|
||||
list($k, $v) = split(':', $opt);
|
||||
$options[$k] = $v;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
if (!isset($serverPath)) {
|
||||
$serverPath =
|
||||
"http://{$CC_CONFIG['storageUrlHost']}:{$CC_CONFIG['storageUrlPort']}".
|
||||
"{$CC_CONFIG['storageUrlPath']}/{$CC_CONFIG['storageXMLRPC']}";
|
||||
}
|
||||
|
||||
$url = parse_url($serverPath);
|
||||
$client = new XML_RPC_Client($url['path'], $url['host']);
|
||||
|
||||
if ($verbose) {
|
||||
$client->debug = 1;
|
||||
echo "ServerPath: $serverPath\n";
|
||||
echo "Host: {$url['host']}, path: {$url['path']}\n";
|
||||
echo "Method: $method\n";
|
||||
echo "Parameters:\n";
|
||||
//var_dump($pars);
|
||||
}
|
||||
|
||||
$infos = array(
|
||||
"listMethods" => array('m'=>"system.listMethods", 'p'=>NULL),
|
||||
"methodHelp" => array('m'=>"system.methodHelp", 'p'=>0),
|
||||
"methodSignature" => array('m'=>"system.methodSignature", 'p'=>0),
|
||||
"test" => array('m'=>"locstor.test", 'p'=>array('sessid', 'teststring')),
|
||||
"ping" => array('m'=>"locstor.ping", 'p'=>array("par")),
|
||||
"getVersion" => array('m'=>"locstor.getVersion", 'p'=>array("str"), 'r'=>'version'),
|
||||
"authenticate" => array('m'=>"locstor.authenticate", 'p'=>array('login', 'pass'), 'r'=>'authenticate'),
|
||||
"login" => array('m'=>"locstor.login", 'p'=>array('login', 'pass'), 'r'=>'sessid'),
|
||||
"logout" => array('m'=>"locstor.logout", 'p'=>array('sessid'), 'r'=>'status'),
|
||||
"storeAudioClipOpen" => array('m'=>"locstor.storeAudioClipOpen",
|
||||
'p'=>array('sessid', 'gunid', 'metadata', 'fname', 'chsum'),
|
||||
'r'=>array('url', 'token')
|
||||
),
|
||||
"storeAudioClipClose" => array('m'=>"locstor.storeAudioClipClose",
|
||||
'p'=>array('sessid', 'token'), 'r'=>'gunid'),
|
||||
"accessRawAudioData" => array('m'=>"locstor.accessRawAudioData",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>array('url', 'token')),
|
||||
"releaseRawAudioData" => array('m'=>"locstor.releaseRawAudioData",
|
||||
'p'=>array('token'), 'r'=>'status'),
|
||||
"downloadRawAudioDataOpen" =>
|
||||
array('m'=>"locstor.downloadRawAudioDataOpen",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>array('url', 'token')),
|
||||
"downloadRawAudioDataClose" =>
|
||||
array('m'=>"locstor.downloadRawAudioDataClose",
|
||||
'p'=>array('sessid', 'token'), 'r'=>'gunid'),
|
||||
"downloadMetadataOpen" => array('m'=>"locstor.downloadMetadataOpen",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>array('url', 'token')),
|
||||
"downloadMetadataClose" => array('m'=>"locstor.downloadMetadataClose",
|
||||
'p'=>array('sessid', 'token'), 'r'=>'gunid'),
|
||||
|
||||
"deleteAudioClip" =>
|
||||
array('m'=>"locstor.deleteAudioClip",
|
||||
'p'=>array('sessid', 'gunid', 'forced'), 'r'=>'status'),
|
||||
"existsAudioClip" => array('m'=>"locstor.existsAudioClip",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>'exists'),
|
||||
"getAudioClip" => array('m'=>"locstor.getAudioClip",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>'metadata'),
|
||||
"updateAudioClipMetadata" => array('m'=>"locstor.updateAudioClipMetadata",
|
||||
'p'=>array('sessid', 'gunid', 'metadata'), 'r'=>'status'),
|
||||
"searchMetadata" => array('m'=>"locstor.searchMetadata", 'p'=>NULL),
|
||||
"browseCategory" => array('m'=>"locstor.browseCategory", 'p'=>NULL),
|
||||
// "resetStorage" => array('m'=>"locstor.resetStorage",
|
||||
// 'p'=>array()),
|
||||
# 'p'=>array('loadSampleData', 'invalidateSessionIds')),
|
||||
"storeWebstream" => array('m'=>"locstor.storeWebstream",
|
||||
'p'=>array('sessid', 'gunid', 'metadata', 'fname', 'url'),
|
||||
'r'=>array('gunid')
|
||||
),
|
||||
|
||||
"createPlaylist" => array('m'=>"locstor.createPlaylist",
|
||||
'p'=>array('sessid', 'plid', 'fname'), 'r'=>'plid'),
|
||||
"editPlaylist" => array('m'=>"locstor.editPlaylist",
|
||||
'p'=>array('sessid', 'plid'), 'r'=>array('url', 'token')),
|
||||
"savePlaylist" => array('m'=>"locstor.savePlaylist",
|
||||
'p'=>array('sessid', 'token', 'newPlaylist'), 'r'=>'plid'),
|
||||
"revertEditedPlaylist" => array('m'=>"locstor.revertEditedPlaylist",
|
||||
'p'=>array('sessid', 'token'), 'r'=>'plid'),
|
||||
"deletePlaylist" => array('m'=>"locstor.deletePlaylist",
|
||||
'p'=>array('sessid', 'plid', 'forced'), 'r'=>'status'),
|
||||
"accessPlaylist" => array('m'=>"locstor.accessPlaylist",
|
||||
'p'=>array('sessid', 'plid'), 'r'=>array('url', 'token')),
|
||||
"releasePlaylist" => array('m'=>"locstor.releasePlaylist",
|
||||
'p'=>array('token'), 'r'=>'plid'),
|
||||
"existsPlaylist" => array('m'=>"locstor.existsPlaylist",
|
||||
'p'=>array('sessid', 'plid'), 'r'=>'exists'),
|
||||
"playlistIsAvailable" => array('m'=>"locstor.playlistIsAvailable",
|
||||
'p'=>array('sessid', 'plid'), 'r'=>array('available', 'ownerid', 'ownerlogin')),
|
||||
|
||||
"exportPlaylistOpen" => array('m'=>"locstor.exportPlaylistOpen",
|
||||
'p'=>array('sessid', 'plids', 'type', 'standalone'),
|
||||
'r'=>array('url', 'token')),
|
||||
"exportPlaylistClose" => array('m'=>"locstor.exportPlaylistClose",
|
||||
'p'=>array('token'), 'r'=>array('status')),
|
||||
"importPlaylistOpen" => array('m'=>"locstor.importPlaylistOpen",
|
||||
'p'=>array('sessid', 'chsum'), 'r'=>array('url', 'token')),
|
||||
"importPlaylistClose" => array('m'=>"locstor.importPlaylistClose",
|
||||
'p'=>array('token'), 'r'=>array('gunid')),
|
||||
|
||||
"renderPlaylistToFileOpen" => array('m'=>"locstor.renderPlaylistToFileOpen",
|
||||
'p'=>array('sessid', 'plid'),
|
||||
'r'=>array('token')),
|
||||
"renderPlaylistToFileCheck" => array('m'=>"locstor.renderPlaylistToFileCheck",
|
||||
'p'=>array('token'), 'r'=>array('status', 'url')),
|
||||
"renderPlaylistToFileClose" => array('m'=>"locstor.renderPlaylistToFileClose",
|
||||
'p'=>array('token'), 'r'=>array('status')),
|
||||
"renderPlaylistToStorageOpen" => array('m'=>"locstor.renderPlaylistToStorageOpen",
|
||||
'p'=>array('sessid', 'plid'),
|
||||
'r'=>array('token')),
|
||||
"renderPlaylistToStorageCheck" => array('m'=>"locstor.renderPlaylistToStorageCheck",
|
||||
'p'=>array('token'), 'r'=>array('status', 'gunid')),
|
||||
"renderPlaylistToRSSOpen" => array('m'=>"locstor.renderPlaylistToRSSOpen",
|
||||
'p'=>array('sessid', 'plid'),
|
||||
'r'=>array('token')),
|
||||
"renderPlaylistToRSSCheck" => array('m'=>"locstor.renderPlaylistToRSSCheck",
|
||||
'p'=>array('token'), 'r'=>array('status', 'url')),
|
||||
"renderPlaylistToRSSClose" => array('m'=>"locstor.renderPlaylistToRSSClose",
|
||||
'p'=>array('token'), 'r'=>array('status')),
|
||||
|
||||
"loadPref" => array('m'=>"locstor.loadPref",
|
||||
'p'=>array('sessid', 'key'), 'r'=>'value'),
|
||||
"savePref" => array('m'=>"locstor.savePref",
|
||||
'p'=>array('sessid', 'key', 'value'), 'r'=>'status'),
|
||||
"delPref" => array('m'=>"locstor.delPref",
|
||||
'p'=>array('sessid', 'key'), 'r'=>'status'),
|
||||
"loadGroupPref" => array('m'=>"locstor.loadGroupPref",
|
||||
'p'=>array('sessid', 'group', 'key'), 'r'=>'value'),
|
||||
"saveGroupPref" => array('m'=>"locstor.saveGroupPref",
|
||||
'p'=>array('sessid', 'group', 'key', 'value'), 'r'=>'status'),
|
||||
|
||||
"getTransportInfo" => array('m'=>"locstor.getTransportInfo",
|
||||
'p'=>array('trtok'),
|
||||
'r'=>array('state', 'realsize', 'expectedsize', 'realsum', 'expectedsum')),
|
||||
"turnOnOffTransports" => array('m'=>"locstor.turnOnOffTransports",
|
||||
'p'=>array('sessid', 'onOff'), 'r'=>array('state')),
|
||||
"doTransportAction" => array('m'=>"locstor.doTransportAction",
|
||||
'p'=>array('sessid', 'trtok', 'action'), 'r'=>array('state')),
|
||||
"uploadFile2Hub" => array('m'=>"locstor.uploadFile2Hub",
|
||||
'p'=>array('sessid', 'filePath'), 'r'=>array('trtok')),
|
||||
"getHubInitiatedTransfers" => array('m'=>"locstor.getHubInitiatedTransfers",
|
||||
'p'=>array('sessid'), 'r'=>array()),
|
||||
"startHubInitiatedTransfer" => array('m'=>"locstor.startHubInitiatedTransfer",
|
||||
'p'=>array('trtok'), 'r'=>array()),
|
||||
"upload2Hub" => array('m'=>"locstor.upload2Hub",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>array('trtok')),
|
||||
"downloadFromHub" => array('m'=>"locstor.downloadFromHub",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>array('trtok')),
|
||||
// "globalSearch" => array('m'=>"locstor.globalSearch",
|
||||
// 'p'=>array('sessid', 'criteria'), 'r'=>array('trtok')),
|
||||
// "getSearchResults" => array('m'=>"locstor.getSearchResults",
|
||||
// 'p'=>array('trtok')),
|
||||
|
||||
"createBackupOpen" => array('m'=>"locstor.createBackupOpen",
|
||||
'p'=>array('sessid', 'criteria'), 'r'=>array('token')),
|
||||
"createBackupCheck" => array('m'=>"locstor.createBackupCheck",
|
||||
# 'p'=>array('token'), 'r'=>array('status', 'url', 'metafile', 'faultString')),
|
||||
'p'=>array('token'), 'r'=>array('status', 'url', 'tmpfile')),
|
||||
"createBackupClose" => array('m'=>"locstor.createBackupClose",
|
||||
'p'=>array('token'), 'r'=>array('status')),
|
||||
"restoreBackupOpen" => array('m'=>"locstor.restoreBackupOpen",
|
||||
'p'=>array('sessid', 'chsum'), 'r'=>array('url', 'token')),
|
||||
"restoreBackupClosePut" => array('m'=>"locstor.restoreBackupClosePut",
|
||||
'p'=>array('sessid', 'token'), 'r'=>array('token')),
|
||||
"restoreBackupCheck" => array('m'=>"locstor.restoreBackupCheck",
|
||||
'p'=>array('token'), 'r'=>array('status', 'faultString')),
|
||||
"restoreBackupClose" => array('m'=>"locstor.restoreBackupClose",
|
||||
'p'=>array('token'), 'r'=>array('status')),
|
||||
|
||||
/*
|
||||
"uploadToArchive" => array('m'=>"locstor.uploadToArchive",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>'trtok'),
|
||||
"downloadFromArchive" => array('m'=>"locstor.downloadFromArchive",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>'trtok'),
|
||||
*/
|
||||
|
||||
"openPut" => array('m'=>"locstor.openPut", 'p'=>array()),
|
||||
"closePut" => array('m'=>"locstor.closePut", 'p'=>array()),
|
||||
);
|
||||
|
||||
|
||||
switch ($method) {
|
||||
case "searchMetadata":
|
||||
// case "globalSearch":
|
||||
case "createBackupOpen":
|
||||
$parr = array(
|
||||
'sessid'=>$pars[0],
|
||||
'criteria'=>array(
|
||||
'filetype'=>'audioclip',
|
||||
'operator'=>'and',
|
||||
'limit'=> 0,
|
||||
'offset'=> 0,
|
||||
'conditions'=>array(
|
||||
array('cat'=>$pars[1], 'op'=>'partial', 'val'=>$pars[2])
|
||||
)
|
||||
),
|
||||
);
|
||||
break;
|
||||
case "browseCategory":
|
||||
$parr = array(
|
||||
'sessid'=>$pars[0],
|
||||
'category'=>$pars[1],
|
||||
'criteria'=>array(
|
||||
'filetype'=>'audioclip',
|
||||
'operator'=>'and',
|
||||
'limit'=> 0,
|
||||
'offset'=> 0,
|
||||
'conditions'=>array(
|
||||
array('cat'=>$pars[2], 'op'=>'partial', 'val'=>$pars[3])
|
||||
)
|
||||
),
|
||||
);
|
||||
break;
|
||||
// case "resetStorage":
|
||||
// $parr = array(
|
||||
// 'loadSampleData'=>(boolean)$pars[0],
|
||||
// 'invalidateSessionIds'=>(boolean)$pars[1],
|
||||
// );
|
||||
// break;
|
||||
default:
|
||||
$pinfo = $infos[$method]['p'];
|
||||
if (is_null($pinfo)) {
|
||||
$parr = NULL;
|
||||
} elseif(!is_array($pinfo)) {
|
||||
$parr = $pars[0];
|
||||
#echo "pinfo not null and not array.\n"; exit;
|
||||
} elseif(count($pinfo) == 0) {
|
||||
$parr = (object)array();
|
||||
} else {
|
||||
$parr = array(); $i=0;
|
||||
foreach($pinfo as $it){
|
||||
if(isset($pars[$i])) $parr[$it] = $pars[$i];
|
||||
$i++;
|
||||
}
|
||||
}
|
||||
} // switch
|
||||
|
||||
$fullmethod = $infos[$method]['m'];
|
||||
if (is_array($options)) {
|
||||
$msg = new XML_RPC_Message($fullmethod, array(XML_RPC_encode($options)));
|
||||
} else {
|
||||
$msg = new XML_RPC_Message($fullmethod);
|
||||
}
|
||||
//$msg = new XML_RPC_Message($fullmethod, array(XML_RPC_encode($parr)));
|
||||
|
||||
if ($verbose) {
|
||||
echo "parr:\n";
|
||||
var_dump($parr);
|
||||
echo "message:\n";
|
||||
echo $msg->serialize()."\n";
|
||||
}
|
||||
|
||||
#$client->setDebug(1);
|
||||
$res = $client->send($msg);
|
||||
if ($res->faultCode() > 0) {
|
||||
echo "xr_cli_test.php: ".$res->faultString()." ".$res->faultCode()."\n";
|
||||
# echo var_export($res);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if ($verbose) {
|
||||
echo "result:\n";
|
||||
echo $res->serialize();
|
||||
}
|
||||
|
||||
$resp = XML_RPC_decode($res->value());
|
||||
if (isset($infos[$method]['r'])) {
|
||||
$pom = $infos[$method]['r'];
|
||||
if (is_array($pom)) {
|
||||
foreach ($pom as $k => $it) {
|
||||
$pom[$k] = $resp[$it];
|
||||
}
|
||||
echo join(' ', $pom)."\n";
|
||||
} else {
|
||||
switch ($pom) {
|
||||
case "status":
|
||||
case "exists":
|
||||
echo ($resp[$pom]=='1' ? "TRUE" : "FALSE" )."\n";
|
||||
break;
|
||||
default:
|
||||
echo "{$resp[$pom]}\n";
|
||||
}
|
||||
}
|
||||
} else {
|
||||
switch ($method) {
|
||||
case "searchMetadata":
|
||||
// case "getSearchResults":
|
||||
$acCnt = 0;
|
||||
$acGunids = array();
|
||||
$plCnt = 0;
|
||||
$plGunids = array();
|
||||
$fld = (isset($options['category']) ? $options['category'] : 'gunid' );
|
||||
foreach ($resp['results'] as $k => $v) {
|
||||
if ($v['type']=='audioclip') {
|
||||
$acCnt++;
|
||||
$acGunids[] = $v[$fld];
|
||||
}
|
||||
if ($v['type']=='playlist') {
|
||||
$plCnt++;
|
||||
$plGunids[] = $v[$fld];
|
||||
}
|
||||
}
|
||||
echo "AC({$acCnt}): ".
|
||||
join(", ", $acGunids).
|
||||
" | PL({$plCnt}): ".
|
||||
join(", ", $plGunids).
|
||||
"\n";
|
||||
break;
|
||||
case "browseCategory":
|
||||
echo "RES({$resp['cnt']}): ".
|
||||
join(", ", $resp['results']).
|
||||
"\n";
|
||||
break;
|
||||
default:
|
||||
print_r($resp);
|
||||
echo "\n";
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1,373 +0,0 @@
|
|||
<?php
|
||||
require_once(dirname(__FILE__).'/../../conf.php');
|
||||
include_once("XML/RPC.php");
|
||||
|
||||
session_start();
|
||||
|
||||
/**
|
||||
* Get a persistant value. If the value is present in the $_REQUEST
|
||||
* array, the session variable will be set to this value and returned.
|
||||
* If the value is not yet set, it will be set to the default value.
|
||||
* In all other cases the value from the session variable is returned.
|
||||
*
|
||||
* @param string $p_name
|
||||
* @param mixed $p_defaultValue
|
||||
* @return mixed
|
||||
*/
|
||||
function camp_session_get($p_name, $p_defaultValue)
|
||||
{
|
||||
// Use the REQUEST variable if it is set.
|
||||
if (isset($_REQUEST[$p_name])) {
|
||||
$_SESSION[$p_name] = $_REQUEST[$p_name];
|
||||
}
|
||||
elseif (!isset($_SESSION[$p_name])) {
|
||||
$_SESSION[$p_name] = $p_defaultValue;
|
||||
}
|
||||
return $_SESSION[$p_name];
|
||||
} // fn camp_session_get
|
||||
|
||||
|
||||
/**
|
||||
* Print out an HTML OPTION element.
|
||||
*
|
||||
* @param string $p_value
|
||||
* @param string $p_selectedValue
|
||||
* @param string $p_printValue
|
||||
* @return boolean
|
||||
* Return TRUE if the option is selected, FALSE if not.
|
||||
*/
|
||||
function camp_html_select_option($p_value, $p_selectedValue, $p_printValue)
|
||||
{
|
||||
$selected = false;
|
||||
$str = '<OPTION VALUE="'.htmlspecialchars($p_value, ENT_QUOTES).'"';
|
||||
if (!strcmp($p_value, $p_selectedValue)) {
|
||||
$str .= ' SELECTED';
|
||||
$selected = true;
|
||||
}
|
||||
$str .= '>'.htmlspecialchars($p_printValue)."</OPTION>\n";
|
||||
echo $str;
|
||||
return $selected;
|
||||
} // fn camp_html_select_option
|
||||
|
||||
|
||||
$serverPath =
|
||||
"http://{$CC_CONFIG['storageUrlHost']}:{$CC_CONFIG['storageUrlPort']}".
|
||||
"{$CC_CONFIG['storageUrlPath']}/{$CC_CONFIG['storageXMLRPC']}";
|
||||
$serverPath = camp_session_get("storageserver_xmlrpc_path", $serverPath);
|
||||
$f_selectedMethod = camp_session_get("f_selectedMethod", "listMethods");
|
||||
$url = parse_url($serverPath);
|
||||
$client = new XML_RPC_Client($url['path'], $url['host']);
|
||||
|
||||
$methodDefs = array(
|
||||
"listMethods" => array('m'=>"system.listMethods", 'p'=>NULL),
|
||||
"methodHelp" => array('m'=>"system.methodHelp", 'p'=>0),
|
||||
"methodSignature" => array('m'=>"system.methodSignature", 'p'=>0),
|
||||
"test" => array('m'=>"locstor.test", 'p'=>array('sessid', 'teststring')),
|
||||
"getVersion" => array('m'=>"locstor.getVersion", 'p'=>array(), 'r'=>'version'),
|
||||
"authenticate" => array('m'=>"locstor.authenticate", 'p'=>array('login', 'pass'), 'r'=>'authenticate'),
|
||||
"login" => array('m'=>"locstor.login", 'p'=>array('login', 'pass'), 'r'=>'sessid'),
|
||||
"logout" => array('m'=>"locstor.logout", 'p'=>array('sessid'), 'r'=>'status'),
|
||||
"storeAudioClipOpen" => array('m'=>"locstor.storeAudioClipOpen",
|
||||
'p'=>array('sessid', 'gunid', 'metadata', 'fname', 'chsum'),
|
||||
'r'=>array('url', 'token')
|
||||
),
|
||||
"storeAudioClipClose" => array('m'=>"locstor.storeAudioClipClose",
|
||||
'p'=>array('sessid', 'token'), 'r'=>'gunid'),
|
||||
"accessRawAudioData" => array('m'=>"locstor.accessRawAudioData",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>array('url', 'token')),
|
||||
"releaseRawAudioData" => array('m'=>"locstor.releaseRawAudioData",
|
||||
'p'=>array('token'), 'r'=>'status'),
|
||||
"downloadRawAudioDataOpen" =>
|
||||
array('m'=>"locstor.downloadRawAudioDataOpen",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>array('url', 'token')),
|
||||
"downloadRawAudioDataClose" =>
|
||||
array('m'=>"locstor.downloadRawAudioDataClose",
|
||||
'p'=>array('sessid', 'token'), 'r'=>'gunid'),
|
||||
"downloadMetadataOpen" => array('m'=>"locstor.downloadMetadataOpen",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>array('url', 'token')),
|
||||
"downloadMetadataClose" => array('m'=>"locstor.downloadMetadataClose",
|
||||
'p'=>array('sessid', 'token'), 'r'=>'gunid'),
|
||||
|
||||
"deleteAudioClip" =>
|
||||
array('m'=>"locstor.deleteAudioClip",
|
||||
'p'=>array('sessid', 'gunid', 'forced'), 'r'=>'status'),
|
||||
"existsAudioClip" => array('m'=>"locstor.existsAudioClip",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>'exists'),
|
||||
"getAudioClip" => array('m'=>"locstor.getAudioClip",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>'metadata'),
|
||||
"updateAudioClipMetadata" => array('m'=>"locstor.updateAudioClipMetadata",
|
||||
'p'=>array('sessid', 'gunid', 'metadata'), 'r'=>'status'),
|
||||
"searchMetadata" => array('m'=>"locstor.searchMetadata", 'p'=>NULL),
|
||||
"browseCategory" => array('m'=>"locstor.browseCategory", 'p'=>NULL),
|
||||
// "resetStorage" => array('m'=>"locstor.resetStorage",
|
||||
// 'p'=>array()),
|
||||
"storeWebstream" => array('m'=>"locstor.storeWebstream",
|
||||
'p'=>array('sessid', 'gunid', 'metadata', 'fname', 'url'),
|
||||
'r'=>array('gunid')
|
||||
),
|
||||
|
||||
"createPlaylist" => array('m'=>"locstor.createPlaylist",
|
||||
'p'=>array('sessid', 'plid', 'fname'), 'r'=>'plid'),
|
||||
"editPlaylist" => array('m'=>"locstor.editPlaylist",
|
||||
'p'=>array('sessid', 'plid'), 'r'=>array('url', 'token')),
|
||||
"savePlaylist" => array('m'=>"locstor.savePlaylist",
|
||||
'p'=>array('sessid', 'token', 'newPlaylist'), 'r'=>'plid'),
|
||||
"revertEditedPlaylist" => array('m'=>"locstor.revertEditedPlaylist",
|
||||
'p'=>array('sessid', 'token'), 'r'=>'plid'),
|
||||
"deletePlaylist" => array('m'=>"locstor.deletePlaylist",
|
||||
'p'=>array('sessid', 'plid', 'forced'), 'r'=>'status'),
|
||||
"accessPlaylist" => array('m'=>"locstor.accessPlaylist",
|
||||
'p'=>array('sessid', 'plid'), 'r'=>array('url', 'token')),
|
||||
"releasePlaylist" => array('m'=>"locstor.releasePlaylist",
|
||||
'p'=>array('token'), 'r'=>'plid'),
|
||||
"existsPlaylist" => array('m'=>"locstor.existsPlaylist",
|
||||
'p'=>array('sessid', 'plid'), 'r'=>'exists'),
|
||||
"playlistIsAvailable" => array('m'=>"locstor.playlistIsAvailable",
|
||||
'p'=>array('sessid', 'plid'), 'r'=>array('available', 'ownerid', 'ownerlogin')),
|
||||
|
||||
"exportPlaylistOpen" => array('m'=>"locstor.exportPlaylistOpen",
|
||||
'p'=>array('sessid', 'plids', 'type', 'standalone'),
|
||||
'r'=>array('url', 'token')),
|
||||
"exportPlaylistClose" => array('m'=>"locstor.exportPlaylistClose",
|
||||
'p'=>array('token'), 'r'=>array('status')),
|
||||
"importPlaylistOpen" => array('m'=>"locstor.importPlaylistOpen",
|
||||
'p'=>array('sessid', 'chsum'), 'r'=>array('url', 'token')),
|
||||
"importPlaylistClose" => array('m'=>"locstor.importPlaylistClose",
|
||||
'p'=>array('token'), 'r'=>array('gunid')),
|
||||
|
||||
"renderPlaylistToFileOpen" => array('m'=>"locstor.renderPlaylistToFileOpen",
|
||||
'p'=>array('sessid', 'plid'),
|
||||
'r'=>array('token')),
|
||||
"renderPlaylistToFileCheck" => array('m'=>"locstor.renderPlaylistToFileCheck",
|
||||
'p'=>array('token'), 'r'=>array('status', 'url')),
|
||||
"renderPlaylistToFileClose" => array('m'=>"locstor.renderPlaylistToFileClose",
|
||||
'p'=>array('token'), 'r'=>array('status')),
|
||||
"renderPlaylistToStorageOpen" => array('m'=>"locstor.renderPlaylistToStorageOpen",
|
||||
'p'=>array('sessid', 'plid'),
|
||||
'r'=>array('token')),
|
||||
"renderPlaylistToStorageCheck" => array('m'=>"locstor.renderPlaylistToStorageCheck",
|
||||
'p'=>array('token'), 'r'=>array('status', 'gunid')),
|
||||
"renderPlaylistToRSSOpen" => array('m'=>"locstor.renderPlaylistToRSSOpen",
|
||||
'p'=>array('sessid', 'plid'),
|
||||
'r'=>array('token')),
|
||||
"renderPlaylistToRSSCheck" => array('m'=>"locstor.renderPlaylistToRSSCheck",
|
||||
'p'=>array('token'), 'r'=>array('status', 'url')),
|
||||
"renderPlaylistToRSSClose" => array('m'=>"locstor.renderPlaylistToRSSClose",
|
||||
'p'=>array('token'), 'r'=>array('status')),
|
||||
|
||||
"loadPref" => array('m'=>"locstor.loadPref",
|
||||
'p'=>array('sessid', 'key'), 'r'=>'value'),
|
||||
"savePref" => array('m'=>"locstor.savePref",
|
||||
'p'=>array('sessid', 'key', 'value'), 'r'=>'status'),
|
||||
"delPref" => array('m'=>"locstor.delPref",
|
||||
'p'=>array('sessid', 'key'), 'r'=>'status'),
|
||||
"loadGroupPref" => array('m'=>"locstor.loadGroupPref",
|
||||
'p'=>array('sessid', 'group', 'key'), 'r'=>'value'),
|
||||
"saveGroupPref" => array('m'=>"locstor.saveGroupPref",
|
||||
'p'=>array('sessid', 'group', 'key', 'value'), 'r'=>'status'),
|
||||
|
||||
"getTransportInfo" => array('m'=>"locstor.getTransportInfo",
|
||||
'p'=>array('trtok'),
|
||||
'r'=>array('state', 'realsize', 'expectedsize', 'realsum', 'expectedsum')),
|
||||
"turnOnOffTransports" => array('m'=>"locstor.turnOnOffTransports",
|
||||
'p'=>array('sessid', 'onOff'), 'r'=>array('state')),
|
||||
"doTransportAction" => array('m'=>"locstor.doTransportAction",
|
||||
'p'=>array('sessid', 'trtok', 'action'), 'r'=>array('state')),
|
||||
"uploadFile2Hub" => array('m'=>"locstor.uploadFile2Hub",
|
||||
'p'=>array('sessid', 'filePath'), 'r'=>array('trtok')),
|
||||
"getHubInitiatedTransfers" => array('m'=>"locstor.getHubInitiatedTransfers",
|
||||
'p'=>array('sessid'), 'r'=>array()),
|
||||
"startHubInitiatedTransfer" => array('m'=>"locstor.startHubInitiatedTransfer",
|
||||
'p'=>array('trtok'), 'r'=>array()),
|
||||
"upload2Hub" => array('m'=>"locstor.upload2Hub",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>array('trtok')),
|
||||
"downloadFromHub" => array('m'=>"locstor.downloadFromHub",
|
||||
'p'=>array('sessid', 'gunid'), 'r'=>array('trtok')),
|
||||
// "globalSearch" => array('m'=>"locstor.globalSearch",
|
||||
// 'p'=>array('sessid', 'criteria'), 'r'=>array('trtok')),
|
||||
// "getSearchResults" => array('m'=>"locstor.getSearchResults",
|
||||
// 'p'=>array('trtok')),
|
||||
|
||||
"createBackupOpen" => array('m'=>"locstor.createBackupOpen",
|
||||
'p'=>array('sessid', 'criteria'), 'r'=>array('token')),
|
||||
"createBackupCheck" => array('m'=>"locstor.createBackupCheck",
|
||||
# 'p'=>array('token'), 'r'=>array('status', 'url', 'metafile', 'faultString')),
|
||||
'p'=>array('token'), 'r'=>array('status', 'url', 'tmpfile')),
|
||||
"createBackupClose" => array('m'=>"locstor.createBackupClose",
|
||||
'p'=>array('token'), 'r'=>array('status')),
|
||||
"restoreBackupOpen" => array('m'=>"locstor.restoreBackupOpen",
|
||||
'p'=>array('sessid', 'chsum'), 'r'=>array('url', 'token')),
|
||||
"restoreBackupClosePut" => array('m'=>"locstor.restoreBackupClosePut",
|
||||
'p'=>array('sessid', 'token'), 'r'=>array('token')),
|
||||
"restoreBackupCheck" => array('m'=>"locstor.restoreBackupCheck",
|
||||
'p'=>array('token'), 'r'=>array('status', 'faultString')),
|
||||
"restoreBackupClose" => array('m'=>"locstor.restoreBackupClose",
|
||||
'p'=>array('token'), 'r'=>array('status')),
|
||||
"openPut" => array('m'=>"locstor.openPut", 'p'=>array()),
|
||||
"closePut" => array('m'=>"locstor.closePut", 'p'=>array()),
|
||||
);
|
||||
|
||||
if (isset($_REQUEST['go_button'])) {
|
||||
// Get the parameters
|
||||
$methodParams = $methodDefs[$f_selectedMethod]['p'];
|
||||
foreach ($methodParams as $methodParamName) {
|
||||
$inputParamName = "param_".$methodParamName;
|
||||
$xmlParameters[$methodParamName] = $_REQUEST[$inputParamName];
|
||||
$_SESSION[$inputParamName] = $_REQUEST[$inputParamName];
|
||||
}
|
||||
|
||||
// Create the XML-RPC message
|
||||
$actualMethod = $methodDefs[$f_selectedMethod]['m'];
|
||||
$msg = new XML_RPC_Message($actualMethod, array(XML_RPC_encode($xmlParameters)));
|
||||
$sentMessage = $msg->serialize();
|
||||
|
||||
// Send it
|
||||
$sendResult = $client->send($msg);
|
||||
if ($sendResult->faultCode() > 0) {
|
||||
$errorMsg = "xr_cli_test.php: ".$sendResult->faultString()." ".$sendResult->faultCode()."\n";
|
||||
} else {
|
||||
// If successful
|
||||
$xmlResponse = XML_RPC_decode($sendResult->value());
|
||||
|
||||
// Special case state handling
|
||||
switch ($f_selectedMethod) {
|
||||
case "login":
|
||||
// Remember the login session ID so we can use it to call
|
||||
// other methods.
|
||||
$loggedIn = true;
|
||||
$_SESSION['xmlrpc_session_id'] = $xmlResponse['sessid'];
|
||||
break;
|
||||
case "logout":
|
||||
unset($_SESSION['xmlrpc_session_id']);
|
||||
break;
|
||||
case "storeAudioClipOpen":
|
||||
$_SESSION['xmlrpc_token'] = $xmlResponse['token'];
|
||||
$_SESSION['xmlrpc_put_url'] = $xmlResponse['url'];
|
||||
break;
|
||||
}
|
||||
|
||||
if (isset($methodDefs[$method]['r'])) {
|
||||
$expectedResult = $methodDefs[$method]['r'];
|
||||
if (is_array($expectedResult)) {
|
||||
foreach ($expectedResult as $resultName) {
|
||||
$actualResults[$resultName] = $xmlResponse[$resultName];
|
||||
}
|
||||
echo join(' ', $actualResults)."\n";
|
||||
} else {
|
||||
switch ($expectedResult) {
|
||||
case "status":
|
||||
case "exists":
|
||||
echo ($xmlResponse[$expectedResult]=='1' ? "TRUE" : "FALSE" )."\n";
|
||||
break;
|
||||
default:
|
||||
echo "{$xmlResponse[$expectedResult]}\n";
|
||||
}
|
||||
}
|
||||
} else {
|
||||
switch ($method) {
|
||||
case "searchMetadata":
|
||||
// case "getSearchResults":
|
||||
$acCnt = 0;
|
||||
$acGunids = array();
|
||||
$plCnt = 0;
|
||||
$plGunids = array();
|
||||
$fld = (isset($options['category']) ? $options['category'] : 'gunid' );
|
||||
foreach ($xmlResponse['results'] as $k => $v) {
|
||||
if ($v['type']=='audioclip') {
|
||||
$acCnt++;
|
||||
$acGunids[] = $v[$fld];
|
||||
}
|
||||
if ($v['type']=='playlist') {
|
||||
$plCnt++;
|
||||
$plGunids[] = $v[$fld];
|
||||
}
|
||||
}
|
||||
echo "AC({$acCnt}): ".
|
||||
join(", ", $acGunids).
|
||||
" | PL({$plCnt}): ".
|
||||
join(", ", $plGunids).
|
||||
"\n";
|
||||
break;
|
||||
case "browseCategory":
|
||||
echo "RES({$xmlResponse['cnt']}): ".
|
||||
join(", ", $xmlResponse['results']).
|
||||
"\n";
|
||||
break;
|
||||
default:
|
||||
//print_r($xmlResponse);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
?>
|
||||
<html>
|
||||
<body bgcolor="#dddddd">
|
||||
<form>
|
||||
StorageServer path : <INPUT type="text" name="f_storageserver_xmlrpc_path" value="<?php echo $serverPath; ?>" size="100"><br>
|
||||
Method:
|
||||
<select name="f_selectedMethod" onchange="this.form.submit();">
|
||||
<?php
|
||||
foreach ($methodDefs as $methodName => $methodDef) {
|
||||
camp_html_select_option($methodName, $f_selectedMethod, $methodName);
|
||||
}
|
||||
?>
|
||||
</select>
|
||||
<br>
|
||||
Parameters:
|
||||
<?PHP
|
||||
$methodParams = $methodDefs[$f_selectedMethod]['p'];
|
||||
if (!is_array($methodParams) || count($methodParams) == 0) {
|
||||
echo "This method requires no parameters.<br>";
|
||||
} else {
|
||||
echo "<table cellpadding=3>";
|
||||
foreach ($methodParams as $methodParamName) {
|
||||
$value = "";
|
||||
if ($methodParamName == "sessid" && isset($_SESSION['xmlrpc_session_id'])) {
|
||||
$value = $_SESSION['xmlrpc_session_id'];
|
||||
} elseif ($methodParamName == "token" && isset($_SESSION['xmlrpc_token'])) {
|
||||
$value = $_SESSION['xmlrpc_token'];
|
||||
} elseif (isset($_SESSION["param_".$methodParamName])) {
|
||||
$value = $_SESSION["param_".$methodParamName];
|
||||
}
|
||||
echo "<tr>";
|
||||
echo "<td>$methodParamName</td>"; ?> <td><INPUT type="text" name="param_<?php echo $methodParamName; ?>" value="<?php echo $value; ?>"><td></tr>
|
||||
<?php
|
||||
}
|
||||
echo "</table>";
|
||||
}
|
||||
?>
|
||||
<br>
|
||||
<INPUT type="submit" name="go_button" value="Send Message">
|
||||
</form>
|
||||
|
||||
|
||||
<?PHP
|
||||
if ($loggedIn) {
|
||||
echo "You have logged in with session ID: ".$_SESSION['xmlrpc_session_id']."<br><br>";
|
||||
}
|
||||
if (isset($sentMessage)) {
|
||||
?>
|
||||
Sent message:<br>
|
||||
<TEXTAREA cols="60" rows="8">Method name: <?php echo $actualMethod; ?>
|
||||
<?php print_r($xmlParameters);?></TEXTAREA>
|
||||
<br>
|
||||
<?PHP
|
||||
}
|
||||
if (isset($errorMsg)) {
|
||||
?>
|
||||
Error:<br>
|
||||
<TEXTAREA cols="60" rows="8"><?php print_r($errorMsg);?></TEXTAREA>
|
||||
<br>
|
||||
<?php
|
||||
}
|
||||
|
||||
if (isset($xmlResponse)) {
|
||||
?>
|
||||
Response:<br>
|
||||
<TEXTAREA cols="60" rows="8"><?php print_r($xmlResponse);?></TEXTAREA>
|
||||
<br>
|
||||
<?php
|
||||
}
|
||||
?>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -1,112 +0,0 @@
|
|||
#!/bin/bash
|
||||
#-------------------------------------------------------------------------------
|
||||
# Copyright (c) 2010 Sourcefabric O.P.S.
|
||||
#
|
||||
# This file is part of the Airtime project.
|
||||
# http://airtime.sourcefabric.org/
|
||||
#
|
||||
# Airtime is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# Airtime is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with Airtime; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
#
|
||||
#-------------------------------------------------------------------------------
|
||||
#-------------------------------------------------------------------------------
|
||||
# This script creates a tgz archive of the Airtime storage.
|
||||
#
|
||||
# To get usage help, try the -h option
|
||||
#-------------------------------------------------------------------------------
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# Determine directories, files
|
||||
#-------------------------------------------------------------------------------
|
||||
|
||||
reldir=`dirname $0`
|
||||
phpdir=$reldir
|
||||
mkdir -p $reldir/tmp
|
||||
tmpmaindir=`cd $reldir/tmp; pwd`
|
||||
dbxml="db.xml"
|
||||
datestr=`date '+%Y%m%d%H%M%S'`
|
||||
xmltar="xmls.tar"
|
||||
destfile="storage$datestr.tar"
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# Print the usage information for this script.
|
||||
#-------------------------------------------------------------------------------
|
||||
printUsage()
|
||||
{
|
||||
echo "This script creates a tgz archive of the Airtime storage.";
|
||||
echo "parameters:";
|
||||
echo "";
|
||||
echo " -d, --destination Destination directory [default:$tmpmaindir].";
|
||||
echo " -h, --help Print this message and exit.";
|
||||
echo "";
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# Process command line parameters
|
||||
#-------------------------------------------------------------------------------
|
||||
CMD=${0##*/}
|
||||
|
||||
opts=$(getopt -o hd: -l help,destinantion: -n $CMD -- "$@") || exit 1
|
||||
eval set -- "$opts"
|
||||
while true; do
|
||||
case "$1" in
|
||||
-h|--help)
|
||||
printUsage;
|
||||
exit 0;;
|
||||
-d|--destinantion)
|
||||
destdir=$2
|
||||
shift; shift;;
|
||||
--)
|
||||
shift;
|
||||
break;;
|
||||
*)
|
||||
echo "Unrecognized option $1.";
|
||||
printUsage;
|
||||
exit 1;
|
||||
esac
|
||||
done
|
||||
|
||||
if [ "x$destdir" == "x" ]; then
|
||||
destdir=$tmpmaindir
|
||||
fi
|
||||
destdir=`cd $destdir; pwd`
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# Do backup
|
||||
#-------------------------------------------------------------------------------
|
||||
|
||||
tmpdir=`mktemp -d $tmpmaindir/tmp.XXXXXX`
|
||||
|
||||
echo "Backuping to $destdir/$destfile :"
|
||||
echo "Dumping database ..."
|
||||
cd $phpdir
|
||||
php -q airtime_backup.php > $tmpdir/$dbxml
|
||||
echo "Packaging stored files ..."
|
||||
cd $phpdir
|
||||
storpath=`php -q getStorPath.php`
|
||||
cd $storpath/..
|
||||
find stor -name "*.xml" -print | tar cf $tmpdir/$xmltar -T -
|
||||
find stor ! -name "*.xml" -a -type f -print | tar cf $tmpdir/$destfile -T -
|
||||
cd $tmpdir
|
||||
tar rf $xmltar $dbxml --remove-files
|
||||
echo "Compressing XML part ..."
|
||||
bzip2 $xmltar
|
||||
tar rf $destfile $xmltar.bz2 --remove-files
|
||||
mv $destfile "$destdir"
|
||||
rmdir $tmpdir
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# Say goodbye
|
||||
#-------------------------------------------------------------------------------
|
||||
echo "done"
|
||||
|
|
@ -1,194 +0,0 @@
|
|||
<?php
|
||||
define('NSPACE', 'lse');
|
||||
|
||||
header("Content-type: text/plain");
|
||||
require_once('DB.php');
|
||||
require_once("XML/Util.php");
|
||||
require_once("XML/Beautifier.php");
|
||||
require_once(dirname(__FILE__)."/../application/configs/conf.php");
|
||||
require_once(dirname(__FILE__)."/../application/models/BasicStor.php");
|
||||
require_once(dirname(__FILE__)."/../application/models/Prefs.php");
|
||||
|
||||
PEAR::setErrorHandling(PEAR_ERROR_RETURN);
|
||||
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
|
||||
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
|
||||
$bs = new BasicStor();
|
||||
|
||||
$stid = $bs->storId;
|
||||
#var_dump($stid); exit;
|
||||
#$farr = $bs->bsListFolder($stid); var_dump($farr); exit;
|
||||
|
||||
function admDumpFolder(&$bs, $fid, $ind='')
|
||||
{
|
||||
// NOTE: need to fix this, removed due to tree removal
|
||||
// $name = M2tree::GetObjName($fid);
|
||||
// if (PEAR::isError($name)) {
|
||||
// echo $name->getMessage();
|
||||
// exit;
|
||||
// }
|
||||
$media = StoredFile::Recall($fid);
|
||||
$type = $media->getType();
|
||||
$gunid = $media->getGunid();
|
||||
$pars = array();
|
||||
if ($gunid) {
|
||||
$pars['id']="$gunid";
|
||||
}
|
||||
$pars['name'] = "$name";
|
||||
switch ($type) {
|
||||
case "audioclip":
|
||||
return XML_Util::createTagFromArray(array(
|
||||
'namespace' => NSPACE,
|
||||
'localPart' => 'audioClip',
|
||||
'attributes'=> $pars,
|
||||
));
|
||||
break;
|
||||
case "webstream":
|
||||
return XML_Util::createTagFromArray(array(
|
||||
'namespace' => NSPACE,
|
||||
'localPart' => 'webstream',
|
||||
'attributes'=> $pars,
|
||||
));
|
||||
break;
|
||||
case "playlist":
|
||||
return XML_Util::createTagFromArray(array(
|
||||
'namespace' => NSPACE,
|
||||
'localPart' => 'playlist',
|
||||
'attributes'=> $pars,
|
||||
));
|
||||
break;
|
||||
default:
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
function admDumpGroup(&$bs, $gid, $ind='')
|
||||
{
|
||||
$name = Subjects::GetSubjName($gid);
|
||||
if (PEAR::isError($name)) {
|
||||
echo $name->getMessage();
|
||||
exit;
|
||||
}
|
||||
$isGr = Subjects::IsGroup($gid);
|
||||
if (PEAR::isError($isGr)) {
|
||||
echo $isGr->getMessage();
|
||||
exit;
|
||||
}
|
||||
$pars = array('name'=>"$name");
|
||||
$pars['id'] = $gid;
|
||||
if (!$isGr) {
|
||||
return XML_Util::createTagFromArray(array(
|
||||
'namespace' => NSPACE,
|
||||
'localPart' => 'member',
|
||||
'attributes'=> $pars,
|
||||
));
|
||||
}
|
||||
$garr = Subjects::ListGroup($gid);
|
||||
if (PEAR::isError($garr)) {
|
||||
echo $garr->getMessage();
|
||||
exit;
|
||||
}
|
||||
$res = '';
|
||||
foreach ($garr as $i => $member) {
|
||||
$fid2 = $member['id'];
|
||||
$res .= admDumpGroup($bs, $fid2, "$ind ");
|
||||
}
|
||||
$tagarr = array(
|
||||
'namespace' => NSPACE,
|
||||
'localPart' => 'group',
|
||||
'attributes'=> $pars,
|
||||
);
|
||||
$prefs = admDumpPrefs($bs, $gid);
|
||||
if (!is_null($prefs)) {
|
||||
$res .= $prefs;
|
||||
}
|
||||
if ($res) {
|
||||
$tagarr['content'] = $res;
|
||||
}
|
||||
return XML_Util::createTagFromArray($tagarr, $res === '');
|
||||
// if (!$res) {
|
||||
// } else {
|
||||
// return XML_Util::createTagFromArray(array(
|
||||
// 'namespace' => NSPACE,
|
||||
// 'localPart' => 'group',
|
||||
// 'attributes'=> $pars,
|
||||
// 'content' => $res,
|
||||
// ), FALSE);
|
||||
// }
|
||||
|
||||
}
|
||||
function admDumpSubjects(&$bs, $ind='')
|
||||
{
|
||||
$res ='';
|
||||
$subjs = Subjects::GetSubjects('id, login, pass, type');
|
||||
foreach ($subjs as $i => $member) {
|
||||
switch ($member['type']) {
|
||||
case "U":
|
||||
$prefs = admDumpPrefs($bs, $member['id']);
|
||||
$pars = array('login'=>"{$member['login']}", 'pass'=>"{$member['pass']}");
|
||||
$pars['id'] = $member['id'];
|
||||
$tagarr = array(
|
||||
'namespace' => NSPACE,
|
||||
'localPart' => 'user',
|
||||
'attributes'=> $pars,
|
||||
);
|
||||
if (!is_null($prefs)) {
|
||||
$tagarr['content'] = $prefs;
|
||||
}
|
||||
$res .= XML_Util::createTagFromArray($tagarr , FALSE);
|
||||
break;
|
||||
case "G":
|
||||
$res .= admDumpGroup($bs, $member['id'], "$ind ");
|
||||
break;
|
||||
}
|
||||
}
|
||||
# return "$ind<subjects>\n$res$ind</subjects>\n";
|
||||
return XML_Util::createTagFromArray(array(
|
||||
'namespace' => NSPACE,
|
||||
'localPart' => 'subjects',
|
||||
'content'=> $res,
|
||||
), FALSE);
|
||||
}
|
||||
|
||||
function admDumpPrefs(&$bs, $subjid)
|
||||
{
|
||||
$res ='';
|
||||
$pr = new Prefs($bs);
|
||||
$prefkeys = $pr->readKeys($subjid);
|
||||
# var_dump($subjid); var_dump($prefkeys); #exit;
|
||||
foreach ($prefkeys as $i => $prefk) {
|
||||
$keystr = $prefk['keystr'];
|
||||
$prefval = $pr->readVal($subjid, $keystr);
|
||||
$pars = array('name'=>"$keystr", 'val'=>"$prefval");
|
||||
$res .= XML_Util::createTagFromArray(array(
|
||||
'namespace' => NSPACE,
|
||||
'localPart' => 'pref',
|
||||
'attributes'=> $pars,
|
||||
));
|
||||
}
|
||||
if (!$res) {
|
||||
return NULL;
|
||||
}
|
||||
return XML_Util::createTagFromArray(array(
|
||||
'namespace' => NSPACE,
|
||||
'localPart' => 'preferences',
|
||||
'content'=> $res,
|
||||
), FALSE);
|
||||
}
|
||||
|
||||
$subjects = admDumpSubjects($bs, ' ');
|
||||
$tree = admDumpFolder($bs, $stid, ' ');
|
||||
|
||||
$res = XML_Util::getXMLDeclaration("1.0", "UTF-8")."\n";
|
||||
$node = XML_Util::createTagFromArray(array(
|
||||
'namespace' => NSPACE,
|
||||
'localPart' => 'storageServer',
|
||||
'content' => "$subjects$tree",
|
||||
), FALSE);
|
||||
$res .= $node;
|
||||
|
||||
$fmt = new XML_Beautifier();
|
||||
$res = $fmt->formatString($res);
|
||||
|
||||
#var_export($res);
|
||||
#var_dump($res);
|
||||
echo "$res";
|
||||
|
|
@ -1,110 +0,0 @@
|
|||
#!/bin/bash
|
||||
#-------------------------------------------------------------------------------
|
||||
# Copyright (c) 2010 Sourcefabric O.P.S.
|
||||
#
|
||||
# This file is part of the Airtime project.
|
||||
# http://airtime.sourcefabric.org/
|
||||
#
|
||||
# Airtime is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# Airtime is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with Airtime; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
#
|
||||
#-------------------------------------------------------------------------------
|
||||
#-------------------------------------------------------------------------------
|
||||
# This script restores the data which was backed up with airtime-backup.
|
||||
#
|
||||
# To get usage help, try the -h option
|
||||
#-------------------------------------------------------------------------------
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# Determine directories, files
|
||||
#-------------------------------------------------------------------------------
|
||||
|
||||
reldir=`dirname $0`
|
||||
phpdir=$reldir
|
||||
mkdir -p $reldir/tmp
|
||||
tmpmaindir=`cd $reldir/tmp; pwd`
|
||||
dbxml="db.xml"
|
||||
tarfile0="xmls.tar"
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# Print the usage information for this script.
|
||||
#-------------------------------------------------------------------------------
|
||||
printUsage()
|
||||
{
|
||||
echo "This script restores the data which was backed up with airtime-backup."
|
||||
echo "parameters:";
|
||||
echo "";
|
||||
echo " -f, --file File with the backed up data, required.";
|
||||
echo " -h, --help Print this message and exit.";
|
||||
echo "";
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# Process command line parameters
|
||||
#-------------------------------------------------------------------------------
|
||||
CMD=${0##*/}
|
||||
|
||||
opts=$(getopt -o hf: -l help,file -n $CMD -- "$@") || exit 1
|
||||
eval set -- "$opts"
|
||||
while true; do
|
||||
case "$1" in
|
||||
-h|--help)
|
||||
printUsage;
|
||||
exit 0;;
|
||||
-f|--file)
|
||||
tarfile=$2
|
||||
shift; shift;;
|
||||
--)
|
||||
shift;
|
||||
break;;
|
||||
*)
|
||||
echo "Unrecognized option $1.";
|
||||
printUsage;
|
||||
exit 1;
|
||||
esac
|
||||
done
|
||||
|
||||
if [ "x$tarfile" == "x" ]; then
|
||||
echo "Required parameter file not specified.";
|
||||
printUsage;
|
||||
exit 1;
|
||||
fi
|
||||
|
||||
tfdir=`dirname $tarfile`
|
||||
tfdir=`cd $tfdir; pwd`
|
||||
tfbname=`basename $tarfile`
|
||||
tarfile="$tfdir/$tfbname"
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# Do restore
|
||||
#-------------------------------------------------------------------------------
|
||||
|
||||
tmpdir=`mktemp -d $tmpmaindir/tmp.XXXXXX`
|
||||
|
||||
echo "Restoring database from $tarfile ..."
|
||||
cd $tmpdir
|
||||
tar xf $tarfile
|
||||
tar xjf $tarfile0.bz2
|
||||
rm -f $tarfile0.bz2
|
||||
cd $phpdir
|
||||
php -q restore.php $tmpdir/$dbxml $tmpdir
|
||||
rm -rf "$tmpdir/stor"
|
||||
rm -f $tmpdir/*
|
||||
rmdir "$tmpdir"
|
||||
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# Say goodbye
|
||||
#-------------------------------------------------------------------------------
|
||||
echo "done"
|
||||
|
|
@ -1,257 +0,0 @@
|
|||
<?php
|
||||
echo "This file is currently not working. Try again in the next version. :) \n";
|
||||
exit;
|
||||
|
||||
define('NSPACE', 'lse');
|
||||
define('VERBOSE', FALSE);
|
||||
#define('VERBOSE', TRUE);
|
||||
|
||||
header("Content-type: text/plain");
|
||||
require_once 'DB.php';
|
||||
require_once "XML/Util.php";
|
||||
require_once "XML/Beautifier.php";
|
||||
require_once dirname(__FILE__)."/../application/configs/conf.php";
|
||||
require_once dirname(__FILE__)."/../application/models/BasicStor.php";
|
||||
require_once dirname(__FILE__)."/../application/models/Prefs.php";
|
||||
|
||||
/* =========================================================== misc functions */
|
||||
function ls_restore_processObject($el)
|
||||
{
|
||||
$res = array(
|
||||
'name' => $el->attrs['name']->val,
|
||||
'type' => $el->name,
|
||||
);
|
||||
switch ($res['type']) {
|
||||
case 'folder':
|
||||
foreach ($el->children as $i => $o) {
|
||||
$res['children'][] = ls_restore_processObject($o);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
$res['gunid'] = $el->attrs['id']->val;
|
||||
break;
|
||||
}
|
||||
return $res;
|
||||
}
|
||||
|
||||
function ls_restore_checkErr($r, $ln='')
|
||||
{
|
||||
if (PEAR::isError($r)) {
|
||||
echo "ERROR $ln: ".$r->getMessage()." ".$r->getUserInfo()."\n";
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
function ls_restore_restoreObject($obj, /*$parid,*/ $reallyInsert=TRUE){
|
||||
global $tmpdir, $bs;
|
||||
switch ($obj['type']) {
|
||||
case "audioClip";
|
||||
case "webstream";
|
||||
case "playlist";
|
||||
$gunid = $obj['gunid'];
|
||||
if (is_null($gunid)) {
|
||||
break;
|
||||
}
|
||||
$gunid3 = substr($gunid, 0, 3);
|
||||
$mediaFile = "$tmpdir/stor/$gunid3/$gunid";
|
||||
# echo "X1 $gunid, $gunid3, $mediaFile\n";
|
||||
if (!file_exists($mediaFile)) {
|
||||
$mediaFile = NULL;
|
||||
}
|
||||
$mdataFile = "$tmpdir/stor/$gunid3/$gunid.xml";
|
||||
if (!file_exists($mdataFile)) {
|
||||
$mdataFile = NULL;
|
||||
}
|
||||
if ($reallyInsert) {
|
||||
if (VERBOSE) {
|
||||
echo " creating file {$obj['name']} ...\n";
|
||||
}
|
||||
$values = array(
|
||||
"filename" => $obj['name'],
|
||||
"filepath" => $mediaFile,
|
||||
"metadata" => $mdataFile,
|
||||
"gunid" => $obj['gunid'],
|
||||
"filetype" => strtolower($obj['type'])
|
||||
);
|
||||
$r = StoredFile::Insert($values);
|
||||
ls_restore_checkErr($r, __LINE__);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* =============================================================== processing */
|
||||
|
||||
PEAR::setErrorHandling(PEAR_ERROR_RETURN);
|
||||
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
|
||||
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
|
||||
$bs = new BasicStor();
|
||||
$pr = new Prefs($bs);
|
||||
|
||||
$dbxml = file_get_contents($argv[1]);
|
||||
$tmpdir = $argv[2];
|
||||
|
||||
require_once("$STORAGE_SERVER_PATH/var/XmlParser.php");
|
||||
$parser = new XmlParser($dbxml);
|
||||
if ($parser->isError()) {
|
||||
return PEAR::raiseError(
|
||||
"MetaData::parse: ".$parser->getError()
|
||||
);
|
||||
}
|
||||
$xmlTree = $parser->getTree();
|
||||
|
||||
|
||||
/* ----------------------------------------- processing storageServer element */
|
||||
$subjArr = FALSE;
|
||||
//$tree = FALSE;
|
||||
foreach ($xmlTree->children as $i => $el) {
|
||||
switch ($el->name) {
|
||||
case "subjects":
|
||||
if ($subjArr !== FALSE) {
|
||||
echo "ERROR: unexpected subjects element\n";
|
||||
}
|
||||
$subjArr = $el->children;
|
||||
break;
|
||||
// case "folder":
|
||||
// if ($tree !== FALSE) {
|
||||
// echo "ERROR: unexpected folder element\n";
|
||||
// }
|
||||
// $tree = ls_restore_processObject($el);
|
||||
// break;
|
||||
default:
|
||||
echo "ERROR: unknown element name {$el->name}\n";
|
||||
exit;
|
||||
}
|
||||
// echo "{$el->name}\n";
|
||||
}
|
||||
|
||||
/* ---------------------------------------------- processing subjects element */
|
||||
$subjects = array();
|
||||
$groups = array();
|
||||
foreach ($subjArr as $i => $el) {
|
||||
switch ($el->name) {
|
||||
case "group":
|
||||
$grname = $el->attrs['name']->val;
|
||||
$groups[$grname] = $el->children;
|
||||
$subjects[$grname] = array(
|
||||
'type' => 'group',
|
||||
);
|
||||
break;
|
||||
case "user":
|
||||
$login = $el->attrs['login']->val;
|
||||
$subjects[$login] = array(
|
||||
'type' => 'user',
|
||||
'pass' => $el->attrs['pass']->val,
|
||||
# 'realname' => $el->attrs['realname']->val,
|
||||
'realname' => '',
|
||||
'prefs' => (isset($el->children[0]) ? $el->children[0]->children : NULL),
|
||||
);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------- processing groups */
|
||||
foreach ($groups as $grname => $group) {
|
||||
foreach ($group as $i => $el) {
|
||||
switch ($el->name) {
|
||||
case "member":
|
||||
$groups[$grname][$i] = $el->attrs['name']->val;
|
||||
break;
|
||||
case "preferences":
|
||||
$subjects[$grname]['prefs'] = $el->children;
|
||||
unset($groups[$grname][$i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#var_dump($xmlTree);
|
||||
#var_dump($subjArr);
|
||||
#var_dump($groups);
|
||||
#var_dump($subjects);
|
||||
#var_dump($tree);
|
||||
|
||||
#exit;
|
||||
|
||||
/* ================================================================ restoring */
|
||||
|
||||
if (VERBOSE) {
|
||||
echo " resetting storage ...\n";
|
||||
}
|
||||
$bs->resetStorage(FALSE);
|
||||
$storId = $bs->storId;
|
||||
|
||||
/* ------------------------------------------------------- restoring subjects */
|
||||
foreach ($subjects as $login => $subj) {
|
||||
$uid0 = Subjects::GetSubjId($login);
|
||||
ls_restore_checkErr($uid0);
|
||||
switch ($subj['type']) {
|
||||
case "user":
|
||||
if ($login=='root') {
|
||||
$r = $bs->passwd($login, NULL, $subj['pass'], TRUE);
|
||||
ls_restore_checkErr($r, __LINE__);
|
||||
$uid = $uid0;
|
||||
} else {
|
||||
if (!is_null($uid0)) {
|
||||
$r = $bs->removeSubj($login);
|
||||
ls_restore_checkErr($r, __LINE__);
|
||||
}
|
||||
if (VERBOSE) {
|
||||
echo " adding user $login ...\n";
|
||||
}
|
||||
$uid = BasicStor::addSubj($login, $subj['pass'], $subj['realname'], TRUE);
|
||||
ls_restore_checkErr($uid, __LINE__);
|
||||
}
|
||||
break;
|
||||
case "group":
|
||||
if (!is_null($uid0)) {
|
||||
$r = $bs->removeSubj($login);
|
||||
if (PEAR::isError($r)) {
|
||||
$uid = $uid0;
|
||||
break;
|
||||
}
|
||||
//ls_restore_checkErr($r, __LINE__);
|
||||
}
|
||||
if (VERBOSE) {
|
||||
echo " adding group $login ...\n";
|
||||
}
|
||||
$uid = BasicStor::addSubj($login, NULL);
|
||||
ls_restore_checkErr($uid, __LINE__);
|
||||
// var_export($uid); echo " ";
|
||||
break;
|
||||
} // switch
|
||||
|
||||
// echo "$login/$uid :\n";
|
||||
if (isset($subj['prefs'])) {
|
||||
// var_dump($subj['prefs']); exit;
|
||||
foreach ($subj['prefs'] as $i => $el) {
|
||||
switch ($el->name) {
|
||||
case "pref":
|
||||
$prefkey = $el->attrs['name']->val;
|
||||
$prefval = $el->attrs['val']->val;
|
||||
// echo" PREF($prefkey)=$prefval\n";
|
||||
$res = $pr->insert($uid, $prefkey, $prefval);
|
||||
ls_restore_checkErr($res, __LINE__);
|
||||
break;
|
||||
default:
|
||||
var_dump($el);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------- restoring groups */
|
||||
#var_dump($groups);
|
||||
foreach ($groups as $grname => $group) {
|
||||
foreach ($group as $i => $login) {
|
||||
if (VERBOSE) {
|
||||
echo " adding subject $login to group $grname ...\n";
|
||||
}
|
||||
$r = Subjects::AddSubjectToGroup($login, $grname);
|
||||
ls_restore_checkErr($r, __LINE__);
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------- restoring objects */
|
||||
ls_restore_restoreObject($tree, /*$storId,*/ FALSE);
|
||||
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
<?php
|
||||
/**
|
||||
* Do database restore in background. - command line php application
|
||||
*
|
||||
* required command line parameters:
|
||||
* @param 1. backup file
|
||||
* @param 2. status file
|
||||
* @param 3. token
|
||||
* @param 4. sessid
|
||||
*
|
||||
*/
|
||||
|
||||
require_once(dirname(__FILE__).'/../application/configs/conf.php');
|
||||
require_once(dirname(__FILE__).'/../application/models/GreenBox.php');
|
||||
require_once(dirname(__FILE__).'/../application/models/Restore.php');
|
||||
include_once('DB.php');
|
||||
|
||||
PEAR::setErrorHandling(PEAR_ERROR_RETURN);
|
||||
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
|
||||
if (DB::isError($CC_DBC)) {
|
||||
die($CC_DBC->getMessage());
|
||||
}
|
||||
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
|
||||
|
||||
$gb = new GreenBox();
|
||||
$rs = new Restore($gb);
|
||||
|
||||
if ($rs->loglevel=='debug') {
|
||||
$rs->addLogItem('argv:'.print_r($argv,true));
|
||||
}
|
||||
|
||||
$backupfile = $argv[1];
|
||||
$token = $argv[3];
|
||||
$sessid = $argv[4];
|
||||
$rs->startRestore($backupfile,$token,$sessid);
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue