Congegni/sintonia
7
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

CC-1695 Remove Campcaster Studio and make install easier

Browse source
This commit is contained in:
paul.baranowski 2010-09-30 15:46:44 -04:00
parent 89a138b5f8
commit 81d499060b
478 changed files with 63037 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

12
3rd_party/storageServer/.htaccess vendored
View file

@ -1,12 +0,0 @@
DirectoryIndex index.php
Options +FollowSymLinks -Indexes
<IfModule mod_mime.c>
<IfModule mod_php4.c>
AddType application/x-httpd-php .php
php_flag magic_quotes_gpc On
php_flag register_globals Off
</IfModule>
</IfModule>

90
3rd_party/storageServer/bin/autogen.sh vendored
View file

@ -1,90 +0,0 @@
#!/bin/bash
#-------------------------------------------------------------------------------
# Copyright (c) 2010 Sourcefabric O.P.S.
#
# This file is part of the Campcaster project.
# http://campcaster.sourcefabric.org/
# To report bugs, send an e-mail to bugs@campware.org
#
# Campcaster 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.
#
# Campcaster 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 Campcaster; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# Run this to set up the build system: configure, makefiles, etc.
# (based on the version in enlightenment's cvs)
#-------------------------------------------------------------------------------
package="StorageServer"
# assume we're in $basedir/bin
reldir=`dirname $0`/..
basedir=`cd $reldir; pwd;`
test -z "$basedir" && basedir=.
bindir=$basedir/bin
etcdir=$basedir/etc
tmpdir=$basedir/tmp
cd "$tmpdir"
DIE=0
(autoheader --version) < /dev/null > /dev/null 2>&1 || {
echo
echo "You must have autoconf installed to compile $package."
echo "Download the appropriate package for your distribution,"
echo "or get the source tarball at ftp://ftp.gnu.org/pub/gnu/"
DIE=1
}
(autoconf --version) < /dev/null > /dev/null 2>&1 || {
echo
echo "You must have autoconf installed to compile $package."
echo "Download the appropriate package for your distribution,"
echo "or get the source tarball at ftp://ftp.gnu.org/pub/gnu/"
DIE=1
}
if test "$DIE" -eq 1; then
exit 1
fi
if test -z "$*"; then
echo "I am going to run ./configure with no arguments - if you wish "
echo "to pass any to it, please specify them on the $0 command line."
fi
echo "Generating configuration files for $package, please wait...."
configure_ac=${etcdir}/configure.ac
configure=${tmpdir}/configure
aclocal_m4=${tmpdir}/aclocal.m4
# copy over configure.ac and acinlclude.m4 from etc to tmp,
# as aclocal >= 1.8 is sooo unbelivably stupid that it will simply try to
# look for configure.ac in the current directory, and include acinclude.m4
# in aclocal.m4 it without a directory path in front
#ACLOCAL_FLAGS="-I ${tmpdir} --acdir=${tmpdir} --output=${aclocal_m4}"
#echo " aclocal $ACLOCAL_FLAGS"
#cp -f ${configure_ac} ${tmpdir}
#cp -f ${etcdir}/acinclude.m4 ${tmpdir}
#aclocal $ACLOCAL_FLAGS
#echo " autoheader ${configure_ac}"
#autoheader ${configure_ac}
echo " autoconf -I ${tmpdir} -o ${configure} ${configure_ac}"
autoconf -I ${tmpdir} -o ${configure} ${configure_ac}

32
3rd_party/storageServer/bin/runPhpTest.sh vendored
View file

@ -1,32 +0,0 @@
#!/bin/bash
#-------------------------------------------------------------------------------
# Copyright (c) 2010 Sourcefabric O.P.S.
#
# This file is part of the Campcaster project.
# http://campcaster.sourcefabric.org/
# To report bugs, send an e-mail to bugs@campware.org
#
# Campcaster 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.
#
# Campcaster 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 Campcaster; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#
#-------------------------------------------------------------------------------
reldir=`dirname $0`/..
cd $reldir/var/tests
php -q $1 || exit $?
exit 0

31
3rd_party/storageServer/bin/xrCli.sh vendored
View file

@ -1,31 +0,0 @@
#!/bin/bash
#-------------------------------------------------------------------------------
# Copyright (c) 2010 Sourcefabric O.P.S.
#
# This file is part of the Campcaster project.
# http://campcaster.sourcefabric.org/
# To report bugs, send an e-mail to bugs@campware.org
#
# Campcaster 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.
#
# Campcaster 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 Campcaster; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# XMLRPC test client call
#-------------------------------------------------------------------------------
reldir=`dirname $0`/..
cd $reldir/var/xmlrpc
php -q ./xr_cli_test.php $*

47
3rd_party/storageServer/configure vendored
View file

@ -1,47 +0,0 @@
#!/bin/sh
#-------------------------------------------------------------------------------
# Copyright (c) 2010 Sourcefabric O.P.S.
#
# This file is part of the Campcaster project.
# http://campcaster.campware.org/
#
# Campcaster 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.
#
# Campcaster 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 Campcaster; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# Run this script to configure the environment.
#
# This script in effect calls the real automake / autoconf configure script
#-------------------------------------------------------------------------------
# assume we're in $basedir
reldir=`dirname $0`
basedir=`cd $reldir; pwd;`
test -z "$basedir" && basedir=.
bindir=$basedir/bin
tmpdir=$basedir/tmp
autogen=$bindir/autogen.sh
configure=$tmpdir/configure
if [ ! -x $configure ]; then
(cd $basedir && $autogen $*)
fi
(cd $tmpdir && $configure $*)

30
3rd_party/storageServer/doc/index.html vendored
View file

@ -1,30 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta content="text/html; charset=UTF-8" http-equiv="content-type">
<title>storageServer documentation</title>
</head>
<body>
<h1>Preface</h1>
This document is part of the
<a href="http://campcaster.sourcefabric.org/">Campcaster</a>
project, Copyright © 2010 Sourcefabric O.P.S., under the GNU <a
href="http://www.gnu.org/licenses/gpl.html">GPL</a>.<br>
<h1>Scope</h1>
This document collects storageServer documentation, both
generated and handwritten.<br>
<h1>Introduction</h1>
The links below provide useful documentation for the storageServer
developer or user.<br>
<h1>Static documentation.</h1>
<ul>
<!-- <li> <a href=".html"></a></li>-->
</ul>
<h1>Generated documentation</h1>
<ul>
<li><a href="doxygen/html/index.html">documentation generated from the source
code</a></li>
</ul>
<br>
</body>
</html>

259
3rd_party/storageServer/etc/Makefile.in vendored
View file

@ -1,259 +0,0 @@
#-------------------------------------------------------------------------------
# StorageServer - file storage component
# Copyright (c) 2010 Sourcefabric O.P.S.
#
# This file is part of the Campcaster project.
#
# Campcaster 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.
#
# Campcaster 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 Campcaster; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# @configure_input@
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# General command definitions
#-------------------------------------------------------------------------------
SHELL = /bin/bash
MKDIR = mkdir -p
RM = rm -f
RMDIR = rm -rf
DOXYGEN = doxygen
CP = cp -rP
SED = sed
ECHO = echo
CAT = cat
PHP = php
#-------------------------------------------------------------------------------
# Misc
#-------------------------------------------------------------------------------
MODULE_NAME = storageServer
TAR_C = tar -cj --exclude .svn --exclude '*~' -C ${BASE_DIR} -f
DIST_EXT = .tgz
DATE = `date +%y%m%d`
#-------------------------------------------------------------------------------
# Basic directory and file definitions
#-------------------------------------------------------------------------------
#BASE_DIR = @builddir@
BASE_DIR = .
BIN_DIR = ${BASE_DIR}/bin
DOC_DIR = ${BASE_DIR}/doc
DOXYGEN_DIR = ${DOC_DIR}/doxygen
ETC_DIR = ${BASE_DIR}/etc
INCLUDE_DIR = ${BASE_DIR}/include
LIB_DIR = ${BASE_DIR}/lib
SRC_DIR = ${BASE_DIR}/src
TMP_DIR = ${BASE_DIR}/tmp
VAR_DIR = ${BASE_DIR}/var
prefix = @prefix@
USR_DIR = ${prefix}
USR_INCLUDE_DIR = ${USR_DIR}/include
USR_LIB_DIR = ${USR_DIR}/lib
USR_VAR_DIR = ${USR_DIR}/var
DOXYGEN_CONFIG = ${ETC_DIR}/doxygen.config
PHP_DIR = ${VAR_DIR}
INSTALL_DIR = ${PHP_DIR}/install
STOR_DIR = ${PHP_DIR}/stor
ACCESS_DIR = ${PHP_DIR}/access
TRANS_DIR = ${PHP_DIR}/trans
BUFF_DIR = ${STOR_DIR}/buffer
TEST_RUNNER = ${PHP_DIR}/xmlrpc/testRunner.sh
DEST_DIR = ${USR_VAR_DIR}/Campcaster/storageServer
DEST_VAR_DIR = ${DEST_DIR}/var
DEST_BIN_DIR = ${DEST_DIR}/bin
HOSTNAME = @HOSTNAME@
APACHE_GROUP = @APACHE_GROUP@
WWW_PORT = @WWW_PORT@
DB_SERVER = @DB_SERVER@
DATABASE = @DATABASE@
DB_USER = @DB_USER@
DB_PASSWORD = @DB_PASSWORD@
SCHEDULER_PORT = @SCHEDULER_PORT@
WWW_DOCROOT = @WWW_DOCROOT@
PHP_URL_PREFIX = @URL_PREFIX@
SCHEDULER_URL_PREFIX =
SCHEDULER_XML_RPC_PREFIX = RC2
USR_LIB_DIR_S=$(shell ${ECHO} ${USR_LIB_DIR} | ${SED} -e "s/\//\\\\\\\\\//g")
PHP_URL_PREFIX_S=$(shell ${ECHO} ${PHP_URL_PREFIX} | ${SED} -e "s/\//\\\\\\\\\//g")
REPLACE_SED_STRING="s/ls_lib_dir/${USR_LIB_DIR_S}/; \
s/ls_dbuser/${DB_USER}/; \
s/ls_dbpassword/${DB_PASSWORD}/; \
s/ls_dbserver/${DB_SERVER}/; \
s/ls_database/${DATABASE}/; \
s/ls_apache_group/${APACHE_GROUP}/; \
s/ls_storageUrlPath/\/${PHP_URL_PREFIX_S}\/storageServer\/var/; \
s/ls_php_host/${HOSTNAME}/; \
s/ls_php_port/${WWW_PORT}/; \
s/ls_archiveUrlPath/\/${PHP_URL_PREFIX_S}\/archiveServer\/var/; \
s/ls_scheduler_urlPrefix/${SCHEDULER_URL_PREFIX}/; \
s/ls_scheduler_xmlRpcPrefix/${SCHEDULER_XML_RPC_PREFIX}/; \
s/ls_scheduler_host/${HOSTNAME}/; \
s/ls_scheduler_port/${SCHEDULER_PORT}/;"
#-------------------------------------------------------------------------------
# Configuration parameters
#-------------------------------------------------------------------------------
#CPPFLAGS = @CPPFLAGS@
#CXXFLAGS = @CXXFLAGS@ @DEFS@ -I${USR_INCLUDE_DIR} -I${INCLUDE_DIR} -I${TMP_DIR}\
# -pedantic -Wall
#LDFLAGS = @LDFLAGS@ -L${USR_LIB_DIR} -L${LIB_DIR}
#-------------------------------------------------------------------------------
# Dependencies
#-------------------------------------------------------------------------------
#HELLO_LIB_OBJS = ${TMP_DIR}/Hello.o
#TEST_RUNNER_OBJS = ${TMP_DIR}/HelloTest.o ${TMP_DIR}/TestRunner.o
#-------------------------------------------------------------------------------
# Targets
#-------------------------------------------------------------------------------
.PHONY: all dir_setup doc clean docclean depclean distclean dist install
.PHONY: db_init db_clean testonly transtest storage reset
.PHONY: copy_files create_database init_database
all:
doc:
${DOXYGEN} ${DOXYGEN_CONFIG}
clean: db_clean
${RMDIR} ${STOR_DIR}
${RMDIR} ${ACCESS_DIR}
${RMDIR} ${TRANS_DIR}
docclean:
${RMDIR} ${DOXYGEN_DIR}/html
depclean: clean
dist:
${TAR_C} ${MODULE_NAME}${DATE}${DIST_EXT} *
distclean: clean docclean
testonly: ${TEST_RUNNER}
${TEST_RUNNER}
check: all testonly
install: copy_files create_database init_database
copy_files:
${MKDIR} ${DEST_DIR}
${MKDIR} ${DEST_VAR_DIR}
${MKDIR} ${DEST_BIN_DIR}
${MKDIR} ${DEST_VAR_DIR}/access
${MKDIR} ${DEST_VAR_DIR}/cron
${MKDIR} ${DEST_VAR_DIR}/install
${MKDIR} ${DEST_VAR_DIR}/install/upgrade
${MKDIR} ${DEST_VAR_DIR}/stor
${MKDIR} ${DEST_VAR_DIR}/stor/buffer
${MKDIR} ${DEST_VAR_DIR}/trans
${MKDIR} ${DEST_VAR_DIR}/xmlrpc
${CP} ${VAR_DIR}/*.{php,xml} ${DEST_VAR_DIR}
${CP} ${VAR_DIR}/cron/*.php ${DEST_VAR_DIR}/cron
${CP} ${VAR_DIR}/install/*.php \
${DEST_VAR_DIR}/install
${CP} ${VAR_DIR}/install/upgrade/*.php \
${DEST_VAR_DIR}/install/upgrade
${CP} ${VAR_DIR}/xmlrpc/*.php \
${DEST_VAR_DIR}/xmlrpc
${CAT} ${VAR_DIR}/conf.php.template | ${SED} -e ${REPLACE_SED_STRING} \
> ${DEST_VAR_DIR}/conf.php
${CP} ${BIN_DIR}/backup.sh ${BIN_DIR}/restore.php \
${DEST_BIN_DIR}
chgrp ${APACHE_GROUP} ${DEST_VAR_DIR}/access
chgrp ${APACHE_GROUP} ${DEST_VAR_DIR}/stor
chgrp ${APACHE_GROUP} ${DEST_VAR_DIR}/stor/buffer
chgrp ${APACHE_GROUP} ${DEST_VAR_DIR}/trans
chmod g+sw ${DEST_VAR_DIR}/access
chmod g+sw ${DEST_VAR_DIR}/stor
chmod g+sw ${DEST_VAR_DIR}/stor/buffer
chmod g+sw ${DEST_VAR_DIR}/trans
${RM} ${WWW_DOCROOT}/${PHP_URL_PREFIX}
ln -sf ${USR_VAR_DIR}/Campcaster ${WWW_DOCROOT}/${PHP_URL_PREFIX}
create_database:
ifeq (@CREATE_LS_DATABASE@,yes)
${BIN_DIR}/createDatabase.sh --database=${DATABASE} \
--dbserver=${DB_SERVER} \
--dbuser=${DB_USER} \
--dbpassword=${DB_PASSWORD}
endif
init_database:
ifeq (@INIT_LS_DATABASE@,yes)
-cd ${DEST_VAR_DIR}/install && ${PHP} -q install.php
endif
recheck: clean check
#-------------------------------------------------------------------------------
# Specific targets
#-------------------------------------------------------------------------------
storage: db_init dir_setup
storagecheck: storage testonly
dir_setup:
bin/setupDirs.sh ${STOR_DIR} ${ACCESS_DIR} ${TRANS_DIR} ${BUFF_DIR}
db_init:
-cd var/install && php -q install.php
chgrp ${APACHE_GROUP} ${STOR_DIR} ${ACCESS_DIR} ${TRANS_DIR} ${BUFF_DIR}
chmod g+sw ${STOR_DIR} ${ACCESS_DIR} ${TRANS_DIR} ${BUFF_DIR}
db_clean:
-cd var/install && php -q uninstall.php
reset:
./bin/resetStorage.sh
transtest:
./var/tests/transTest.sh
# cd var/tests; php -q transTest.php
${TMP_DIR}:
${MKDIR} ${TMP_DIR}
${DOXYGEN_DIR}:
${MKDIR} ${DOXYGEN_DIR}
${TEST_RUNNER}:
#-------------------------------------------------------------------------------
# Pattern rules
#-------------------------------------------------------------------------------
#${TMP_DIR}/%.o : ${SRC_DIR}/%.cxx
# ${CXX} ${CPPFLAGS} ${CXXFLAGS} -c -o $@ $<

220
3rd_party/storageServer/etc/configure.ac vendored
View file

@ -1,220 +0,0 @@
dnl-----------------------------------------------------------------------------
dnl Copyright (c) 2010 Sourcefabric O.P.S.
dnl
dnl This file is part of the Campcaster project.
dnl http://campcaster.sourcefabric.org/
dnl
dnl Campcaster is free software; you can redistribute it and/or modify
dnl it under the terms of the GNU General Public License as published by
dnl the Free Software Foundation; either version 2 of the License, or
dnl (at your option) any later version.
dnl
dnl Campcaster is distributed in the hope that it will be useful,
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
dnl GNU General Public License for more details.
dnl
dnl You should have received a copy of the GNU General Public License
dnl along with Campcaster; if not, write to the Free Software
dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
dnl
dnl-----------------------------------------------------------------------------
dnl-----------------------------------------------------------------------------
dnl NOTE: Run all configure related scripts from the tmp directory of the
dnl project.
dnl This is due to the fact that configure spreads a lot of trash around,
dnl like atom4te cache directories, config.* files, etc. into the directory
dnl it is being run from. We clearly don't want these in our base directory.
dnl-----------------------------------------------------------------------------
AC_INIT(StorageServer, 0.0, bugs@campware.org)
AC_PREREQ(2.59)
AC_COPYRIGHT([Copyright (c) 2010 Sourcefabric O.P.S. under the GNU GPL])
AC_REVISION($Revision$)
AC_CONFIG_SRCDIR(../var/BasicStor.php)
dnl-----------------------------------------------------------------------------
dnl specify wether the Campcaster database and user should be created
dnl-----------------------------------------------------------------------------
AC_SUBST(CREATE_LS_DATABASE)
AC_ARG_WITH([create-database],
AC_HELP_STRING([--with-create-database],
[specify wether the Campcaster database and database user
should be created (no)]),
[CREATE_LS_DATABASE=${withval}],
[CREATE_LS_DATABASE=no])
AC_MSG_RESULT([creating Campcaster database: ${CREATE_LS_DATABASE}])
dnl-----------------------------------------------------------------------------
dnl specify wether the Campcaster database tables should be initialized
dnl-----------------------------------------------------------------------------
AC_SUBST(INIT_LS_DATABASE)
AC_ARG_WITH([init-database],
AC_HELP_STRING([--with-init-database],
[specify wether the Campcaster database tables should be
initialized (no)]),
[INIT_LS_DATABASE=${withval}],
[INIT_LS_DATABASE=no])
AC_MSG_RESULT([initializing Campcaster database: ${INIT_LS_DATABASE}])
dnl-----------------------------------------------------------------------------
dnl specify the FQDN
dnl-----------------------------------------------------------------------------
AC_SUBST(HOSTNAME)
AC_ARG_WITH([hostname],
AC_HELP_STRING([--with-hostname],
[use the specified hostname (guess)]),
[HOSTNAME=${withval}], [HOSTNAME=`hostname -f`])
AC_MSG_RESULT([using hostname: ${HOSTNAME}])
dnl-----------------------------------------------------------------------------
dnl specify group in which apache is running
dnl-----------------------------------------------------------------------------
AC_SUBST(APACHE_GROUP)
AC_ARG_WITH([apache-group],
AC_HELP_STRING([--with-apache-group],
[use apache running in the specified group (apache)]),
[APACHE_GROUP=${withval}], [APACHE_GROUP=apache])
AC_MSG_RESULT([using apache group: ${APACHE_GROUP}])
dnl-----------------------------------------------------------------------------
dnl specify the web server port
dnl-----------------------------------------------------------------------------
AC_SUBST(WWW_PORT)
AC_ARG_WITH([www-port],
AC_HELP_STRING([--with-www-port],
[use the specified www port (80)]),
[WWW_PORT=${withval}], [WWW_PORT=80])
AC_MSG_RESULT([using www port: ${WWW_PORT}])
dnl-----------------------------------------------------------------------------
dnl specify the scheduler server port
dnl-----------------------------------------------------------------------------
AC_SUBST(SCHEDULER_PORT)
AC_ARG_WITH([scheduler-port],
AC_HELP_STRING([--with-scheduler-port],
[use the specified scheduler port (3344)]),
[SCHEDULER_PORT=${withval}], [SCHEDULER_PORT=3344])
AC_MSG_RESULT([using scheduler port: ${SCHEDULER_PORT}])
dnl-----------------------------------------------------------------------------
dnl specify the database server name
dnl-----------------------------------------------------------------------------
AC_SUBST(DB_SERVER)
AC_ARG_WITH([database-server],
AC_HELP_STRING([--with-database-server],
[use the specified database server (localhost)]),
[DB_SERVER=${withval}], [DB_SERVER=localhost])
AC_MSG_RESULT([using database server: ${DB_SERVER}])
dnl-----------------------------------------------------------------------------
dnl get the name of the Campcaster database
dnl-----------------------------------------------------------------------------
AC_SUBST(DATABASE)
AC_ARG_WITH([database],
AC_HELP_STRING([--with-database],
[the name of the postgresql database to use (Campcaster)]),
[DATABASE=${withval}], [DATABASE=Campcaster])
AC_MSG_RESULT([using database: ${DATABASE}])
dnl-----------------------------------------------------------------------------
dnl specify the database server user
dnl-----------------------------------------------------------------------------
AC_SUBST(DB_USER)
AC_ARG_WITH([database-user],
AC_HELP_STRING([--with-database-user],
[use the specified database server user (campcaster)]),
[DB_USER=${withval}], [DB_USER=campcaster])
AC_MSG_RESULT([using database server user: ${DB_USER}])
dnl-----------------------------------------------------------------------------
dnl specify the database server user password
dnl-----------------------------------------------------------------------------
AC_SUBST(DB_PASSWORD)
AC_ARG_WITH([database-password],
AC_HELP_STRING([--with-database-password],
[use the specified database server user password (campcaster)]),
[DB_PASSWORD=${withval}], [DB_PASSWORD=campcaster])
AC_MSG_RESULT([using database server user password: ${DB_PASSWORD}])
dnl-----------------------------------------------------------------------------
dnl specify web document root
dnl-----------------------------------------------------------------------------
AC_SUBST(WWW_DOCROOT)
AC_ARG_WITH([www-docroot],
AC_HELP_STRING([--with-www-docroot],
[deploy Campcaster under the specified docroot (/var/www)]),
[WWW_DOCROOT=${withval}], [WWW_DOCROOT=/var/www])
AC_MSG_RESULT([using www document root: ${WWW_DOCROOT}])
dnl-----------------------------------------------------------------------------
dnl specify url prefix
dnl-----------------------------------------------------------------------------
AC_SUBST(URL_PREFIX)
AC_ARG_WITH([url-prefix],
AC_HELP_STRING([--with-url-prefix],
[use the specified url prefix (campcaster)]),
[URL_PREFIX=${withval}], [URL_PREFIX=campcaster])
AC_MSG_RESULT([using url prefix: ${URL_PREFIX}])
dnl display status info on what libraries will get compiled
AC_MSG_NOTICE(
[using the following configuration settings:
hostname: ${HOSTNAME}
www port: ${WWW_PORT}
scheduler port: ${SCHEDULER_PORT}
database server: ${DB_SERVER}
database name: ${DATABASE}
database user: ${DB_USER}
database user password: ${DB_PASSWORD}
creating Campcaster database: ${CREATE_LS_DATABASE}
initialize Campcaster database: ${INIT_LS_DATABASE}
www document root: ${WWW_DOCROOT}
url prefix: ${URL_PREFIX}
])
AC_CONFIG_FILES(../Makefile:../etc/Makefile.in)
AC_OUTPUT()

1140
3rd_party/storageServer/etc/doxygen.config vendored
View file

File diff suppressed because it is too large Load diff

1
3rd_party/storageServer/tmp/.keepme vendored
View file

@ -1 +0,0 @@
keep me

12
3rd_party/storageServer/var/.htaccess vendored
View file

@ -1,12 +0,0 @@
DirectoryIndex index.php
Options +FollowSymLinks -Indexes
<IfModule mod_mime.c>
<IfModule mod_php4.c>
AddType application/x-httpd-php .php
php_flag magic_quotes_gpc On
php_flag register_globals Off
</IfModule>
</IfModule>

184
3rd_party/storageServer/var/AccessRecur.php vendored
View file

@ -1,184 +0,0 @@
<?
/**
* AccessRecur class
*
* Handles recursive accessPlaylist/releasePlaylist.
* Should be 'required_once' from LocStor.php only.
*
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*/
class AccessRecur {
public $ls;
public $sessid;
public function __construct(&$ls, $sessid)
{
$this->ls =& $ls;
$this->sessid = $sessid;
}
public static function accessPlaylist(&$ls, $sessid, $plid, $parent='0')
{
$ppa = new AccessRecur($ls, $sessid);
$r = $ls->accessPlaylist($sessid, $plid, FALSE, $parent);
if (PEAR::isError($r)) {
return $r;
}
$plRes = $r;
$r = StoredFile::RecallByGunid($plid);
if (is_null($r) || PEAR::isError($r)) {
return $r;
}
$ac = $r;
$r = $ac->md->genPhpArray();
if (PEAR::isError($r)) {
return $r;
}
$pla = $r;
$r = $ppa->processPlaylist($pla, $plRes['token']);
if (PEAR::isError($r)) {
return $r;
}
$plRes['content'] = $r;
return $plRes;
}
public static function releasePlaylist(&$ls, $sessid, $token)
{
global $CC_CONFIG, $CC_DBC;
$ppa = new AccessRecur($ls, $sessid);
$r = $CC_DBC->getAll("
SELECT to_hex(token)as token2, to_hex(gunid)as gunid
FROM ".$CC_CONFIG['accessTable']."
WHERE parent=x'{$token}'::bigint
");
if (PEAR::isError($r)) {
return $r;
}
$arr = $r;
foreach ($arr as $i => $item) {
extract($item); // token2, gunid
$r = BasicStor::GetType($gunid);
if (PEAR::isError($r)) {
return $r;
}
$ftype = $r;
# echo "$ftype/$token2\n";
switch (strtolower($ftype)) {
case "audioclip":
$r = $ppa->ls->releaseRawAudioData($ppa->sessid, $token2);
if (PEAR::isError($r)) {
return $r;
}
# var_dump($r);
break;
case "playlist":
$r = $ppa->releasePlaylist($ppa->ls, $ppa->sessid, $token2);
if (PEAR::isError($r)) {
return $r;
}
# var_dump($r);
break;
default:
}
}
$r = $ppa->ls->releasePlaylist($ppa->sessid, $token, FALSE);
if (PEAR::isError($r)) {
return $r;
}
return $r;
}
private function processPlaylist($pla, $parent)
{
$res = array();
foreach ($pla['children'] as $ple) {
switch ($ple['elementname']) {
case "playlistElement":
$r = $this->processPlaylistElement($ple, $parent);
if (PEAR::isError($r)) {
return $r;
}
// $res = array_merge($res, $r);
$res[] = $r;
break;
default:
}
}
return $res;
}
private function processAudioClip($gunid, $parent)
{
$r = $this->ls->accessRawAudioData($this->sessid, $gunid, $parent);
if (PEAR::isError($r)) {
return $r;
}
return $r;
}
private function processPlaylistElement($ple, $parent='0')
{
foreach ($ple['children'] as $ac) {
switch ($ac['elementname']) {
case "audioClip":
$r = $this->processAudioClip($ac['attrs']['id'], $parent);
if (PEAR::isError($r)) {
return $r;
}
return $r;
case "playlist":
// if(empty($ac['children'])){
$r = $this->accessPlaylist($this->ls, $this->sessid,
$ac['attrs']['id'], $parent);
if (PEAR::isError($r)) {
if ($r->getCode() != GBERR_NOTF) {
return $r;
} else {
$r = $this->processPlaylist($ac, $parent);
if (PEAR::isError($r)) {
return $r;
}
$r = array(
'content' => $r,
'url' => NULL,
'token' => NULL,
'chsum' => NULL,
'size' => NULL,
'warning' => 'inline playlist?',
);
}
}
return $r;
/*
}else{
$r = $this->processPlaylist($ac, $parent);
if(PEAR::isError($r)) return $r;
$res = array(
'content' => $r,
'url' => NULL,
'token' => NULL,
'chsum' => NULL,
'size' => NULL,
'warning' => 'inline playlist',
);
return $res;
}
*/
break;
default:
}
}
return array();
}
} // class AccessRecur
?>

622
3rd_party/storageServer/var/Alib.php vendored
View file

@ -1,622 +0,0 @@
<?php
require_once('Subjects.php');
define('USE_ALIB_CLASSES', TRUE);
define('ALIBERR_NOTLOGGED', 30);
define('ALIBERR_NOTEXISTS', 31);
/**
* Authentication/authorization class
*
* @package Campcaster
* @subpackage Alib
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*/
class Alib {
/* ======================================================= public methods */
/* ----------------------------------------------- session/authentication */
/**
* Authenticate and create session
*
* @param string $login
* @param string $pass
* @return boolean|sessionId|PEAR_Error
*/
public static function Login($login, $pass)
{
global $CC_CONFIG, $CC_DBC;
if (FALSE === Subjects::Authenticate($login, $pass)) {
Subjects::SetTimeStamp($login, TRUE);
return FALSE;
}
$sessid = Alib::_createSessid();
if (PEAR::isError($sessid)) {
return $sessid;
}
$userid = Subjects::GetSubjId($login);
$sql = "INSERT INTO ".$CC_CONFIG['sessTable']." (sessid, userid, login, ts)"
." VALUES('$sessid', '$userid', '$login', now())";
$r = $CC_DBC->query($sql);
if (PEAR::isError($r)) {
return $r;
}
Subjects::SetTimeStamp($login, FALSE);
return $sessid;
} // fn login
/**
* Logout and destroy session
*
* @param string $sessid
* @return true|PEAR_Error
*/
public static function Logout($sessid)
{
global $CC_CONFIG, $CC_DBC;
$ct = Alib::CheckAuthToken($sessid);
if ($ct === FALSE) {
return PEAR::raiseError("Alib::logout: not logged ($sessid)",
ALIBERR_NOTLOGGED, PEAR_ERROR_RETURN);
} elseif (PEAR::isError($ct)) {
return $ct;
} else {
$sql = "DELETE FROM ".$CC_CONFIG['sessTable']
." WHERE sessid='$sessid'";
$r = $CC_DBC->query($sql);
if (PEAR::isError($r)) {
return $r;
}
return TRUE;
}
} // fn logout
/**
* Return true if the token is valid
*
* @param string $sessid
* @return boolean|PEAR_Error
*/
private static function CheckAuthToken($sessid)
{
global $CC_CONFIG, $CC_DBC;
$sql = "SELECT count(*) as cnt FROM ".$CC_CONFIG['sessTable']
." WHERE sessid='$sessid'";
$c = $CC_DBC->getOne($sql);
return ($c == 1 ? TRUE : (PEAR::isError($c) ? $c : FALSE ));
} //fn checkAuthToken
/**
* Set valid token in alib object
*
* @param string $sessid
* @return TRUE|PEAR_Error
*/
// public function setAuthToken($sessid)
// {
// $r = $this->checkAuthToken($sessid);
// if (PEAR::isError($r)) {
// return $r;
// }
// if (!$r) {
// return PEAR::raiseError("ALib::setAuthToken: invalid token ($sessid)");
// }
// //$this->sessid = $sessid;
// return TRUE;
// } // fn setAuthToken
/* -------------------------------------------------------- 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
*
* @param int $permid
* local permission id
* @param int $subj
* local user/group id
* @param int $obj
* local object id
* @return boolean|PEAR_Error
*/
public static function RemovePerm($permid=NULL, $subj=NULL, $obj=NULL)
{
global $CC_CONFIG, $CC_DBC;
$ca = array();
if ($permid) {
$ca[] = "permid=$permid";
}
if ($subj) {
$ca[] = "subj=$subj";
}
if ($obj) {
$ca[] = "obj=$obj";
}
$cond = join(" AND ", $ca);
if (!$cond) {
return TRUE;
}
$sql = "DELETE FROM ".$CC_CONFIG['permTable']." WHERE $cond";
return $CC_DBC->query($sql);
} // fn removePerm
/**
* Return object related with permission record
*
* @param int $permid
* local permission id
* @return int
* local object id
*/
public static function GetPermOid($permid)
{
global $CC_CONFIG, $CC_DBC;
$sql = "SELECT obj FROM ".$CC_CONFIG['permTable']." WHERE permid=$permid";
$res = $CC_DBC->getOne($sql);
return $res;
} // fn GetPermOid
/**
* Check if specified subject have permission to specified action
* on specified object
*
* Look for sequence of corresponding permissions and order it by
* relevence, then test the most relevant for result.
* High relevence have direct permission (directly for specified subject
* and object. Relevance order is done by level distance in the object
* tree, level distance in subjects (user/group system).
* Similar way is used for permissions related to object classes.
* But class-related permissions have lower priority then
* object-tree-related.
* Support for object classes can be disabled by USE_ALIB_CLASSES const.
*
* @param int $sid
* subject id (user or group id)
* @param string $action
* from set defined in config
* @param int $oid
* object id (default: root node)
* @return boolean|PEAR_Error
*/
public static function CheckPerm($sid, $action, $oid=NULL)
{
return TRUE;
// global $CC_DBC;
// global $CC_CONFIG;
// if (!is_numeric($sid)) {
// return FALSE;
// }
//// if (is_null($oid) or $oid=='') {
//// $oid = M2tree::GetRootNode();
//// }
//// if (PEAR::isError($oid)) {
//// return $oid;
//// }
// if (!is_numeric($oid)) {
// return FALSE;
// }
// // query construction
// // shortcuts:
// // p: permTable,
// // s: subjTable, m smembTable,
// // t: treeTable ts: structTable,
// // c: classTable, cm: cmembTable
// // main query elements:
// $q_flds = "m.level , p.subj, s.login, action, p.type, p.obj";
// $q_from = $CC_CONFIG['permTable']." p ";
// // joins for solving users/groups:
// $q_join = "LEFT JOIN ".$CC_CONFIG['subjTable']." s ON s.id=p.subj ";
// $q_join .= "LEFT JOIN ".$CC_CONFIG['smembTable']." m ON m.gid=p.subj ";
// $q_cond = "p.action in('_all', '$action') AND
// (s.id=$sid OR m.uid=$sid) ";
// // coalesce -1 for higher priority of nongroup rows:
// // action DESC order for lower priority of '_all':
// $q_ordb = "ORDER BY coalesce(m.level,-1), action DESC, p.type DESC";
// $q_flds0 = $q_flds;
// $q_from0 = $q_from;
// $q_join0 = $q_join;
// $q_cond0 = $q_cond;
// $q_ordb0 = $q_ordb;
// // joins for solving object tree:
// $q_flds .= ", t.name, ts.level as tlevel";
// //$q_join .= "LEFT JOIN ".$CC_CONFIG['treeTable']." t ON t.id=p.obj ";
// //$q_join .= "LEFT JOIN ".$CC_CONFIG['structTable']." ts ON ts.parid=p.obj ";
// //$q_cond .= " AND (t.id=$oid OR ts.objid=$oid)";
// // action DESC order is hack for lower priority of '_all':
// $q_ordb = "ORDER BY coalesce(ts.level,0), m.level, action DESC, p.type DESC";
// // query by tree:
// $query1 = "SELECT $q_flds FROM $q_from $q_join WHERE $q_cond $q_ordb";
// $r1 = $CC_DBC->getAll($query1);
// if (PEAR::isError($r1)) {
// return($r1);
// }
// // if there is row with type='A' on the top => permit
// //$AllowedByTree =
// // (is_array($r1) && count($r1)>0 && $r1[0]['type']=='A');
// //$DeniedByTree =
// // (is_array($r1) && count($r1)>0 && $r1[0]['type']=='D');
//
// if (!USE_ALIB_CLASSES) {
// return $AllowedbyTree;
// }
//
// // joins for solving object classes:
// $q_flds = $q_flds0.", c.cname ";
// $q_join = $q_join0."LEFT JOIN ".$CC_CONFIG['classTable']." c ON c.id=p.obj ";
// $q_join .= "LEFT JOIN ".$CC_CONFIG['cmembTable']." cm ON cm.cid=p.obj ";
// $q_cond = $q_cond0." AND (c.id=$oid OR cm.objid=$oid)";
// $q_ordb = $q_ordb0;
// // query by class:
// $query2 = "SELECT $q_flds FROM $q_from $q_join WHERE $q_cond $q_ordb";
// $r2 = $CC_DBC->getAll($query2);
// if (PEAR::isError($r2)) {
// return $r2;
// }
// $AllowedByClass =
// (is_array($r2) && count($r2)>0 && $r2[0]['type']=='A');
// // not used now:
// // $DeniedByClass =
// // (is_array($r2) && count($r2)>0 && $r2[0]['type']=='D');
// $res = ($AllowedByTree || (!$DeniedByTree && $AllowedByClass));
// return $res;
} // fn CheckPerm
/* ---------------------------------------------------------- object tree */
/**
* Remove all permissions on object and then remove object itself
*
* @param int $id
* @return void|PEAR_Error
*/
public static function RemoveObj($id)
{
$r = Alib::RemovePerm(NULL, NULL, $id);
return $r;
} // fn removeObj
/* --------------------------------------------------------- users/groups */
/**
* Remove all permissions of subject and then remove subject itself
*
* @param string $login
* @return void|PEAR_Error
*/
public static function RemoveSubj($login)
{
global $CC_CONFIG, $CC_DBC;
$uid = Subjects::GetSubjId($login);
if (PEAR::isError($uid)) {
return $uid;
}
if (is_null($uid)){
return $CC_DBC->raiseError("Alib::removeSubj: Subj not found ($login)",
ALIBERR_NOTEXISTS, PEAR_ERROR_RETURN);
}
$r = Alib::RemovePerm(NULL, $uid);
if (PEAR::isError($r)) {
return $r;
}
return Subjects::RemoveSubj($login, $uid);
} // fn RemoveSubj
/* ------------------------------------------------------------- sessions */
/**
* Get login from session id (token)
*
* @param string $sessid
* @return string|PEAR_Error
*/
public static function GetSessLogin($sessid)
{
global $CC_CONFIG, $CC_DBC;
$sql = "SELECT login FROM ".$CC_CONFIG['sessTable']." WHERE sessid='$sessid'";
$r = $CC_DBC->getOne($sql);
if (PEAR::isError($r)) {
return $r;
}
if (is_null($r)){
return PEAR::raiseError("Alib::GetSessLogin:".
" invalid session id ($sessid)",
ALIBERR_NOTEXISTS, PEAR_ERROR_RETURN);
}
return $r;
} // fn GetSessLogin
/**
* Get user id from session id.
*
* @param string $p_sessid
* @return int|PEAR_Error
*/
public static function GetSessUserId($p_sessid)
{
global $CC_CONFIG, $CC_DBC;
$sql = "SELECT userid FROM ".$CC_CONFIG['sessTable']." WHERE sessid='$p_sessid'";
$r = $CC_DBC->getOne($sql);
if (PEAR::isError($r)) {
return $r;
}
if (is_null($r)) {
return PEAR::raiseError("Alib::getSessUserId:".
" invalid session id ($p_sessid)",
ALIBERR_NOTEXISTS, PEAR_ERROR_RETURN);
}
return $r;
} // fn getSessUserId
/* --------------------------------------------------------- info methods */
/**
* Get all permissions on object.
*
* @param int $id
* @return array|null|PEAR_Error
*/
public static function GetObjPerms($id)
{
global $CC_CONFIG, $CC_DBC;
$sql = "SELECT s.login, p.* FROM ".$CC_CONFIG['permTable']." p, ".$CC_CONFIG['subjTable']." s"
." WHERE s.id=p.subj AND p.obj=$id";
return $CC_DBC->getAll($sql);
} // fn GetObjPerms
/**
* Get all permissions of subject.
*
* @param int $sid
* @return array
*/
public static function GetSubjPerms($sid)
{
global $CC_CONFIG, $CC_DBC;
$sql = "SELECT *"
." FROM ".$CC_CONFIG['permTable']
." WHERE p.subj=$sid";
// $sql = "SELECT t.name, t.type as otype , p.*"
// ." FROM ".$CC_CONFIG['permTable']." p, ".$CC_CONFIG['treeTable']." t"
// ." WHERE t.id=p.obj AND p.subj=$sid";
$a1 = $CC_DBC->getAll($sql);
return $a1;
} // fn GetSubjPerms
/* ------------------------ info methods related to application structure */
/* (this part should be added/rewritten to allow defining/modifying/using
* application structure)
* (only very simple structure definition - in $CC_CONFIG - supported now)
*/
/**
* Get all actions
*
* @return array
*/
public static function GetAllActions()
{
global $CC_CONFIG;
return $CC_CONFIG['allActions'];
} // fn GetAllActions
/**
* Get all allowed actions on specified object type.
*
* @param string $type
* @return array
*/
public static function GetAllowedActions($type)
{
global $CC_CONFIG;
return $CC_CONFIG['allowedActions'][$type];
} // fn GetAllowedActions
/* ====================================================== private methods */
/**
* Create new session id. Return the new session ID.
*
* @return string
*/
private static function _createSessid()
{
global $CC_CONFIG, $CC_DBC;
for ($c = 1; $c > 0; ){
$sessid = md5(uniqid(rand()));
$sql = "SELECT count(*) FROM ".$CC_CONFIG['sessTable']
." WHERE sessid='$sessid'";
$c = $CC_DBC->getOne($sql);
if (PEAR::isError($c)) {
return $c;
}
}
return $sessid;
} // fn _createSessid
/* =============================================== test and debug methods */
/**
* Dump all permissions for debug
*
* @param string $indstr
* indentation string
* @param string $ind
* actual indentation
* @return string
*/
public static function DumpPerms($indstr=' ', $ind='')
{
global $CC_CONFIG, $CC_DBC;
$sql = "SELECT s.login, p.action, p.type"
." FROM ".$CC_CONFIG['permTable']." p, ".$CC_CONFIG['subjTable']." s"
." WHERE s.id=p.subj"
." ORDER BY p.permid";
$arr = $CC_DBC->getAll($sql);
if (PEAR::isError($arr)) {
return $arr;
}
$r = $ind.join(', ', array_map(create_function('$v',
'return "{$v[\'login\']}/{$v[\'action\']}/{$v[\'type\']}";'
),
$arr
))."\n";
return $r;
} // fn dumpPerms
/**
* Delete everything form the permission table and session table.
*
* @return void
*/
public static function DeleteData()
{
global $CC_CONFIG, $CC_DBC;
$CC_DBC->query("DELETE FROM ".$CC_CONFIG['permTable']);
$CC_DBC->query("DELETE FROM ".$CC_CONFIG['sessTable']);
Subjects::DeleteData();
} // fn deleteData
/**
* Insert test permissions
*
* @return array
*/
public static function TestData()
{
global $CC_CONFIG, $CC_DBC;
$tdata = Subjects::TestData();
$t =& $tdata['tree'];
$c =& $tdata['classes'];
$s =& $tdata['subjects'];
$CC_DBC->setErrorHandling(PEAR_ERROR_PRINT);
$perms = array(
array($s['root'], '_all', $t['root'], 'A'),
array($s['test1'], '_all', $t['pa'], 'A'),
array($s['test1'], 'read', $t['s2b'], 'D'),
array($s['test2'], 'addChilds', $t['pa'], 'D'),
array($s['test2'], 'read', $t['i2'], 'A'),
array($s['test2'], 'edit', $t['s1a'], 'A'),
array($s['test1'], 'addChilds', $t['s2a'], 'D'),
array($s['test1'], 'addChilds', $t['s2c'], 'D'),
array($s['gr2'], 'addChilds', $t['i2'], 'A'),
array($s['test3'], '_all', $t['t1'], 'D'),
);
if (USE_ALIB_CLASSES){
$perms[] = array($s['test3'], 'read', $c['cl_sa'], 'D');
$perms[] = array($s['test4'], 'editPerms', $c['cl2'], 'A');
}
foreach ($perms as $p){
$o[] = $r = Alib::AddPerm($p[0], $p[1], $p[2], $p[3]);
if (PEAR::isError($r)) {
return $r;
}
}
$tdata['perms'] = $o;
return $tdata;
} // fn testData
/**
* Make basic test
*
* @return boolean|PEAR_Error
*/
public static function Test()
{
$p = Subjects::test();
if (PEAR::isError($p)) {
return $p;
}
Alib::DeleteData();
$tdata = Alib::TestData();
if (PEAR::isError($tdata)) {
return $tdata;
}
$test_correct = "root/_all/A, test1/_all/A, test1/read/D,".
" test2/addChilds/D, test2/read/A, test2/edit/A,".
" test1/addChilds/D, test1/addChilds/D, gr2/addChilds/A,".
" test3/_all/D";
if (USE_ALIB_CLASSES){
$test_correct .= ", test3/read/D, test4/editPerms/A";
}
$test_correct .= "\nno, yes\n";
$r = Alib::DumpPerms();
if (PEAR::isError($r)) {
return $r;
}
$test_dump = $r.
(Alib::CheckPerm(
$tdata['subjects']['test1'], 'read',
$tdata['tree']['t1']
)? 'yes':'no').", ".
(Alib::CheckPerm(
$tdata['subjects']['test1'], 'addChilds',
$tdata['tree']['i2']
)? 'yes':'no')."\n"
;
Alib::RemovePerm($tdata['perms'][1]);
Alib::RemovePerm($tdata['perms'][3]);
$test_correct .= "root/_all/A, test1/read/D,".
" test2/read/A, test2/edit/A,".
" test1/addChilds/D, test1/addChilds/D, gr2/addChilds/A,".
" test3/_all/D";
if (USE_ALIB_CLASSES) {
$test_correct .= ", test3/read/D, test4/editPerms/A";
}
$test_correct .= "\n";
$test_dump .= Alib::DumpPerms();
Alib::DeleteData();
if ($test_dump == $test_correct) {
$test_log .= "alib: OK\n";
return TRUE;
} else {
return PEAR::raiseError('Alib::test', 1, PEAR_ERROR_DIE, '%s'.
"<pre>\ncorrect:\n{$test_correct}\n".
"dump:\n{$test_dump}\n</pre>\n");
}
} // fn test
} // class Alib
?>

487
3rd_party/storageServer/var/Backup.php vendored
View file

@ -1,487 +0,0 @@
<?php
define('BACKUP_EXT', 'tar');
define('ACCESS_TYPE', 'backup');
/**
* @package Campcaster
* @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
?>

2346
3rd_party/storageServer/var/BasicStor.php vendored
View file

File diff suppressed because it is too large Load diff

121
3rd_party/storageServer/var/CleanStor.php vendored
View file

@ -1,121 +0,0 @@
<?php
// Do not allow remote execution
$arr = array_diff_assoc($_SERVER, $_ENV);
if (isset($arr["DOCUMENT_ROOT"]) && ($arr["DOCUMENT_ROOT"] != "") ) {
header("HTTP/1.1 400");
header("Content-type: text/plain; charset=UTF-8");
echo "400 Not executable\r\n";
exit(1);
}
require_once('conf.php');
require_once('DB.php');
require_once('install/installInit.php');
require_once ('StoredFile.php');
function printUsage() {
global $CC_CONFIG;
echo "Usage:\n";
echo " ./CleanStor [OPTION] \n";
echo "\n";
echo "Options:\n";
echo " -c, --clean Removes all broken links from the storage server\n";
echo " and empties all missing file information from the database.\n";
echo "\n";
echo " -e, --empty Removes all files from the storage server \n";
echo " and empties all relevant information from the database.\n\n";
echo "Storage server: ". $CC_CONFIG["storageDir"] ."\n\n\n";
}
function camp_clean_files($p_path) {
if (!empty($p_path) && (strlen($p_path) > 4)) {
list($dirList,$fileList) = File_Find::maptree($p_path);
$array_mus;
foreach ($fileList as $filepath) {
if (@substr($filepath, strlen($filepath) - 3) != "xml") {
$array_mus[] = $filepath;
}
}
foreach ($array_mus as $audio_file) {
if (@is_link($audio_file) && !@stat($audio_file)) {
//filesystem clean up.
@unlink($audio_file);
echo "unlinked $audio_file\n";
@unlink($audio_file . ".xml");
echo "unlinked " . $audio_file . ".xml\n";
@rmdir(@dirname($audio_file));
echo "removed dir " . @dirname($audio_file) . "\n";
//database clean up.
$stored_audio_file = StoredFile::RecallByGunid(@basename($audio_file));
$stored_audio_file->delete();
}
}
}
}
function camp_remove_files($p_path) {
if (!empty($p_path) && (strlen($p_path) > 4)) {
list($dirList,$fileList) = File_Find::maptree($p_path);
foreach ($fileList as $filepath) {
echo " * Removing $filepath\n";
@unlink($filepath);
echo "done.\n";
}
foreach ($dirList as $dirpath) {
echo " * Removing $dirpath\n";
@rmdir($dirpath);
echo "done.\n";
}
}
}
function camp_empty_db($db) {
global $CC_CONFIG;
if (!PEAR::isError($db)) {
if (camp_db_table_exists($CC_CONFIG['filesTable'])) {
echo " * Deleting from database table ".$CC_CONFIG['filesTable']."\n";
$sql = "DELETE FROM ".$CC_CONFIG['filesTable'];
camp_install_query($sql, false);
}
else {
echo " * Skipping: database table ".$CC_CONFIG['filesTable']."\n";
}
}
}
global $CC_CONFIG;
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
switch($argv[1]){
case '-e':
case '--empty':
camp_empty_db($CC_DBC);
camp_remove_files($CC_CONFIG['storageDir']);
break;
case '-c':
case '--clean':
camp_clean_files($CC_CONFIG['storageDir']);
break;
default:
printUsage();
}
?>

1767
3rd_party/storageServer/var/GreenBox.php vendored
View file

File diff suppressed because it is too large Load diff

1758
3rd_party/storageServer/var/LocStor.php vendored
View file

File diff suppressed because it is too large Load diff

352
3rd_party/storageServer/var/M3uPlaylist.php vendored
View file

@ -1,352 +0,0 @@
<?
define('INDCH', ' ');
/**
* M3uPlaylist class
*
* @package Campcaster
* @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/campcaster)
* @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 Campcaster 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("|--|", "&#2d;&#2d;", 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 Campcaster
* @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 Campcaster
* @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 Campcaster
* @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 Campcaster
* @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"
);
}
}
?>

1843
3rd_party/storageServer/var/Playlist.php vendored
View file

File diff suppressed because it is too large Load diff

445
3rd_party/storageServer/var/Prefs.php vendored
View file

@ -1,445 +0,0 @@
<?php
require_once("GreenBox.php");
/**
* Preference storage class.
*
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
* @see StoredFile
*/
/* ================== Prefs ================== */
class Prefs {
public $gb;
/**
* Constructor
*
* @param GreenBox $gb
* GreenBox object reference
*/
public function __construct(&$gb)
{
$this->gb =& $gb;
}
/* ======================================================= public methods */
/* ----------------------------------------------------- user preferences */
/**
* Read preference record by session id
*
* @param string $sessid
* session id
* @param string $key
* preference key
* @return string
* preference value
*/
function loadPref($sessid, $key)
{
$subjid = GreenBox::GetSessUserId($sessid);
if (PEAR::isError($subjid)) {
return $subjid;
}
if (is_null($subjid)) {
return PEAR::raiseError("Prefs::loadPref: invalid session id",
GBERR_SESS);
}
$val = $this->readVal($subjid, $key);
if (PEAR::isError($val)) {
return $val;
}
if ($val === FALSE) {
return PEAR::raiseError("Prefs::loadPref: invalid preference key",
GBERR_PREF);
}
return $val;
}
/**
* Save preference record by session id
*
* @param string $sessid
* session id
* @param string $key
* preference key
* @param string $value
* preference value
* @return boolean
*/
function savePref($sessid, $key, $value)
{
$subjid = GreenBox::GetSessUserId($sessid);
if (PEAR::isError($subjid)) {
return $subjid;
}
if (is_null($subjid)) {
return PEAR::raiseError("Prefs::savePref: invalid session id",
GBERR_SESS);
}
$r = $this->update($subjid, $key, $value);
if (PEAR::isError($r)) {
return $r;
}
if ($r === FALSE) {
$r = $this->insert($subjid, $key, $value);
if (PEAR::isError($r)) {
return $r;
}
}
return TRUE;
}
/**
* Delete preference record by session id
*
* @param string $sessid
* session id
* @param string $key
* preference key
* @return boolean
*/
function delPref($sessid, $key)
{
$subjid = GreenBox::GetSessUserId($sessid);
if (PEAR::isError($subjid)) {
return $subjid;
}
if (is_null($subjid)) {
return PEAR::raiseError("Prefs::delPref: invalid session id",
GBERR_SESS);
}
$r = $this->delete($subjid, $key);
if (PEAR::isError($r)) {
return $r;
}
if ($r === FALSE) {
return PEAR::raiseError("Prefs::delPref: invalid preference key",
GBERR_PREF);
}
return TRUE;
}
/* ---------------------------------------------------- group preferences */
/**
* Read group preference record
*
* @param string $group
* group name
* @param string $key
* preference key
* @param boolean $returnErrorIfKeyNotExists
* If set to true and the key doesnt exist, return a PEAR error.
* @return string
* preference value
*/
function loadGroupPref($group, $key, $returnErrorIfKeyNotExists = true)
{
// if sessid is would be used here fix Transport::cronCallMethod !
$subjid = Subjects::GetSubjId($group);
if (PEAR::isError($subjid)) {
return $subjid;
}
if (is_null($subjid)) {
return PEAR::raiseError(
"Prefs::loadGroupPref: invalid group name", ALIBERR_NOTGR);
}
$val = $this->readVal($subjid, $key);
if (PEAR::isError($val)) {
return $val;
}
if ($val === FALSE) {
if ($returnErrorIfKeyNotExists) {
return PEAR::raiseError(
"Prefs::loadGroupPref: invalid preference key", GBERR_PREF);
} else {
return '';
}
}
return $val;
}
/**
* Save group preference record
*
* @param string $sessid
* session id
* @param string $group
* group name
* @param string $key
* preference key
* @param string $value
* preference value
* @return boolean
*/
function saveGroupPref($sessid, $group, $key, $value)
{
$uid = GreenBox::GetSessUserId($sessid);
if (PEAR::isError($uid)) {
return $uid;
}
if (is_null($uid)) {
return PEAR::raiseError(
"Prefs::saveGroupPref: invalid session id", GBERR_SESS);
}
$gid = Subjects::GetSubjId($group);
if (PEAR::isError($gid)) {
return $gid;
}
if (is_null($gid)) {
return PEAR::raiseError(
"Prefs::saveGroupPref: invalid group name", GBERR_SESS);
}
$memb = Subjects::IsMemberOf($uid, $gid);
if (PEAR::isError($memb)) {
return $memb;
}
if (!$memb) {
return PEAR::raiseError(
"Prefs::saveGroupPref: access denied", GBERR_DENY);
}
$r = $this->update($gid, $key, $value);
if (PEAR::isError($r)) {
return $r;
}
if ($r === FALSE) {
$r = $this->insert($gid, $key, $value);
if (PEAR::isError($r)) {
return $r;
}
}
return TRUE;
}
/**
* Delete group preference record
*
* @param string $sessid
* session id
* @param string $group
* group name
* @param string $key
* preference key
* @return boolean
*/
function delGroupPref($sessid, $group, $key)
{
$uid = GreenBox::GetSessUserId($sessid);
if (PEAR::isError($uid)) {
return $uid;
}
if (is_null($uid)) {
return PEAR::raiseError(
"Prefs::delGroupPref: invalid session id", GBERR_SESS);
}
$gid = Subjects::GetSubjId($group);
if (PEAR::isError($gid)) {
return $gid;
}
if (is_null($gid)) {
return PEAR::raiseError(
"Prefs::delGroupPref: invalid group name", GBERR_SESS);
}
$memb = Subjects::IsMemberOf($uid, $gid);
if (PEAR::isError($memb)) {
return $memb;
}
if (!$memb) {
return PEAR::raiseError(
"Prefs::delGroupPref: access denied", GBERR_DENY);
}
$r = $this->delete($gid, $key);
if (PEAR::isError($r)) {
return $r;
}
if ($r === FALSE) {
return PEAR::raiseError(
"Prefs::delGroupPref: invalid preference key", GBERR_PREF);
}
return TRUE;
}
/* ==================================================== low level methods */
/**
* Insert of new preference record
*
* @param int $subjid
* local user/group id
* @param string $keystr
* preference key
* @param string $valstr
* preference value
* @return int
* local user id
*/
public static function Insert($subjid, $keystr, $valstr='')
{
global $CC_CONFIG, $CC_DBC;
$id = $CC_DBC->nextId($CC_CONFIG['prefSequence']);
if (PEAR::isError($id)) {
return $id;
}
$r = $CC_DBC->query("
INSERT INTO ".$CC_CONFIG['prefTable']."
(id, subjid, keystr, valstr)
VALUES
($id, $subjid, '$keystr', '$valstr')
");
if (PEAR::isError($r)) {
return $r;
}
return $id;
}
/**
* Read value of preference record
*
* @param int $subjid
* local user/group id
* @param string $keystr
* preference key
* @return string
* preference value
*/
function readVal($subjid, $keystr)
{
global $CC_CONFIG, $CC_DBC;
$val = $CC_DBC->getOne("
SELECT valstr FROM ".$CC_CONFIG['prefTable']."
WHERE subjid=$subjid AND keystr='$keystr'
");
if (PEAR::isError($val)) {
return $val;
}
if (is_null($val)) {
return FALSE;
}
return $val;
}
/**
* Read all keys of subject's preferences
*
* @param int $subjid
* local user/group id
* @return array
* preference keys
*/
function readKeys($subjid)
{
global $CC_CONFIG, $CC_DBC;
$res = $CC_DBC->getAll("
SELECT keystr FROM ".$CC_CONFIG['prefTable']."
WHERE subjid=$subjid
");
if (PEAR::isError($res)) {
return $res;
}
if (is_null($res)) {
return FALSE;
}
return $res;
}
/**
* Update value of preference record
*
* @param int $subjid
* local user/group id
* @param string $keystr
* preference key
* @param string $newvalstr
* new preference value
* @return boolean
*/
function update($subjid, $keystr, $newvalstr='')
{
global $CC_CONFIG, $CC_DBC;
$r = $CC_DBC->query("
UPDATE ".$CC_CONFIG['prefTable']." SET
valstr='$newvalstr'
WHERE subjid=$subjid AND keystr='$keystr'
");
if (PEAR::isError($r)) {
return $r;
}
if ($CC_DBC->affectedRows() < 1) {
return FALSE;
}
return TRUE;
}
/**
* Delete preference record
*
* @param int $subjid
* local user/group id
* @param string $keystr
* preference key
* @return boolean
*/
function delete($subjid, $keystr)
{
global $CC_CONFIG, $CC_DBC;
$r = $CC_DBC->query("
DELETE FROM ".$CC_CONFIG['prefTable']."
WHERE subjid=$subjid AND keystr='$keystr'
");
if (PEAR::isError($r)) {
return $r;
}
if ($CC_DBC->affectedRows() < 1) {
return FALSE;
}
return TRUE;
}
/* ==================================================== auxiliary methods */
/**
* Test method
*
*/
function test()
{
global $CC_CONFIG;
$sessid = Alib::Login('root', $CC_CONFIG['tmpRootPass']);
$testkey = 'testKey';
$testVal = 'abcDef 0123 ěščřžýáíé ĚŠČŘŽÝÁÍÉ';
$r = savePref($sessid, $testKey, $testVal);
if (PEAR::isError($r)) {
return $r;
}
$val = loadPref($sessid, $testKey);
if ($val != $testVal) {
echo "ERROR: preference storage test failed.\n ($testVal / $val)\n";
return FALSE;
}
$r = savePref($sessid, $testKey, '');
if (PEAR::isError($r)) {
return $r;
}
$val = loadPref($sessid, $testKey);
if ($val != $testVal) {
echo "ERROR: preference storage test failed.\n ('' / '$val')\n";
return FALSE;
}
return TRUE;
}
} // class Prefs
?>

290
3rd_party/storageServer/var/Renderer.php vendored
View file

@ -1,290 +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 Campcaster
* @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
?>

435
3rd_party/storageServer/var/Restore.php vendored
View file

@ -1,435 +0,0 @@
<?php
define('ACCESS_TYPE', 'restore');
/**
* @package Campcaster
* @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;
/**
* @param GreenBox $gb
* greenbox object reference
*/
public function __construct(&$gb)
{
global $CC_CONFIG;
$this->gb =& $gb;
$this->token = null;
$this->logFile = $CC_CONFIG['bufferDir'].'/'.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
?>

404
3rd_party/storageServer/var/Schedule.php vendored
View file

@ -1,404 +0,0 @@
<?php
class ScheduleGroup {
private $groupId;
public function __construct($p_groupId = null) {
$this->groupId = $p_groupId;
}
/**
* Convert a date to an ID by stripping out all characters
* and padding with zeros.
*
* @param string $p_dateStr
*/
public static function dateToId($p_dateStr) {
$p_dateStr = str_replace(":", "", $p_dateStr);
$p_dateStr = str_replace(" ", "", $p_dateStr);
$p_dateStr = str_replace(".", "", $p_dateStr);
$p_dateStr = str_replace("-", "", $p_dateStr);
$p_dateStr = substr($p_dateStr, 0, 17);
$p_dateStr = str_pad($p_dateStr, 17, "0");
return $p_dateStr;
}
/**
* Add the two times together, return the result.
*
* @param string $p_baseTime
* Specified as YYYY-MM-DD HH:MM:SS
*
* @param string $p_addTime
* Specified as HH:MM:SS.nnnnnn
*
* @return string
* The end time, to the nearest second.
*/
// protected function calculateEndTime($p_startTime, $p_trackTime) {
// $p_trackTime = substr($p_startTime, 0, );
// $start = new DateTime();
// $interval = new DateInterval()
//
// }
/**
* Add a music clip or playlist to the schedule.
*
* @param $p_datetime
* In the format YYYY-MM-DD HH:MM:SS.mmmmmm
* @param $p_audioFileId
* (optional, either this or $p_playlistId must be set) DB ID of the audio file
* @param $p_playlistId
* (optional, either this of $p_audioFileId must be set) DB ID of the playlist
* @param $p_options
* Does nothing at the moment.
*
* @return int|PEAR_Error
* Return PEAR_Error if the item could not be added.
* Error code 555 is a scheduling conflict.
*/
public function add($p_datetime, $p_audioFileId = null, $p_playlistId = null, $p_options = null) {
global $CC_CONFIG, $CC_DBC;
if (!is_null($p_audioFileId)) {
// Schedule a single audio track
// Load existing track
$track = StoredFile::Recall($p_audioFileId);
if (is_null($track)) {
return new PEAR_Error("Could not find audio track.");
}
// Check if there are any conflicts with existing entries
$metadata = $track->getMetadata();
$length = trim($metadata["length"]);
if (empty($length)) {
return new PEAR_Error("Length is empty.");
}
if (!Schedule::isScheduleEmptyInRange($p_datetime, $length)) {
return new PEAR_Error("Schedule conflict.", 555);
}
// Insert into the table
$this->groupId = $CC_DBC->GetOne("SELECT nextval('schedule_group_id_seq')");
$id = $this->dateToId($p_datetime);
$sql = "INSERT INTO ".$CC_CONFIG["scheduleTable"]
." (id, playlist_id, starts, ends, clip_length, group_id, file_id)"
." VALUES ($id, 0, TIMESTAMP '$p_datetime', "
." (TIMESTAMP '$p_datetime' + INTERVAL '$length'),"
." '$length',"
." {$this->groupId}, $p_audioFileId)";
$result = $CC_DBC->query($sql);
if (PEAR::isError($result)) {
var_dump($sql);
return $result;
}
return $this->groupId;
} elseif (!is_null($p_playlistId)){
// Schedule a whole playlist
// Load existing playlist
$playlist = Playlist::Recall($p_playlistId);
if (is_null($playlist)) {
return new PEAR_Error("Could not find playlist.");
}
// Check if there are any conflicts with existing entries
$length = trim($playlist->getLength());
if (empty($length)) {
return new PEAR_Error("Length is empty.");
}
if (!Schedule::isScheduleEmptyInRange($p_datetime, $length)) {
return new PEAR_Error("Schedule conflict.", 555);
}
// Insert all items into the schedule
$this->groupId = $CC_DBC->GetOne("SELECT nextval('schedule_group_id_seq')");
$id = $this->dateToId($p_datetime);
$itemStartTime = $p_datetime;
$plItems = $playlist->getContents();
foreach ($plItems as $row) {
$trackLength = $row["cliplength"];
$sql = "INSERT INTO ".$CC_CONFIG["scheduleTable"]
." (id, playlist_id, starts, ends, group_id, file_id,"
." clip_length, cue_in, cue_out, fade_in, fade_out)"
." VALUES ($id, $p_playlistId, TIMESTAMP '$itemStartTime', "
." (TIMESTAMP '$itemStartTime' + INTERVAL '$trackLength'),"
." {$this->groupId}, {$row['file_id']}, '$trackLength', '{$row['cuein']}',"
." '{$row['cueout']}', '{$row['fadein']}','{$row['fadeout']}')";
$result = $CC_DBC->query($sql);
if (PEAR::isError($result)) {
var_dump($sql);
return $result;
}
$itemStartTime = $CC_DBC->getOne("SELECT TIMESTAMP '$itemStartTime' + INTERVAL '$trackLength'");
$id = $this->dateToId($itemStartTime);
}
return $this->groupId;
}
}
public function addAfter($p_groupId, $p_audioFileId) {
global $CC_CONFIG, $CC_DBC;
// Get the end time for the given entry
$sql = "SELECT ends FROM ".$CC_CONFIG["scheduleTable"]
." WHERE group_id=$p_groupId";
$startTime = $CC_DBC->GetOne($sql);
return $this->add($startTime, $p_audioFileId);
}
public function update() {
}
/**
* Remove the group from the schedule.
* Note: does not check if it is in the past, you can remove anything.
*
* @return boolean
* TRUE on success, false if there is no group ID defined.
*/
public function remove() {
global $CC_CONFIG, $CC_DBC;
if (is_null($this->groupId) || !is_numeric($this->groupId)) {
return false;
}
$sql = "DELETE FROM ".$CC_CONFIG["scheduleTable"]
." WHERE group_id = ".$this->groupId;
return $CC_DBC->query($sql);
}
/**
* Return the number of items in this group.
* @return string
*/
public function count() {
global $CC_CONFIG, $CC_DBC;
$sql = "SELECT COUNT(*) FROM {$CC_CONFIG['scheduleTable']}"
." WHERE group_id={$this->groupId}";
return $CC_DBC->GetOne($sql);
}
/*
* Return the list of items in this group as a 2D array.
* @return array
*/
public function getItems() {
global $CC_CONFIG, $CC_DBC;
$sql = "SELECT * FROM {$CC_CONFIG['scheduleTable']}"
." WHERE group_id={$this->groupId}";
return $CC_DBC->GetAll($sql);
}
public function reschedule($toDateTime) {
global $CC_CONFIG, $CC_DBC;
// $sql = "UPDATE ".$CC_CONFIG["scheduleTable"]. " SET id=, starts=,ends="
}
}
class Schedule {
function __construct() {
}
/**
* Return true if there is nothing in the schedule for the given times.
*
* @param string $p_datetime
* @param string $p_length
*
* @return boolean|PEAR_Error
*/
public static function isScheduleEmptyInRange($p_datetime, $p_length) {
global $CC_CONFIG, $CC_DBC;
if (empty($p_length)) {
return new PEAR_Error("Schedule::isSchedulerEmptyInRange: param p_length is empty.");
}
$sql = "SELECT COUNT(*) FROM ".$CC_CONFIG["scheduleTable"]
." WHERE (starts >= '$p_datetime') "
." AND (ends <= (TIMESTAMP '$p_datetime' + INTERVAL '$p_length'))";
//$_SESSION["debug"] = $sql;
$count = $CC_DBC->GetOne($sql);
return ($count == '0');
}
public function onAddTrackToPlaylist($playlistId, $audioTrackId) {
}
public function onRemoveTrackFromPlaylist($playlistId, $audioTrackId) {
}
/**
* Returns array indexed numberically of:
* "playlistId"/"playlist_id" (aliases to the same thing)
* "start"/"starts" (aliases to the same thing) as YYYY-MM-DD HH:MM:SS.nnnnnn
* "end"/"ends" (aliases to the same thing) as YYYY-MM-DD HH:MM:SS.nnnnnn
* "group_id"/"id" (aliases to the same thing)
* "clip_length" (for playlists only, this is the length of the entire playlist)
* "name" (playlist only)
* "creator" (playlist only)
* "file_id" (audioclip only)
* "count" (number of items in the playlist, always 1 for audioclips.
* Note that playlists with one item will also have count = 1.
*
* @param string $p_fromDateTime
* In the format YYYY-MM-DD HH:MM:SS.nnnnnn
* @param string $p_toDateTime
* In the format YYYY-MM-DD HH:MM:SS.nnnnnn
* @param boolean $p_playlistsOnly
* Retreive playlists as a single item.
* @return array
* Returns empty array if nothing found
*/
public static function GetItems($p_fromDateTime, $p_toDateTime, $p_playlistsOnly = true) {
global $CC_CONFIG, $CC_DBC;
$rows = array();
if (!$p_playlistsOnly) {
$sql = "SELECT * FROM ".$CC_CONFIG["scheduleTable"]
." WHERE (starts >= TIMESTAMP '$p_fromDateTime') "
." AND (ends <= TIMESTAMP '$p_toDateTime')";
$rows = $CC_DBC->GetAll($sql);
foreach ($rows as &$row) {
$row["count"] = "1";
$row["playlistId"] = $row["playlist_id"];
$row["start"] = $row["starts"];
$row["end"] = $row["ends"];
$row["id"] = $row["group_id"];
}
} else {
$sql = "SELECT MIN(name) AS name, MIN(creator) AS creator, group_id, "
." SUM(clip_length) AS clip_length,"
." MIN(file_id) AS file_id, COUNT(*) as count,"
." MIN(playlist_id) AS playlist_id, MIN(starts) AS starts, MAX(ends) AS ends"
." FROM ".$CC_CONFIG["scheduleTable"]
." LEFT JOIN ".$CC_CONFIG["playListTable"]." ON playlist_id = ".$CC_CONFIG["playListTable"].".id"
." WHERE (starts >= TIMESTAMP '$p_fromDateTime') AND (ends <= TIMESTAMP '$p_toDateTime')"
." GROUP BY group_id"
." ORDER BY starts";
//var_dump($sql);
$rows = $CC_DBC->GetAll($sql);
if (!PEAR::isError($rows)) {
foreach ($rows as &$row) {
$row["playlistId"] = $row["playlist_id"];
$row["start"] = $row["starts"];
$row["end"] = $row["ends"];
$row["id"] = $row["group_id"];
}
}
}
return $rows;
}
public function getSchedulerTime() {
}
public function getCurrentlyPlaying() {
}
public function getNextItem($nextCount = 1) {
}
public function getStatus() {
}
private static function CcTimeToPypoTime($p_time) {
$p_time = substr($p_time, 0, 19);
$p_time = str_replace(" ", "-", $p_time);
$p_time = str_replace(":", "-", $p_time);
return $p_time;
}
/**
* Export the schedule in json formatted for pypo (the liquidsoap scheduler)
*
* @param string $range
* In the format "YYYY-MM-DD HH:mm:ss"
* @param string $source
* In the format "YYYY-MM-DD HH:mm:ss"
*/
public static function ExportRangeAsJson($p_fromDateTime, $p_toDateTime)
{
global $CC_CONFIG, $CC_DBC;
// $api_key = $this->input->post('api_key');
// if(!in_array($api_key, $CFG->ml_api_keys))
// {
// //header('HTTP/1.0 401 Unauthorized');
// //print 'You are not allowed to access this ressource. Sorry.';
// //exit;
// }
$range_start = Schedule::CcTimeToPypoTime($p_fromDateTime);
$range_end = Schedule::CcTimeToPypoTime($p_toDateTime);
$range_dt = array('start' => $range_start, 'end' => $range_end);
// Scheduler wants everything in a playlist
$data = Schedule::GetItems($p_fromDateTime, $p_toDateTime, true);
//var_dump($data);
$playlists = array();
if (is_array($data) && count($data) > 0)
{
foreach ($data as $dx)
{
// Is this the first item in the playlist?
$start = $dx['start'];
// chop off subseconds
$start = substr($start, 0, 19);
// Start time is the array key, needs to be in the format "YYYY-MM-DD-HH-mm-ss"
$pkey = Schedule::CcTimeToPypoTime($start);
$timestamp = strtotime($start);
$playlists[$pkey]['source'] = "PLAYLIST";
$playlists[$pkey]['x_ident'] = $dx["playlist_id"];
$playlists[$pkey]['subtype'] = '1'; // Just needs to be between 1 and 4 inclusive
$playlists[$pkey]['timestamp'] = $timestamp;
$playlists[$pkey]['duration'] = $dx['clip_length'];
$playlists[$pkey]['played'] = '0';
$playlists[$pkey]['schedule_id'] = $dx['group_id'];
}
}
foreach ($playlists as &$playlist)
{
$scheduleGroup = new ScheduleGroup($playlist["schedule_id"]);
$items = $scheduleGroup->getItems();
$medias = array();
$playlist['subtype'] = '1';
foreach ($items as $item)
{
$storedFile = StoredFile::Recall($item["file_id"]);
$uri = $storedFile->getFileUrl();
$medias[] = array(
'id' => $item["file_id"],
'uri' => $uri,
'fade_in' => $item["fade_in"],
'fade_out' => $item["fade_out"],
'fade_cross' => 0,
'cue_in' => $item["cue_in"],
'cue_out' => $item["cue_out"],
);
}
$playlist['medias'] = $medias;
}
$result = array();
$result['status'] = array('range' => $range_dt, 'version' => 0.1);
$result['playlists'] = $playlists;
$result['check'] = 1;
print json_encode($result);
}
}
?>

313
3rd_party/storageServer/var/SmilPlaylist.php vendored
View file

@ -1,313 +0,0 @@
<?
define('INDCH', ' ');
require_once("XmlParser.php");
/**
* SmilPlaylist class
*
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*/
class SmilPlaylist {
/**
* Parse SMIL file or string
*
* @param string $data
* local path to SMIL file or SMIL string
* @param string $loc
* location: 'file'|'string'
* @return array
* reference, parse result tree (or PEAR::error)
*/
private static function &parse($data='', $loc='file')
{
return XmlParser::parse($data, $loc);
}
/**
* Import SMIL file to storage
*
* @param GreenBox $gb
* reference to GreenBox object
* @param string $aPath
* absolute path part of imported file (e.g. /home/user/campcaster)
* @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
*/
public static function &import(&$gb, $aPath, $rPath, &$gunids, $plid, $subjid=NULL)
{
$parr = compact('subjid', 'aPath', 'plid', 'rPath');
$path = realpath("$aPath/$rPath");
if (FALSE === $path) {
return PEAR::raiseError(
"SmilPlaylist::import: file doesn't exist ($aPath/$rPath)"
);
}
$lspl = SmilPlaylist::convert2lspl($gb, $path, $gunids, $parr);
if (PEAR::isError($lspl)) {
return $lspl;
}
require_once("Playlist.php");
$pl =& Playlist::create($gb, $plid, "imported_SMIL");
if (PEAR::isError($pl)) {
return $pl;
}
$r = $pl->lock($gb, $subjid);
if (PEAR::isError($r)) {
return $r;
}
$r = $pl->setMetadata($lspl, 'string', 'playlist');
if (PEAR::isError($r)) {
return $r;
}
$r = $pl->unlock($gb);
if (PEAR::isError($r)) {
return $r;
}
return $pl;
}
/**
* Import SMIL file to storage.
*
* @param GreenBox $gb
* @param string $data
* local path to SMIL file
* @param hasharray $gunids
* hash relation from filenames to gunids
* @param array $parr
* array of subjid, aPath, plid, rPath
* @return string
* XML of playlist in Campcaster playlist format
*/
public static function convert2lspl(&$gb, $data, &$gunids, $parr)
{
extract($parr);
$tree = SmilPlaylist::parse($data);
if (PEAR::isError($tree)) {
return $tree;
}
if ($tree->name != 'smil') {
return PEAR::raiseError("SmilPlaylist::parse: smil tag expected");
}
if (isset($tree->children[1])) {
return PEAR::raiseError(sprintf(
"SmilPlaylist::parse: unexpected tag %s in tag smil",
$tree->children[1]->name
));
}
$res = SmilPlaylistBodyElement::convert2lspl(
$gb, $tree->children[0], &$gunids, $parr);
return $res;
}
} // SmilPlaylist
/**
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*/
class SmilPlaylistBodyElement {
public static function convert2lspl(&$gb, &$tree, &$gunids, $parr, $ind='')
{
extract($parr);
$ind2 = $ind.INDCH;
if ($tree->name != 'body') {
return PEAR::raiseError("SmilPlaylist::parse: body tag expected");
}
if (isset($tree->children[1])) {
return PEAR::raiseError(sprintf(
"SmilPlaylist::parse: unexpected tag %s in tag body",
$tree->children[1]->name
));
}
$res = SmilPlaylistParElement::convert2lspl(
$gb, $tree->children[0], &$gunids, $parr, $ind2);
if (PEAR::isError($res)) {
return $res;
}
$title = basename($rPath);
$playlength = '0';
$res = "$ind<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n".
"$ind<playlist id=\"$plid\" playlength=\"$playlength\" title=\"$title\">\n".
"$ind2<metadata/>\n".
"$res".
"$ind</playlist>\n";
return $res;
}
} // class SmilPlaylistBodyElement
/**
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*/
class SmilPlaylistParElement {
public static function convert2lspl(&$gb, &$tree, &$gunids, $parr, $ind='')
{
extract($parr);
if ($tree->name != 'par') {
return PEAR::raiseError("SmilPlaylist::parse: par tag expected");
}
$res = '';
foreach ($tree->children as $i => $ch) {
$ch =& $tree->children[$i];
$r = SmilPlaylistAudioElement::convert2lspl($gb, $ch, &$gunids, $parr, $ind.INDCH);
if (PEAR::isError($r)) {
return $r;
}
$res .= $r;
}
return $res;
}
}
/**
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*/
class SmilPlaylistAudioElement {
public static function convert2lspl(&$gb, &$tree, &$gunids, $parr, $ind='')
{
extract($parr);
$uri = $tree->attrs['src']->val;
$gunid = ( isset($gunids[basename($uri)]) ? $gunids[basename($uri)] : NULL);
$ind2 = $ind.INDCH;
if ($tree->name != 'audio') {
return PEAR::raiseError("SmilPlaylist::parse: audio tag expected");
}
if (isset($tree->children[2])) {
return PEAR::raiseError(sprintf(
"SmilPlaylist::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 = SmilPlaylistAnimateElement::convert2lspl($gb, $ch, &$gunids, $parr, $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) {
$fiGunid = StoredFile::CreateGunid();
$fadeIn = Playlist::secondsToPlaylistTime($fadeIn);
$fadeOut = Playlist::secondsToPlaylistTime($fadeOut);
$fInfo = "$ind2<fadeInfo id=\"$fiGunid\" fadeIn=\"$fadeIn\" fadeOut=\"$fadeOut\"/>\n";
} else {
$fInfo = '';
}
$plElGunid = StoredFile::CreateGunid();
$acGunid = $gunid;
$type = 'audioClip';
if (preg_match("|\.([a-zA-Z0-9]+)$|", $uri, $va)) {
switch (strtolower($ext = $va[1])) {
case "lspl":
case "xml":
case "smil":
case "m3u":
$type = 'playlist';
$acId = $gb->bsImportPlaylistRaw($gunid,
$aPath, $uri, $ext, $gunids, $subjid);
if (PEAR::isError($acId)) {
return $r;
}
//break;
default:
$ac = StoredFile::RecallByGunid($gunid);
if (is_null($ac) || PEAR::isError($ac)) {
return $ac;
}
$r = $ac->md->getMetadataElement('dcterms:extent');
if (PEAR::isError($r)) {
return $r;
}
$playlength = $r[0]['value'];
}
}
$title = basename($tree->attrs['src']->val);
$offset = Playlist::secondsToPlaylistTime($tree->attrs['begin']->val);
$clipStart = Playlist::secondsToPlaylistTime($tree->attrs['clipStart']->val);
$clipEnd = Playlist::secondsToPlaylistTime($tree->attrs['clipEnd']->val);
$clipLength = Playlist::secondsToPlaylistTime($tree->attrs['clipLength']->val);
$res = "$ind<playlistElement id=\"$plElGunid\" relativeOffset=\"$offset\" clipStart=\"$clipStart\" clipEnd=\"$clipEnd\" clipLength=\"$clipLength\">\n".
"$ind2<$type id=\"$acGunid\" playlength=\"$playlength\" title=\"$title\"/>\n".
$fInfo.
"$ind</playlistElement>\n";
return $res;
}
} // class SmilPlaylistAudioElement
/**
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*/
class SmilPlaylistAnimateElement {
public static function convert2lspl(&$gb, &$tree, &$gunids, $parr, $ind='')
{
extract($parr);
if ($tree->name != 'animate') {
return PEAR::raiseError("SmilPlaylist::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'=>intval($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(
"SmilPlaylistAnimateElement::convert2lspl: animate parameters too general"
);
}
} // class SmilPlaylistAnimateElement
?>

1480
3rd_party/storageServer/var/StoredFile.php vendored
View file

File diff suppressed because it is too large Load diff

684
3rd_party/storageServer/var/Subjects.php vendored
View file

@ -1,684 +0,0 @@
<?php
//require_once("ObjClasses.php");
define('ALIBERR_NOTGR', 20);
define('ALIBERR_BADSMEMB', 21);
/**
* Subj class
*
* users + groups
* with "linearized recursive membership" ;)
* (allow adding users to groups or groups to groups)
*
* @package Campcaster
* @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;
}
/**
* Remove subject by uid or by login
*
* @param string $login
* @param int $uid
* @return boolean|PEAR_Error
*/
public static function RemoveSubj($login, $uid=NULL)
{
global $CC_CONFIG, $CC_DBC;
if (is_null($uid)) {
$uid = Subjects::GetSubjId($login);
}
if (PEAR::isError($uid)) {
return $uid;
}
$sql = "DELETE FROM ".$CC_CONFIG['smembTable']
." WHERE (uid='$uid' OR gid='$uid') AND mid is null";
$r = $CC_DBC->query($sql);
if (PEAR::isError($r)) {
return $r;
}
$sql2 = "DELETE FROM ".$CC_CONFIG['subjTable']
." WHERE login='$login'";
$r = $CC_DBC->query($sql2);
if (PEAR::isError($r)) {
return $r;
}
return Subjects::_rebuildRels();
} // fn removeSubj
/**
* Check login and password
*
* @param string $login
* @param string $pass
* optional
* @return boolean|int|PEAR_Error
*/
public static function Authenticate($login, $pass='')
{
global $CC_CONFIG, $CC_DBC;
$cpass = md5($pass);
$sql = "SELECT id FROM ".$CC_CONFIG['subjTable']
." WHERE login='$login' AND pass='$cpass' AND type='U'";
$id = $CC_DBC->getOne($sql);
if (PEAR::isError($id)) {
return $id;
}
return (is_null($id) ? FALSE : $id);
} // 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
*
* @param string $login
* @param string $oldpass
* old password (optional for 'superuser mode')
* @param string $pass
* optional
* @param boolean $passenc
* optional, password already encrypted if true
* @return boolean|PEAR_Error
*/
public static function Passwd($login, $oldpass=null, $pass='', $passenc=FALSE)
{
global $CC_CONFIG, $CC_DBC;
if (!$passenc) {
$cpass = md5($pass);
} else {
$cpass = $pass;
}
if (!is_null($oldpass)) {
$oldcpass = md5($oldpass);
$oldpCond = "AND pass='$oldcpass'";
} else {
$oldpCond = '';
}
$sql = "UPDATE ".$CC_CONFIG['subjTable']." SET pass='$cpass'"
." WHERE login='$login' $oldpCond AND type='U'";
$r = $CC_DBC->query($sql);
if (PEAR::isError($r)) {
return $r;
}
return TRUE;
} // fn passwd
/* --------------------------------------------------------------- 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
/**
* Remove subject from group
*
* @param string $login
* @param string $gname
* @return boolean|PEAR_Error
*/
public static function RemoveSubjectFromGroup($login, $gname)
{
global $CC_CONFIG, $CC_DBC;
$uid = Subjects::GetSubjId($login);
if (PEAR::isError($uid)) {
return $uid;
}
$gid = Subjects::GetSubjId($gname);
if (PEAR::isError($gid)) {
return $gid;
}
$sql = "SELECT id FROM ".$CC_CONFIG['smembTable']
." WHERE uid='$uid' AND gid='$gid' AND mid is null";
$mid = $CC_DBC->getOne($sql);
if (is_null($mid)) {
return FALSE;
}
if (PEAR::isError($mid)) {
return $mid;
}
// remove it:
$r = Subjects::_removeMemb($mid);
if (PEAR::isError($r)) {
return $r;
}
// and rebuild indirect memberships:
$r = Subjects::_rebuildRels();
if (PEAR::isError($r)) {
return $r;
}
return TRUE;
} // fn removeSubjFromGr
/* --------------------------------------------------------- info methods */
/**
* Get subject id from login
*
* @param string $login
* @return int|PEAR_Error
*/
public static function GetSubjId($login)
{
global $CC_CONFIG;
global $CC_DBC;
$sql = "SELECT id FROM ".$CC_CONFIG['subjTable']
." WHERE login='$login'";
return $CC_DBC->getOne($sql);
} // 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
*
* @param int $uid
* local user id
* @param int $gid
* local group id
* @return boolean
*/
public static function IsMemberOf($uid, $gid)
{
global $CC_CONFIG, $CC_DBC;
$sql = "SELECT count(*)as cnt"
." FROM ".$CC_CONFIG['smembTable']
." WHERE uid='$uid' AND gid='$gid'";
$res = $CC_DBC->getOne($sql);
if (PEAR::isError($res)) {
return $res;
}
return (intval($res) > 0);
} // 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
/* =============================================== test and debug methods */
/**
* Dump subjects for debug
*
* @param string $indstr
* indentation string
* @param string $ind
* actual indentation
* @return string
*/
public static function DumpSubjects($indstr=' ', $ind='')
{
$r = $ind.join(', ', array_map(
create_function('$v', 'return "{$v[\'login\']}({$v[\'cnt\']})";'),
Subjects::GetSubjectsWCnt()
))."\n";
return $r;
} // fn dumpSubjects
/**
* Delete all subjects and membership records
*
* @return void
*/
public static function DeleteData()
{
global $CC_CONFIG, $CC_DBC;
$CC_DBC->query("DELETE FROM ".$CC_CONFIG['subjTable']);
$CC_DBC->query("DELETE FROM ".$CC_CONFIG['smembTable']);
//ObjClasses::DeleteData();
} // fn deleteData
/**
* Insert test data
*
* @return array
*/
public function TestData()
{
// $tdata = ObjClasses::TestData();
// $o['root'] = Subjects::AddSubj('root', 'q');
// $o['test1'] = Subjects::AddSubj('test1', 'a');
// $o['test2'] = Subjects::AddSubj('test2', 'a');
// $o['test3'] = Subjects::AddSubj('test3', 'a');
// $o['test4'] = Subjects::AddSubj('test4', 'a');
// $o['test5'] = Subjects::AddSubj('test5', 'a');
// $o['gr1'] = Subjects::AddSubj('gr1');
// $o['gr2'] = Subjects::AddSubj('gr2');
// $o['gr3'] = Subjects::AddSubj('gr3');
// $o['gr4'] = Subjects::AddSubj('gr4');
// Subjects::AddSubjectToGroup('test1', 'gr1');
// Subjects::AddSubjectToGroup('test2', 'gr2');
// Subjects::AddSubjectToGroup('test3', 'gr3');
// Subjects::AddSubjectToGroup('test4', 'gr4');
// Subjects::AddSubjectToGroup('test5', 'gr1');
// Subjects::AddSubjectToGroup('gr4', 'gr3');
// Subjects::AddSubjectToGroup('gr3', 'gr2');
// $tdata['subjects'] = $o;
// return $tdata;
} // fn TestData
/**
* Make basic test
*
*/
public static function Test()
{
// $p = ObjClasses::Test();
// if (PEAR::isError($p)) {
// return $p;
// }
// Subjects::DeleteData();
// Subjects::TestData();
// $test_correct = "root(0), test1(0), test2(0), test3(0),".
// " test4(0), test5(0), gr1(2), gr2(2), gr3(2), gr4(1)\n";
// $test_dump = Subjects::DumpSubjects();
// Subjects::RemoveSubj('test1');
// Subjects::RemoveSubj('test3');
// Subjects::RemoveSubjectFromGroup('test5', 'gr1');
// Subjects::RemoveSubjectFromGroup('gr3', 'gr2');
// $test_correct .= "root(0), test2(0), test4(0), test5(0),".
// " gr1(0), gr2(1), gr3(1), gr4(1)\n";
// $test_dump .= Subjects::DumpSubjects();
// Subjects::DeleteData();
// if ($test_dump == $test_correct) {
// $test_log .= "subj: OK\n";
// return TRUE;
// } else {
// return PEAR::raiseError(
// 'Subjects::test:', 1, PEAR_ERROR_DIE, '%s'.
// "<pre>\ncorrect:\n{$test_correct}\n".
// "dump:\n{$test_dump}\n</pre>\n");
// }
} // fn test
} // class Subjects
?>

1833
3rd_party/storageServer/var/Transport.php vendored
View file

File diff suppressed because it is too large Load diff

419
3rd_party/storageServer/var/TransportRecord.php vendored
View file

@ -1,419 +0,0 @@
<?php
define('TR_LEAVE_CLOSED', TRUE);
/**
* Auxiliary class for transport records
*
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*/
class TransportRecord
{
/**
* @var DB
*/
//public $dbc;
/**
* @var GreenBox
*/
private $gb;
/**
* @var array
*/
//private $config;
/**
* @var Transport
*/
private $tr;
/**
* @var boolean
*/
private $recalled = FALSE;
/**
* @var boolean
*/
private $dropped = FALSE;
/**
* @param Transport $tr
* @return TransportRecord
*/
public function __construct(&$tr)
{
$this->tr =& $tr;
$this->gb =& $tr->gb;
}
/**
* Factory method
*
* @param Transport $tr
* @param string $trtype
* transport type (see Transport::install)
* @param string $direction
* 'up' | 'down'
* @param array $defaults
* default parameters (optional, internal use)
* @return TransportRecord
*/
function create(&$tr, $trtype, $direction='up', $defaults=array())
{
global $CC_DBC, $CC_CONFIG;
$trec = new TransportRecord($tr);
$trec->trtok = $trtok = $tr->_createTransportToken();
$trec->row = array_merge($defaults,
array('trtype'=>$trtype, 'direction'=>$direction));
$trec->recalled = TRUE;
if (!isset($defaults['title'])) {
$defaults['title'] = $trec->getTitle();
if (PEAR::isError($defaults['title'])) {
return $defaults['title'];
}
}
$id = $CC_DBC->nextId($CC_CONFIG['transSequence']);
$names = "id, trtok, direction, state, trtype, start, ts";
$values = "$id, '$trtok', '$direction', 'init', '$trtype', now(), now()";
foreach ($defaults as $k => $v) {
$sqlVal = $trec->_getSqlVal($k, $v);
$names .= ", $k";
$values .= ", $sqlVal";
}
$query = "
INSERT INTO ".$CC_CONFIG['transTable']."
($names)
VALUES
($values)
";
$res = $CC_DBC->query($query);
if (PEAR::isError($res)) {
return $res;
}
return $trec;
}
/**
* Recall transport record from DB
*
* @param Transport $tr
* @param string $trtok
* transport token
* @return TransportRecord
*/
function recall(&$tr, $trtok)
{
global $CC_DBC, $CC_CONFIG;
$trec = new TransportRecord($tr);
$trec->trtok = $trtok;
$row = $CC_DBC->getRow("
SELECT
id, trtok, state, trtype, direction,
to_hex(gunid)as gunid, to_hex(pdtoken)as pdtoken,
fname, localfile, url, rtrtok, mdtrtok, uid,
expectedsize, realsize, expectedsum, realsum,
errmsg, title, jobpid
FROM ".$CC_CONFIG['transTable']."
WHERE trtok='$trtok'
");
if (PEAR::isError($row)) {
return $row;
}
if (is_null($row)) {
return PEAR::raiseError("TransportRecord::recall:".
" invalid transport token ($trtok)", TRERR_TOK
);
}
$row['pdtoken'] = StoredFile::NormalizeGunid($row['pdtoken']);
$row['gunid'] = StoredFile::NormalizeGunid($row['gunid']);
$trec->row = $row;
$trec->recalled = TRUE;
return $trec;
}
/**
* Set state of transport record
*
* @param string $newState
* @param array $data
* other data fields to set
* @param string $oldState
* check old state and do nothing if differ
* @param boolean $lock
* check lock and do nothing if differ
* @return boolean success
*/
function setState($newState, $data=array(), $oldState=NULL, $lock=NULL)
{
global $CC_CONFIG, $CC_DBC;
$set = " state='$newState', ts=now()";
if (!is_null($lock)) {
$slock = ($lock ? 'Y' : 'N');
$nlock = (!$lock);
$snlock = ($nlock ? 'Y' : 'N');
$set .= ", lock='$snlock'";
}
foreach ($data as $k => $v) {
$set .= ", $k=".$this->_getSqlVal($k, $v);
}
$r = $CC_DBC->query("
UPDATE ".$CC_CONFIG['transTable']."
SET $set
WHERE trtok='{$this->trtok}'".
(is_null($oldState) ? '' : " AND state='$oldState'").
(is_null($lock) ? '' : " AND lock = '$slock'")
);
if (PEAR::isError($r)) {
return $r;
}
// return TRUE;
$affRows = $CC_DBC->affectedRows();
if (PEAR::isError($affRows)) {
return $affRows;
}
return ($affRows == 1);
}
/**
* Return state of transport record
*
* @return string
* state
*/
function getState()
{
if (!$this->recalled) {
return PEAR::raiseError("TransportRecord::getState:".
" not recalled ({$this->trtok})", TRERR_TOK
);
}
return $this->row['state'];
}
/**
* Set lock on transport record and save/clear process id
*
* @param boolean $lock
* lock if true, release lock if false
* @param int $pid
* process id
* @return mixed
* true or error
*/
function setLock($lock, $pid=NULL)
{
global $CC_CONFIG, $CC_DBC;
$pidsql = (is_null($pid) ? "NULL" : "$pid" );
if ($this->dropped) {
return TRUE;
}
$slock = ($lock ? 'Y' : 'N');
$nlock = (!$lock);
$snlock = ($nlock ? 'Y' : 'N');
$r = $CC_DBC->query("
UPDATE ".$CC_CONFIG['transTable']."
SET lock='$slock', jobpid=$pidsql, ts=now()
WHERE trtok='{$this->trtok}' AND lock = '$snlock'"
);
if (PEAR::isError($r)) {
return $r;
}
$affRows = $CC_DBC->affectedRows();
if (PEAR::isError($affRows)) {
return $affRows;
}
if ($affRows === 0) {
$ltxt = ($lock ? 'lock' : 'unlock' );
return PEAR::raiseError(
"TransportRecord::setLock: can't $ltxt ({$this->trtok})"
);
}
return TRUE;
}
/**
* Return type of transport
*
* @return string
* Transport type
*/
function getTransportType()
{
if (!$this->recalled) {
return PEAR::raiseError("TransportRecord::getTransportType:".
" not recalled ({$this->trtok})", TRERR_TOK
);
}
return $this->row['trtype'];
}
/**
* Kill transport job (on pause or cancel)
*
* @return string
* Transport type
*/
function killJob()
{
if (!$this->recalled) {
return PEAR::raiseError("TransportRecord::getTransportType:".
" not recalled ({$this->trtok})", TRERR_TOK
);
}
$jobpid = $this->row['jobpid'];
$res = system("pkill -P $jobpid", $status);
}
/**
* Set state to failed and set error message in transport record
*
* @param string $txt
* base part of error message
* @param PEAR_Error $eo
* (opt.) error msg can be construct from it
* @return mixed
* boolean true or error
*/
function fail($txt='', $eo=NULL)
{
if (!$this->recalled) {
return PEAR::raiseError("TransportRecord::fail:".
" not recalled ({$this->trtok})", TRERR_TOK
);
}
$msg = $txt;
if (!is_null($eo)) {
$msg .= $eo->getMessage()." ".$eo->getUserInfo().
" [".$eo->getCode()."]";
}
$r = $this->setState('failed', array('errmsg'=>$msg));
if (PEAR::isError($r)) {
return $r;
}
return TRUE;
}
/**
* Close transport record
*
* @return mixed
* boolean true or error
*/
function close()
{
global $CC_CONFIG, $CC_DBC;
if (!$this->recalled) {
return PEAR::raiseError("TransportRecord::close:".
" not recalled ({$this->trtok})", TRERR_TOK
);
}
if (TR_LEAVE_CLOSED) {
$r = $this->setState('closed');
if (PEAR::isError($r)) {
return $r;
}
} else {
$r = $CC_DBC->query("
DELETE FROM ".$CC_CONFIG['transTable']."
WHERE trtok='{$this->trtok}'
");
if (PEAR::isError($r)) {
return $r;
}
$this->recalled = FALSE;
$this->dropped = TRUE;
}
return TRUE;
}
/**
* Add field specific envelopes to values (e.g. ' around strings)
*
* @param string $fldName
* field name
* @param mixed $fldVal
* field value
* @return string
*/
function _getSqlVal($fldName, $fldVal)
{
switch ($fldName) {
case 'realsize':
case 'expectedsize':
case 'uid':
return ("$fldVal"!='' ? "$fldVal" : "NULL");
break;
case 'gunid':
case 'pdtoken':
return "x'$fldVal'::bigint";
break;
default:
$fldVal = pg_escape_string($fldVal);
return "'$fldVal'";
break;
}
}
/**
* Get title from transported object's metadata (if exists)
*
* @return string
* the title or descriptive string
*/
function getTitle()
{
$defStr = 'unknown';
$trtype = $this->getTransportType(); //contains recall check
if (PEAR::isError($trtype)) {
return $trtype;
}
switch ($trtype) {
case "audioclip":
case "playlist":
case "playlistPkg":
case "metadata":
$title = $this->gb->bsGetTitle(NULL, $this->row['gunid']);
if (is_null($title)) {
$title = $defStr;
}
if (PEAR::isError($title)) {
if ($title->getCode() == GBERR_FOBJNEX) {
$title = $defStr;
} else {
return $title;
}
}
break;
case "searchjob":
$title = 'searchjob';
break;
case "file":
$title = ( isset($this->row['localfile']) ?
basename($this->row['localfile']) : 'regular file');
break;
default:
$title = $defStr;
}
return $title;
}
} // class TransportRecord
?>

385
3rd_party/storageServer/var/Validator.php vendored
View file

@ -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 Campcaster
* @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
?>

398
3rd_party/storageServer/var/XmlParser.php vendored
View file

@ -1,398 +0,0 @@
<?php
/**
* @package Campcaster
* @subpackage StorageServer
*/
require_once "XML/Util.php";
/* ================================================================== Element */
/**
* Object representation of one XML element
*
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
* @see MetaData
*/
class XmlElement {
/**
* Namespace prefix
* @var string
*/
public $ns;
/**
* Element name
* @var string
*/
public $name;
/**
* Attributes
* @var array
*/
public $attrs = array();
/**
* Namespace definitions
* @var array
*/
public $nSpaces = array();
/**
* Child nodes
* @var array
*/
public $children = array();
/**
* Text content of element
* @var string
*/
public $content = '';
/**
* @param string $fullname
* Fully qualified name of element
* @param array $attrs
* hash of attributes
* @param array $nSpaces
* hash of namespace definitions
* @param array $children
* hash of child nodes
*/
public function __construct($fullname, $attrs, $nSpaces=array(), $children=array())
{
$a = XML_Util::splitQualifiedName($fullname);
$this->ns = $a['namespace'];
$this->name = $a['localPart'];
$this->attrs = $attrs;
$this->nSpaces = $nSpaces;
$this->children = $children;
}
} // class XmlElement
/* ================================================================ Attribute */
/**
* Object representation of one XML attribute
*
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
* @see MetaData
*/
class XmlAttrib {
/**
* Namespace prefix
* @var string
*/
public $ns;
/**
* Attribute name
* @var string
*/
public $name;
/**
* Attribute value
* @var string
*/
public $val;
/**
* @param string $atns
* namespace prefix
* @param string $atnm
* attribute name
* @param string $atv
* attribute value
*/
public function __construct($atns, $atnm, $atv)
{
$this->ns = $atns;
$this->name = $atnm;
$this->val = $atv;
}
} // fn XmlAttrib
/* =================================================================== Parser */
/**
* XML parser object encapsulation
*
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
* @see MetaData
*/
class XmlParser {
/**
* Tree of nodes
* @var array
*/
private $tree = NULL;
/**
* Parse stack
* @var array
*/
private $stack = array();
/**
* Error structure
* @var array
*/
private $err = array(FALSE, '');
/**
* @param string $data
* XML string to be parsed
*/
public function __construct($data){
$xml_parser = xml_parser_create('UTF-8');
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, FALSE);
xml_set_object($xml_parser, $this);
xml_set_element_handler($xml_parser, "startTag", "endTag");
xml_set_character_data_handler($xml_parser, 'characterData');
$res = xml_parse($xml_parser, $data, TRUE);
if (!$res) {
$this->err = array(TRUE,
sprintf("XML error: %s at line %d\n",
xml_error_string(xml_get_error_code($xml_parser)),
xml_get_current_line_number($xml_parser)
)
);
// var_dump($data);
}
xml_parser_free($xml_parser);
}
/**
* Parse XML file or string
*
* @param string $data
* local path to XML file or XML 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(
"XmlParser::parse: file not found ($data)"
);
}
if (!is_readable($data)) {
return PEAR::raiseError(
"XmlParser::parse: can't read file ($data)"
);
}
$data = file_get_contents($data);
case "string":
$parser = new XmlParser($data);
if ($parser->isError()) {
return PEAR::raiseError(
"XmlParser::parse: ".$parser->getError()
);
}
$tree = $parser->getTree();
break;
default:
return PEAR::raiseError(
"XmlParser::parse: unsupported source location ($loc)"
);
}
return $tree;
}
/**
* Start tag handler
*
* @param resource $parser
* reference to parser resource
* @param string $fullname
* element name
* @param array $attrs
* array of attributes
* @return none
*/
function startTag($parser, $fullname, $attrs) {
$nSpaces = array();
foreach ($attrs as $atn => $atv) {
$a = XML_Util::splitQualifiedName($atn);
$atns = $a['namespace'];
$atnm = $a['localPart'];
unset($attrs[$atn]);
if ($atns == 'xmlns') {
$nSpaces[$atnm] = $atv;
} else if ($atns == NULL && $atnm == 'xmlns') {
$nSpaces[''] = $atv;
} else {
$attrs[$atn] = new XmlAttrib($atns, $atnm, $atv);
}
}
$el = new XmlElement($fullname, $attrs, $nSpaces);
array_push($this->stack, $el);
}
/**
* End tag handler
*
* @param resource $parser
* reference to parser resource
* @param string $fullname
* element name
* @return none
*/
function endTag($parser, $fullname) {
$cnt = count($this->stack);
if ($cnt > 1) {
$this->stack[$cnt-2]->children[] = $this->stack[$cnt-1];
$lastEl = array_pop($this->stack);
} else {
$this->tree = $this->stack[0];
}
}
/**
* Character data handler
*
* @param resource $parser
* reference to parser resource
* @param string $data
* @return none
*/
function characterData($parser, $data) {
$cnt = count($this->stack);
if (trim($data)!='') {
$this->stack[$cnt-1]->content .= $data;
}
}
/**
* Default handler
*
* @param resource $parser
* reference to parser resource
* @param string $data
* @return none
*/
function defaultHandler($parser, $data)
{
$cnt = count($this->stack);
//if(substr($data, 0, 1) == "&" && substr($data, -1, 1) == ";"){
// $this->stack[$cnt-1]->content .= trim($data);
//}else{
$this->stack[$cnt-1]->content .= "*** $data ***";
//}
}
/**
* Return result tree
*
* @return array
* tree structure
*/
function getTree()
{
return $this->tree;
}
/**
* Return error string
*
* @return boolean
* whether error occured
*/
function isError()
{
return $this->err[0];
}
/**
* Return error string
*
* @return string
* error message
*/
function getError()
{
return $this->err[1];
}
/* ----------------------------------- auxiliary methos for serialization */
/**
* Serialize metadata of one file
*
* @return string, serialized XML
*/
function serialize()
{
$res = '<?xml version="1.0" encoding="utf-8"?>';
$res .= $this->serializeEl($this->tree);
$res .= "\n";
return $res;
}
/**
* Serialize one metadata element
*
* @param el object, element object
* @param lvl int, level for indentation
* @return string, serialized XML
*/
function serializeEl($el, $lvl=0)
{
$ind = str_repeat(" ", $lvl);
$elNs = $el->ns;
$elName = $el->name;
$attrs = XML_Util::attributesToString($el->attrs);
$fullName = ($elNs=='' ? '' : "$elNs:")."$elName";
$res = "\n{$ind}<{$fullName}{$attrs}>";
$haveCh = (count($el->children)>0);
foreach ($el->children as $ch) {
$res .= $this->serializeEl($ch, $lvl+1);
}
$res .= XML_Util::replaceEntities("{$el->content}");
if ($haveCh) {
$res .= "\n{$ind}";
}
$res .= "</{$fullName}>";
return $res;
}
/* -------------------------------------------------------- debug methods */
/**
* Debug dump of tree
*
* @return hash, tree structure
*/
function dump()
{
var_dump($this->tree);
}
}
?>

328
3rd_party/storageServer/var/audioClipFormat.php vendored
View file

@ -1,328 +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}))?)?)?$',
),
);
?>

4
3rd_party/storageServer/var/campcaster_version.php vendored
View file

@ -1,4 +0,0 @@
<?php
define('CAMPCASTER_VERSION', '1.4.0');
define('CAMPCASTER_COPYRIGHT_DATE', '2010');
?>

188
3rd_party/storageServer/var/conf.php vendored
View file

@ -1,188 +0,0 @@
<?php
/**
* StorageServer configuration file
*
* configuration structure:
*
* <dl>
* <dt>dsn<dd> datasource setting
* <dt>tblNamePrefix <dd>prefix for table names in the database
* <dt>authCookieName <dd>secret token cookie name
* <dt>AdminsGr <dd>name of admin group
* <dt>StationPrefsGr <dd>name of station preferences group
* <dt>AllGr <dd>name of 'all users' group
* <dt>storageDir <dd>main directory for storing binary media files
* <dt>bufferDir <dd>directory for temporary files
* <dt>transDir <dd>directory for incomplete transferred files
* <dt>accessDir <dd>directory for symlinks to accessed files
* <dt>validate <dd>enable/disable validator
* <dt>useTrash <dd>enable/disable safe delete (move to trash)
* <dt>storageUrlPath<dd>path-URL-part of storageServer base dir
* <dt>storageXMLRPC<dd>XMLRPC server script address relative to storageUrlPath
* <dt>storageUrlHost, storageUrlPort<dd>host and port of storageServer
* <dt>archiveUrlPath<dd>path-URL-part of archiveServer base dir
* <dt>archiveXMLRPC<dd>XMLRPC server script address relative to archiveUrlPath
* <dt>archiveUrlHost, archiveUrlPort<dd>host and port of archiveServer
* <dt>archiveAccountLogin, archiveAccountPass <dd>account info
* for login to archive
* <dt>sysSubjs<dd>system users/groups - cannot be deleted
* </dl>
*/
include("campcaster_version.php");
// these are the default values for the config
global $CC_CONFIG;
$CC_CONFIG = array(
/* ================================================== basic configuration */
'dsn' => array(
'username' => 'test',
'password' => 'test',
'hostspec' => 'localhost',
'phptype' => 'pgsql',
'database' => 'Campcaster-paul',
),
'tblNamePrefix' => 'cc_',
/* ================================================ storage configuration */
'authCookieName'=> 'campcaster_session_id',
//'AdminsGr' => 'Admins',
'StationPrefsGr'=> 'StationPrefs',
//'AllGr' => 'All',
'TrashName' => 'trash_',
'storageDir' => dirname(__FILE__).'/../../storageServer/var/stor',
'bufferDir' => dirname(__FILE__).'/../../storageServer/var/stor/buffer',
'transDir' => dirname(__FILE__).'/../../storageServer/var/trans',
'accessDir' => dirname(__FILE__).'/../../storageServer/var/access',
'pearPath' => dirname(__FILE__).'/../../../../usr/lib/pear',
// 'zendPath' => dirname(__FILE__).'/../../../../usr/lib',
'cronDir' => dirname(__FILE__).'/../../storageServer/var/cron',
'validate' => TRUE,
'useTrash' => TRUE,
/* ==================================================== URL configuration */
'storageUrlPath' => '/campcasterStorageServer',
'storageXMLRPC' => 'xmlrpc/xrLocStor.php',
'storageUrlHost' => 'localhost',
'storageUrlPort' => 80,
/* ================================================ archive configuration */
'archiveUrlPath' => '/campcasterStorageServer',
'archiveXMLRPC' => 'xmlrpc/xrLocStor.php',
'archiveUrlHost' => 'localhost',
// 'archiveUrlHost' => '192.168.30.166',
'archiveUrlPort' => 80,
'archiveAccountLogin' => 'root',
'archiveAccountPass' => 'q',
/* ============================================== scheduler configuration */
'schedulerUrlPath' => '',
'schedulerXMLRPC' => 'RC2',
'schedulerUrlHost' => 'localhost',
'schedulerUrlPort' => 3344,
'schedulerPass' => 'change_me',
/* ==================================== aplication-specific configuration */
'objtypes' => array(
'Storage' => array(/*'Folder',*/ 'File' /*, 'Replica'*/),
'File' => array(),
'audioclip' => array(),
'playlist' => array(),
// 'Replica' => array(),
),
'allowedActions'=> array(
'File' => array('editPrivs', 'write', 'read'),
'audioclip' => array('editPrivs', 'write', 'read'),
'playlist' => array('editPrivs', 'write', 'read'),
// 'Replica' => array('editPrivs', 'write', 'read'),
// '_class' => array('editPrivs', 'write', 'read'),
),
'allActions' => array(
'editPrivs', 'write', 'read', /*'classes',*/ 'subjects'
),
/* ============================================== auxiliary configuration */
'tmpRootPass' => 'q',
/* =================================================== cron configuration */
'cronUserName' => 'www-data',
# 'lockfile' => dirname(__FILE__).'/cron/cron.lock',
'lockfile' => dirname(__FILE__).'/../../storageServer/var/stor/buffer/cron.lock',
'cronfile' => dirname(__FILE__).'/cron/croncall.php',
'paramdir' => dirname(__FILE__).'/cron/params',
'systemPrefId' => "0", // ID for system prefs in prefs table
);
// Add database table names
$CC_CONFIG['playListTable'] = $CC_CONFIG['tblNamePrefix'].'playlist';
$CC_CONFIG['playListContentsTable'] = $CC_CONFIG['tblNamePrefix'].'playlistcontents';
$CC_CONFIG['filesTable'] = $CC_CONFIG['tblNamePrefix'].'files';
$CC_CONFIG['accessTable'] = $CC_CONFIG['tblNamePrefix'].'access';
$CC_CONFIG['permTable'] = $CC_CONFIG['tblNamePrefix'].'perms';
$CC_CONFIG['sessTable'] = $CC_CONFIG['tblNamePrefix'].'sess';
$CC_CONFIG['subjTable'] = $CC_CONFIG['tblNamePrefix'].'subjs';
$CC_CONFIG['smembTable'] = $CC_CONFIG['tblNamePrefix'].'smemb';
$CC_CONFIG['transTable'] = $CC_CONFIG['tblNamePrefix'].'trans';
$CC_CONFIG['prefTable'] = $CC_CONFIG['tblNamePrefix'].'pref';
//$CC_CONFIG['playlogTable'] = $CC_CONFIG['tblNamePrefix'].'playlog';
$CC_CONFIG['scheduleTable'] = $CC_CONFIG['tblNamePrefix'].'schedule';
$CC_CONFIG['backupTable'] = $CC_CONFIG['tblNamePrefix'].'backup';
$CC_CONFIG['playListTimeView'] = $CC_CONFIG['tblNamePrefix'].'playlisttimes';
$CC_CONFIG['playListSequence'] = $CC_CONFIG['playListTable'].'_id';
$CC_CONFIG['filesSequence'] = $CC_CONFIG['filesTable'].'_id';
$CC_CONFIG['transSequence'] = $CC_CONFIG['transTable'].'_id';
$CC_CONFIG['prefSequence'] = $CC_CONFIG['prefTable'].'_id';
$CC_CONFIG['permSequence'] = $CC_CONFIG['permTable'].'_id';
$CC_CONFIG['subjSequence'] = $CC_CONFIG['subjTable'].'_id';
$CC_CONFIG['smembSequence'] = $CC_CONFIG['smembTable'].'_id';
$CC_CONFIG['sysSubjs'] = array(
'root', /*$CC_CONFIG['AdminsGr'],*/ /*$CC_CONFIG['AllGr'],*/ $CC_CONFIG['StationPrefsGr']
);
$old_include_path = get_include_path();
set_include_path('.'.PATH_SEPARATOR.$CC_CONFIG['pearPath'].PATH_SEPARATOR.$old_include_path);
// see if a ~/.campcaster/storageServer.conf.php exists, and
// overwrite the settings from there if any
$this_file = null;
if (isset($_SERVER["SCRIPT_FILENAME"])) {
$this_file = $_SERVER["SCRIPT_FILENAME"];
} elseif(isset($argv[0])) {
$this_file = $argv[0];
}
if (!is_null($this_file)) {
$fileowner_id = fileowner($this_file);
$fileowner_array = posix_getpwuid($fileowner_id);
$fileowner_homedir = $fileowner_array['dir'];
$fileowner_name = $fileowner_array['name'];
$home_conf = $fileowner_homedir . '/.campcaster/storageServer.conf.php';
if (file_exists($home_conf)) {
$default_config = $CC_CONFIG;
$developer_name = $fileowner_name;
include($home_conf);
$user_config = $CC_CONFIG;
$CC_CONFIG = $user_config + $default_config;
}
}
// workaround for missing folders
foreach (array('storageDir', 'bufferDir', 'transDir', 'accessDir', 'pearPath', 'cronDir') as $d) {
$test = file_exists($CC_CONFIG[$d]);
if ( $test === FALSE ) {
@mkdir($CC_CONFIG[$d], 02775);
if (file_exists($CC_CONFIG[$d])) {
$rp = realpath($CC_CONFIG[$d]);
//echo " * Directory $rp created\n";
} else {
echo " * Failed creating {$CC_CONFIG[$d]}\n";
exit(1);
}
} else {
$rp = realpath($CC_CONFIG[$d]);
}
$CC_CONFIG[$d] = $rp;
}
?>

163
3rd_party/storageServer/var/conf.php.template vendored
View file

@ -1,163 +0,0 @@
<?php
/**
* StorageServer configuration file
*
* configuration structure:
*
* <dl>
* <dt>dsn<dd> datasource setting
* <dt>tblNamePrefix <dd>prefix for table names in the database
* <dt>authCookieName <dd>secret token cookie name
* <dt>AdminsGr <dd>name of admin group
* <dt>StationPrefsGr <dd>name of station preferences group
* <dt>AllGr <dd>name of 'all users' group
* <dt>TrashName <dd>name of trash folder (subfolder of the storageRoot)
* <dt>storageDir <dd>main directory for storing binary media files
* <dt>bufferDir <dd>directory for temporary files
* <dt>transDir <dd>directory for incomplete transferred files
* <dt>accessDir <dd>directory for symlinks to accessed files
* <dt>isArchive <dd>local/central flag
* <dt>validate <dd>enable/disable validator
* <dt>useTrash <dd>enable/disable safe delete (move to trash)
* <dt>storageUrlPath<dd>path-URL-part of storageServer base dir
* <dt>storageXMLRPC<dd>XMLRPC server script address relative to storageUrlPath
* <dt>storageUrlHost, storageUrlPort<dd>host and port of storageServer
* <dt>archiveUrlPath<dd>path-URL-part of archiveServer base dir
* <dt>archiveXMLRPC<dd>XMLRPC server script address relative to archiveUrlPath
* <dt>archiveUrlHost, archiveUrlPort<dd>host and port of archiveServer
* <dt>archiveAccountLogin, archiveAccountPass <dd>account info
* for login to archive
* <dt>sysSubjs<dd>system users/groups - cannot be deleted
* <dt>schedulerPass<dd>scheduler's password for storageServer access
* </dl>
*/
include("campcaster_version.php");
// these are the default values for the config
$CC_CONFIG = array(
/* ================================================== basic configuration */
'dsn' => array(
'username' => 'ls_dbuser',
'password' => 'ls_dbpassword',
'hostspec' => 'ls_dbserver',
'phptype' => 'pgsql',
'database' => 'ls_database',
),
'tblNamePrefix' => 'ls_',
/* ================================================ storage configuration */
'authCookieName'=> 'campcaster_session_id',
'AdminsGr' => 'Admins',
'StationPrefsGr'=> 'StationPrefs',
'AllGr' => 'All',
'TrashName' => 'trash_',
'storageDir' => dirname(__FILE__).'/../../storageServer/var/stor',
'bufferDir' => dirname(__FILE__).'/../../storageServer/var/stor/buffer',
'transDir' => dirname(__FILE__).'/../../storageServer/var/trans',
'accessDir' => dirname(__FILE__).'/../../storageServer/var/access',
'pearPath' => 'ls_lib_dir/pear',
'cronDir' => dirname(__FILE__).'/../../storageServer/var/cron',
'isArchive' => FALSE,
'validate' => TRUE,
'useTrash' => TRUE,
/* ==================================================== URL configuration */
'storageUrlPath' => 'ls_storageUrlPath',
'storageXMLRPC' => 'xmlrpc/xrLocStor.php',
'storageUrlHost' => 'ls_php_host',
'storageUrlPort' => ls_php_port,
/* ================================================ archive configuration */
'archiveUrlPath' => 'ls_storageUrlPath',
'archiveXMLRPC' => 'xmlrpc/xrLocStor.php',
'archiveUrlHost' => 'ls_php_host',
'archiveUrlPort' => ls_php_port,
'archiveAccountLogin' => 'root',
'archiveAccountPass' => 'q',
/* ============================================== scheduler configuration */
'schedulerUrlPath' => 'ls_scheduler_urlPrefix',
'schedulerXMLRPC' => 'ls_scheduler_xmlRpcPrefix',
'schedulerUrlHost' => 'ls_scheduler_host',
'schedulerUrlPort' => ls_scheduler_port,
'schedulerPass' => 'ls_scheduler_storage_pass',
/* ==================================== aplication-specific configuration */
'objtypes' => array(
'RootNode' => array('Folder'),
'Storage' => array('Folder', 'File', 'Replica'),
'Folder' => array('Folder', 'File', 'Replica'),
'File' => array(),
'audioclip' => array(),
'playlist' => array(),
'Replica' => array(),
),
'allowedActions'=> array(
'RootNode' => array('classes', 'subjects'),
'Folder' => array('editPrivs', 'write', 'read'),
'File' => array('editPrivs', 'write', 'read'),
'audioclip' => array('editPrivs', 'write', 'read'),
'playlist' => array('editPrivs', 'write', 'read'),
'Replica' => array('editPrivs', 'write', 'read'),
'_class' => array('editPrivs', 'write', 'read'),
),
'allActions' => array(
'editPrivs', 'write', 'read', 'classes', 'subjects'
),
/* ============================================== auxiliary configuration */
'RootNode' => 'RootNode',
'tmpRootPass' => 'q',
/* =================================================== cron configuration */
'cronUserName' => 'ls_apache_group',
'lockfile' => dirname(__FILE__).'/cron/cron.lock',
'cronfile' => dirname(__FILE__).'/cron/croncall.php',
'paramdir' => dirname(__FILE__).'/cron/params',
);
// Add database table names
$CC_CONFIG['filesTable'] = $CC_CONFIG['tblNamePrefix'].'files';
$CC_CONFIG['mdataTable'] = $CC_CONFIG['tblNamePrefix'].'mdata';
$CC_CONFIG['accessTable'] = $CC_CONFIG['tblNamePrefix'].'access';
$CC_CONFIG['permTable'] = $CC_CONFIG['tblNamePrefix'].'perms';
$CC_CONFIG['sessTable'] = $CC_CONFIG['tblNamePrefix'].'sess';
$CC_CONFIG['subjTable'] = $CC_CONFIG['tblNamePrefix'].'subjs';
$CC_CONFIG['smembTable'] = $CC_CONFIG['tblNamePrefix'].'smemb';
$CC_CONFIG['classTable'] = $CC_CONFIG['tblNamePrefix'].'classes';
$CC_CONFIG['cmembTable'] = $CC_CONFIG['tblNamePrefix'].'cmemb';
$CC_CONFIG['treeTable'] = $CC_CONFIG['tblNamePrefix'].'tree';
$CC_CONFIG['structTable'] = $CC_CONFIG['tblNamePrefix'].'struct';
$CC_CONFIG['transTable'] = $CC_CONFIG['tblNamePrefix'].'trans';
$CC_CONFIG['prefTable'] = $CC_CONFIG['tblNamePrefix'].'pref';
$CC_CONFIG['playlogTable'] = 'playlog';
$CC_CONFIG['scheduleTable'] = 'schedule';
$CC_CONFIG['backupTable'] = 'backup';
$CC_CONFIG['sysSubjs'] = array(
'root', $CC_CONFIG['AdminsGr'], $CC_CONFIG['AllGr'], $CC_CONFIG['StationPrefsGr']
);
$old_ip = get_include_path();
set_include_path('.'.PATH_SEPARATOR.$CC_CONFIG['pearPath'].PATH_SEPARATOR.$old_ip);
// workaround for missing folders
foreach (array('storageDir', 'bufferDir', 'transDir', 'accessDir', 'pearPath', 'cronDir') as $d) {
$test = file_exists($CC_CONFIG[$d]);
if ( $test === FALSE ) {
@mkdir($CC_CONFIG[$d], 02775);
if (file_exists($CC_CONFIG[$d])) {
$rp = realpath($CC_CONFIG[$d]);
//echo " * Directory $rp created\n";
} else {
echo " * Failed creating {$CC_CONFIG[$d]}\n";
exit(1);
}
} else {
$rp = realpath($CC_CONFIG[$d]);
}
$CC_CONFIG[$d] = $rp;
}
?>

65
3rd_party/storageServer/var/conf_only.php.template vendored
View file

@ -1,65 +0,0 @@
<?php
/**
* StorageServer configuration file
*
* configuration structure:
*
* <dl>
* <dt>dsn<dd> datasource setting
* <dt>tblNamePrefix <dd>prefix for table names in the database
* <dt>authCookieName <dd>secret token cookie name
* <dt>StationPrefsGr <dd>name of station preferences group
* <dt>AllGr <dd>name of 'all users' group
* <dt>storageDir <dd>main directory for storing binary media files
* <dt>bufferDir <dd>directory for temporary files
* <dt>transDir <dd>directory for incomplete transferred files
* <dt>accessDir <dd>directory for symlinks to accessed files
* <dt>isArchive <dd>local/central flag
* <dt>validate <dd>enable/disable validator
* <dt>storageUrlPath<dd>path-URL-part of storageServer base dir
* <dt>storageXMLRPC<dd>XMLRPC server script address relative to storageUrlPath
* <dt>storageUrlHost, storageUrlPort<dd>host and port of storageServer
* <dt>archiveUrlPath<dd>path-URL-part of archiveServer base dir
* <dt>archiveXMLRPC<dd>XMLRPC server script address relative to archiveUrlPath
* <dt>archiveUrlHost, archiveUrlPort<dd>host and port of archiveServer
* <dt>archiveAccountLogin, archiveAccountPass <dd>account info
* for login to archive
* </dl>
*/
$CC_CONFIG = array(
/* ================================================== basic configuration */
'dsn' => array(
'username' => 'ls_dbuser',
'password' => 'ls_dbpassword',
'hostspec' => 'ls_dbserver',
'phptype' => 'pgsql',
'database' => 'ls_database',
),
/* ==================================================== URL configuration */
'storageUrlPath' => 'ls_storageUrlPath',
'storageXMLRPC' => 'xmlrpc/xrLocStor.php',
'storageUrlHost' => 'ls_php_host',
'storageUrlPort' => ls_php_port,
/* ================================================ archive configuration */
'archiveUrlPath' => 'ls_storageUrlPath',
'archiveXMLRPC' => 'xmlrpc/xrLocStor.php',
'archiveUrlHost' => 'ls_php_host',
'archiveUrlPort' => ls_php_port,
'archiveAccountLogin' => 'root',
'archiveAccountPass' => 'q',
/* ============================================== scheduler configuration */
'schedulerUrlPath' => 'ls_scheduler_urlPrefix',
'schedulerXMLRPC' => 'ls_scheduler_xmlRpcPrefix',
'schedulerUrlHost' => 'ls_scheduler_host',
'schedulerUrlPort' => ls_scheduler_port,
'schedulerPass' => 'ls_scheduler_storage_pass',
/* =================================================== cron configuration */
//'cronUserName' => 'www-data',
'cronUserName' => $developer_name,
);
?>

214
3rd_party/storageServer/var/cron/Cron.php vendored
View file

@ -1,214 +0,0 @@
<?php
require_once (dirname(__FILE__).'/Crontab.php');
require_once (dirname(__FILE__).'/../conf.php');
/**
* This class can call a PHP function from crontab.
* Example:
* <pre>
* $cron = new Cron();
* $access = $cron->openCrontab('write');
* if ($access != 'write') {
* do {
* $access = $cron->forceWriteable();
* } while ($access != 'write');
* }
* $cron->addCronJob('*','*','*','*','*',
* 'ClassName',
* array('first','secound','third')
* );
* $cron->closeCrontab();
* </pre>
* @package Campcaster
* @subpackage StorageServer.Cron
*/
class Cron {
/**
* @var Crontab
*/
public $ct;
/**
* @var array This array created with getCommand() function
*/
private $params;
/**
* @var string available values: read | write
*/
private $ctAccess = 'read';
private $lockfile;
private $cronfile;
private $paramdir;
private $cronUserName;
/**
* Constructor
*/
function Cron() {
global $CC_CONFIG;
$this->lockfile = $CC_CONFIG['lockfile'];
$this->cronfile = $CC_CONFIG['cronfile'];
$this->paramdir = $CC_CONFIG['paramdir'];
$this->cronUserName = $CC_CONFIG['cronUserName'];
}
/* ==================================================== Cronjob functions */
/**
* Add a cronjob to the crontab
*
* @access public
* @param string $m minute
* @param string $h hour
* @param string $dom day of month
* @param string $mo month
* @param string $dow day of week
* @param string $className name of class, which's execute() is called by croncall.php
* @param string $params the parameter(s)
* @return bool true if success else PEAR error.
*/
function addCronJob($m, $h, $dom, $mo, $dow, $className, $params)
{
if ($this->ctAccess == 'write') {
$this->ct->addCron($m, $h, $dom, $mo, $dow,
$this->getCommand($className, $params));
return true;
} else {
return PEAR::raiseError('CronJob::addCronJob : '.
'The crontab is not writable');
}
}
/**
* This function return with the active cronjobs
*
* @access public
* @return array array of cronjob struct
*/
function listCronJob()
{
return $this->ct->getByType(CRON_CMD);
}
/**
* Remove a cronjob.
*
* @access public
* @param int $index index of the cronjobs' array.
* @return bool true if success else PEAR error.
*/
function removeCronJob($index)
{
if ($this->ctAccess == 'write') {
$this->crontab->delEntry($index);
return true;
} else {
return PEAR::raiseError('CronJob::removeCronJob : '.
'The crontab is not writable');
}
}
/* ==================================================== Crontab functions */
/**
* Open the crontab
*
* @access public
* @param string $access only for listing 'read', for add and delete 'write'
* @return string sucessed access - available values read | write
*/
function openCrontab($access = 'read')
{
$access = strtolower($access);
$this->ct = new Crontab($this->cronUserName);
if ($access == 'write' &&
$this->isCrontabWritable() &&
$this->lockCrontab()) {
$this->ctAccess = $access;
} else {
$this->ctAccess = 'read';
}
return $this->ctAccess;
}
/**
* Close the crontab
*
* @access public
* @return bool true if everything is ok, false is the lock file can't delete
*/
function closeCrontab()
{
if ($this->ctAccess == 'write') {
$this->ct->writeCrontab();
}
return $this->ctAccess == 'write' ? $this->unlockCrontab() : true;
}
/**
* Check the crontab is writable
*
* @access private
* @return bool
*/
function isCrontabWritable()
{
return !is_file($this->lockfile);
}
/**
* Try to lock the crontab
*
* @access private
* @return bool true if the locking is success
*/
function lockCrontab()
{
return @touch($this->lockfile);
}
/**
* Try to unlock the crontab
*
* @access private
* @return bool true if the unlocking is success
*/
function unlockCrontab()
{
return unlink($this->lockfile);
}
/**
* If the crontab opened with read access. This function force set
* the access to write.
*
* @access public
* @return bool true if the setting is success
*/
function forceWriteable()
{
if ($this->isCrontabWritable() && $this->lockCrontab()) {
$this->ctAccess = 'write';
return true;
}
return false;
}
/* ======================================================= Misc functions */
/**
* Get the shell command for the cronjob
*
* @param string $className name of the class what is called by croncall.php
* @param mixed $params with this parameter could be called the execute() of class
* @return string shell command
*/
function getCommand($className, $params)
{
$this->params = array (
'class' => $className,
'params' => $params
);
return $this->cronfile.' "'.str_replace('"','\"',serialize($this->params)).'"';
}
}
?>

17
3rd_party/storageServer/var/cron/CronJob.php vendored
View file

@ -1,17 +0,0 @@
<?php
/**
* Cron jobs handling abstract class
*
* @package Campcaster
* @subpackage StorageServer.Cron
*/
class CronJob
{
/**
* The croncall.php call this function after the objectcreation.
*/
function execute()
{
}
}
?>

284
3rd_party/storageServer/var/cron/Crontab.php vendored
View file

@ -1,284 +0,0 @@
<?php
define('CRON_COMMENT', 0);
define('CRON_ASSIGN', 1);
define('CRON_CMD', 2);
define('CRON_SPECIAL', 3);
define('CRON_EMPTY', 4);
/**
* A class that interfaces with the crontab. (cjpa@audiophile.com)
*
* This class lets you manipulate a user's crontab.
* It lets you add delete update entries easily.
*
* @package Campcaster
* @subpackage StorageServer.Cron
*/
class Crontab
{
// {{{ properties
/**
* Holds all the different lines.
* Lines are associative arrays with the following fields:
* "minute" : holds the minutes (0-59)
* "hour" : holds the hour (0-23)
* "dayofmonth" : holds the day of the month (1-31)
* "month" : the month (1-12 or the names)
* "dayofweek" : 0-7 (or the names)
*
* or a line can be a 2-value array that represents an assignment:
* "name" => "value"
* or a line can be a comment (string beginning with #)
* or it can be a special command (beginning with an @)
* @var array
*/
private $crontabs;
/**
* The user for whom the crontab will be manipulated
* @var string
*/
private $user;
/**
* Lists the type of line of each line in $crontabs.
* can be: any of the CRON_* constants.
* so $linetype[5] is the type of $crontabs[5].
* @var string
*/
private $linetypes;
// }}}
/**
* Constructor
*
* Initialises $this->crontabs
*
* @param string $user the user for whom the crontab will be manipulated
*/
function Crontab($user)
{
$this->user = $user;
$this->readCrontab();
}
/**
* This reads the crontab of $this->user and parses it in $this->crontabs
*
*/
function readCrontab()
{
// return code is 0 or 1 if crontab was empty, elsewhere stop here
$cmd = "crontab -u {$this->user} -l";
@exec("crontab -u {$this->user} -l", $crons, $return);
if ($return > 1) {
return PEAR::raiseError("*** Can't read crontab ***\n".
" Set crontab manually!\n");
}
foreach ($crons as $line)
{
$line = trim($line); // discarding all prepending spaces and tabs
// empty lines..
if (!$line) {
$this->crontabs[] = "empty line";
$this->linetypes[] = CRON_EMPTY;
continue;
}
// checking if this is a comment
if ($line[0] == "#") {
$this->crontabs[] = trim($line);
$this->linetypes[] = CRON_COMMENT;
continue;
}
// Checking if this is an assignment
if (ereg("(.*)=(.*)", $line, $assign)) {
$this->crontabs[] = array ("name" => $assign[1], "value" => $assign[2]);
$this->linetypes[] = CRON_ASSIGN;
continue;
}
// Checking if this is a special @-entry. check man 5 crontab for more info
if ($line[0] == '@') {
$this->crontabs[] = split("[ \t]", $line, 2);
$this->linetypes[] = CRON_SPECIAL;
continue;
}
// It's a regular crontab-entry
$ct = split("[ \t]", $line, 6);
$this->addCron($ct[0], $ct[1], $ct[2], $ct[3], $ct[4], $ct[5]);
}
}
/**
* Writes the current crontab
*/
function writeCrontab()
{
global $DEBUG, $PATH;
if (empty($this->linetypes)) {
return;
}
$filename = ($DEBUG ? tempnam("$PATH/crons", "cron") : tempnam("/tmp", "cron"));
$file = fopen($filename, "w");
foreach($this->linetypes as $i => $line) {
switch ($this->linetypes[$i]) {
case CRON_COMMENT:
$line = $this->crontabs[$i];
break;
case CRON_ASSIGN:
$line = $this->crontabs[$i][name]." = ".$this->crontabs[$i][value];
break;
case CRON_CMD:
$line = implode(" ", $this->crontabs[$i]);
break;
case CRON_SPECIAL:
$line = implode(" ", $this->crontabs[$i]);
break;
case CRON_EMPTY:
$line = "\n"; // an empty line in the crontab-file
break;
default:
unset($line);
echo "Something very weird is going on. This line ($i) has an unknown type.\n";
break;
}
// echo "line $i : $line\n";
if ($line) {
$r = @fwrite($file, $line."\n");
if($r === FALSE) {
return PEAR::raiseError("*** Can't write crontab ***\n".
" Set crontab manually!\n");
}
}
}
fclose($file);
if ($DEBUG) {
echo "DEBUGMODE: not updating crontab. writing to $filename instead.\n";
} else {
exec("crontab -u {$this->user} $filename", $returnar, $return);
if ($return != 0) {
echo "Error running crontab ($return). $filename not deleted\n";
} else {
unlink($filename);
}
}
}
/**
* Add a item of type CRON_CMD to the end of $this->crontabs
*
* @param string $m
* minute
* @param string $h
* hour
* @param string $dom
* day of month
* @param string $mo
* month
* @param string $dow
* day of week
* @param string $cmd
* command
*
*/
function addCron($m, $h, $dom, $mo, $dow, $cmd)
{
$this->crontabs[] = array ("minute" => $m, "hour" => $h, "dayofmonth" => $dom, "month" => $mo, "dayofweek" => $dow, "command" => $cmd);
$this->linetypes[] = CRON_CMD;
}
/**
* Add a comment to the cron to the end of $this->crontabs
*
* @param string $comment
*/
function addComment($comment)
{
$this->crontabs[] = "# $comment\n";
$this->linetypes[] = CRON_COMMENT;
}
/**
* Add a special command (check man 5 crontab for more information)
*
* @param string $sdate special date
* string meaning
* ------ -------
* @reboot Run once, at startup.
* @yearly Run once a year, "0 0 1 1 *".
* @annually (same as @yearly)
* @monthly Run once a month, "0 0 1 * *".
* @weekly Run once a week, "0 0 * * 0".
* @daily Run once a day, "0 0 * * *".
* @midnight (same as @daily)
* @hourly Run once an hour, "0 * * * *".
* @param string $cmd command
*/
function addSpecial($sdate, $cmd)
{
$this->crontabs[] = array ("special" => $sdate, "command" => $cmd);
$this->linetypes[] = CRON_SPECIAL;
}
/**
* Add an assignment (name = value)
*
* @param string $name
* @param string $value
*/
function addAssign($name, $value)
{
$this->crontabs[] = array ("name" => $name, "value" => $value);
$this->linetypes[] = CRON_ASSIGN;
}
/**
* Delete a line from the arrays.
*
* @param int $index the index in $this->crontabs
*/
function delEntry($index)
{
unset ($this->crontabs[$index]);
unset ($this->linetypes[$index]);
}
/**
* Get all the lines of a certain type in an array
*
* @param string $type
*/
function getByType($type)
{
if ($type < CRON_COMMENT || $type > CRON_EMPTY)
{
trigger_error("Wrong type: $type", E_USER_WARNING);
return 0;
}
$returnar = array ();
for ($i = 0; $i < count($this->linetypes); $i ++)
if ($this->linetypes[$i] == $type)
$returnar[] = $this->crontabs[$i];
return $returnar;
}
}
?>

9
3rd_party/storageServer/var/cron/croncall.php vendored
View file

@ -1,9 +0,0 @@
#!/usr/bin/php
<?php
chdir(dirname(__FILE__));
$p = unserialize($argv[1]);
require_once (dirname(__FILE__).'/'.$p['class'].'.php');
$cronjob = new $p['class']();
$ret = $cronjob->execute($p['params']);
exit(0);
?>

21
3rd_party/storageServer/var/cron/transportCron.php vendored
View file

@ -1,21 +0,0 @@
#!/usr/bin/php
<?php
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->setErrorHandling(PEAR_ERROR_RETURN);
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
$gb = new LocStor();
$tr = new Transport($gb);
$r = $tr->cronMain();
if (!$r) {
exit(1);
}
exit(0);
?>

42
3rd_party/storageServer/var/cron/transportCronJob.php vendored
View file

@ -1,42 +0,0 @@
#!/usr/bin/php
<?php
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->setErrorHandling(PEAR_ERROR_RETURN);
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
$gb = new LocStor();
$tr = new Transport($gb);
$pid = getmypid();
list(, $trtok) = $_SERVER['argv'];
if (TR_LOG_LEVEL > 1) {
$tr->trLog("transportCronJob($pid) start ($trtok)");
}
// 4-pass on job:
$cnt = 4;
for ($i = 0; $i < $cnt; $i++, sleep(1)) {
// run the action:
$r = $tr->cronCallMethod($trtok);
if (PEAR::isError($r)) {
$tr->trLogPear("transportCronJob($pid): ($trtok): ", $r);
} else {
# $tr->trLog("X transportCronJob: ".var_export($r, TRUE));
if ($r !== TRUE) {
$tr->trLog("transportCronJob($pid): ($trtok): nonTRUE returned");
}
}
#if(!$r) exit(1);
#sleep(2);
}
if (TR_LOG_LEVEL>1) {
$tr->trLog("transportCronJob($pid) end ($trtok)");
}
exit(0);
?>

13
3rd_party/storageServer/var/emptyMdata.xml vendored
View file

@ -1,13 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<audioClip>
<metadata
xmlns="http://mdlf.org/campcaster/elements/1.0/"
xmlns:ls="http://mdlf.org/campcaster/elements/1.0/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:xml="http://www.w3.org/XML/1998/namespace"
>
<dc:title>Empty file</dc:title>
<dcterms:extent>00:00:00.000000</dcterms:extent>
</metadata>
</audioClip>

10
3rd_party/storageServer/var/emptyPlaylist.xml vendored
View file

@ -1,10 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<playlist id="0000000000000000" playlength="00:00:00.000000">
<metadata
xmlns="http://mdlf.org/campcaster/elements/1.0/"
xmlns:ls="http://mdlf.org/campcaster/elements/1.0/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:xml="http://www.w3.org/XML/1998/namespace"
/>
</playlist>

14
3rd_party/storageServer/var/emptyWebstream.xml vendored
View file

@ -1,14 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<audioClip>
<metadata
xmlns="http://mdlf.org/campcaster/elements/1.0/"
xmlns:ls="http://mdlf.org/campcaster/elements/1.0/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:xml="http://www.w3.org/XML/1998/namespace"
>
<ls:url></ls:url>
<dc:title>Empty file</dc:title>
<dcterms:extent>00:00:00.000000</dcterms:extent>
</metadata>
</audioClip>

136
3rd_party/storageServer/var/genres.xml vendored
View file

@ -1,136 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE options [
<!ELEMENT options (option*) >
<!ELEMENT option (label+) >
<!ELEMENT label (#PCDATA) >
<!ATTLIST option id CDATA #REQUIRED >
<!ATTLIST label xml:lang CDATA #IMPLIED >
]>
<options>
<option id="Blues"><label>Blues</label></option>
<option id="Classic Rock"><label>Classic Rock</label></option>
<option id="Country"><label>Country</label></option>
<option id="Dance"><label>Dance</label></option>
<option id="Disco"><label>Disco</label></option>
<option id="Funk"><label>Funk</label></option>
<option id="Grunge"><label>Grunge</label></option>
<option id="Hip-Hop"><label>Hip-Hop</label></option>
<option id="Jazz"><label>Jazz</label></option>
<option id="Metal"><label>Metal</label></option>
<option id="New Age"><label>New Age</label></option>
<option id="Oldies"><label>Oldies</label></option>
<option id="Other"><label>Other</label></option>
<option id="Pop"><label>Pop</label></option>
<option id="R&amp;B"><label>R&amp;B</label></option>
<option id="Rap"><label>Rap</label></option>
<option id="Reggae"><label>Reggae</label></option>
<option id="Rock"><label>Rock</label></option>
<option id="Techno"><label>Techno</label></option>
<option id="Industrial"><label>Industrial</label></option>
<option id="Alternative"><label>Alternative</label></option>
<option id="Ska"><label>Ska</label></option>
<option id="Death Metal"><label>Death Metal</label></option>
<option id="Pranks"><label>Pranks</label></option>
<option id="Soundtrack"><label>Soundtrack</label></option>
<option id="Euro-Techno"><label>Euro-Techno</label></option>
<option id="Ambient"><label>Ambient</label></option>
<option id="Trip-Hop"><label>Trip-Hop</label></option>
<option id="Vocal"><label>Vocal</label></option>
<option id="Jazz+Funk"><label>Jazz+Funk</label></option>
<option id="Fusion"><label>Fusion</label></option>
<option id="Trance"><label>Trance</label></option>
<option id="Classical"><label>Classical</label></option>
<option id="Instrumental"><label>Instrumental</label></option>
<option id="Acid"><label>Acid</label></option>
<option id="House"><label>House</label></option>
<option id="Game"><label>Game</label></option>
<option id="Sound Clip"><label>Sound Clip</label></option>
<option id="Gospel"><label>Gospel</label></option>
<option id="Noise"><label>Noise</label></option>
<option id="AlternRock"><label>AlternRock</label></option>
<option id="Bass"><label>Bass</label></option>
<option id="Soul"><label>Soul</label></option>
<option id="Punk"><label>Punk</label></option>
<option id="Space"><label>Space</label></option>
<option id="Meditative"><label>Meditative</label></option>
<option id="Instrumental Pop"><label>Instrumental Pop</label></option>
<option id="Instrumental Rock"><label>Instrumental Rock</label></option>
<option id="Ethnic"><label>Ethnic</label></option>
<option id="Gothic"><label>Gothic</label></option>
<option id="Darkwave"><label>Darkwave</label></option>
<option id="Techno-Industrial"><label>Techno-Industrial</label></option>
<option id="Electronic"><label>Electronic</label></option>
<option id="Pop-Folk"><label>Pop-Folk</label></option>
<option id="Eurodance"><label>Eurodance</label></option>
<option id="Dream"><label>Dream</label></option>
<option id="Southern Rock"><label>Southern Rock</label></option>
<option id="Comedy"><label>Comedy</label></option>
<option id="Cult"><label>Cult</label></option>
<option id="Gangsta"><label>Gangsta</label></option>
<option id="Top 40"><label>Top 40</label></option>
<option id="Christian Rap"><label>Christian Rap</label></option>
<option id="Pop/Funk"><label>Pop/Funk</label></option>
<option id="Jungle"><label>Jungle</label></option>
<option id="Native American"><label>Native American</label></option>
<option id="Cabaret"><label>Cabaret</label></option>
<option id="New Wave"><label>New Wave</label></option>
<option id="Psychadelic"><label>Psychadelic</label></option>
<option id="Rave"><label>Rave</label></option>
<option id="Showtunes"><label>Showtunes</label></option>
<option id="Trailer"><label>Trailer</label></option>
<option id="Lo-Fi"><label>Lo-Fi</label></option>
<option id="Tribal"><label>Tribal</label></option>
<option id="Acid Punk"><label>Acid Punk</label></option>
<option id="Acid Jazz"><label>Acid Jazz</label></option>
<option id="Polka"><label>Polka</label></option>
<option id="Retro"><label>Retro</label></option>
<option id="Musical"><label>Musical</label></option>
<option id="Rock &amp; Roll"><label>Rock &amp; Roll</label></option>
<option id="Hard Rock"><label>Hard Rock</label></option>
<option id="Folk"><label>Folk</label></option>
<option id="Folk-Rock"><label>Folk-Rock</label></option>
<option id="National Folk"><label>National Folk</label></option>
<option id="Swing"><label>Swing</label></option>
<option id="Fast Fusion"><label>Fast Fusion</label></option>
<option id="Bebob"><label>Bebob</label></option>
<option id="Latin"><label>Latin</label></option>
<option id="Revival"><label>Revival</label></option>
<option id="Celtic"><label>Celtic</label></option>
<option id="Bluegrass"><label>Bluegrass</label></option>
<option id="Avantgarde"><label>Avantgarde</label></option>
<option id="Gothic Rock"><label>Gothic Rock</label></option>
<option id="Progressive Rock"><label>Progressive Rock</label></option>
<option id="Psychedelic Rock"><label>Psychedelic Rock</label></option>
<option id="Symphonic Rock"><label>Symphonic Rock</label></option>
<option id="Slow Rock"><label>Slow Rock</label></option>
<option id="Big Band"><label>Big Band</label></option>
<option id="Chorus"><label>Chorus</label></option>
<option id="Easy Listening"><label>Easy Listening</label></option>
<option id="Acoustic"><label>Acoustic</label></option>
<option id="Humour"><label>Humour</label></option>
<option id="Speech"><label>Speech</label></option>
<option id="Chanson"><label>Chanson</label></option>
<option id="Opera"><label>Opera</label></option>
<option id="Chamber Music"><label>Chamber Music</label></option>
<option id="Sonata"><label>Sonata</label></option>
<option id="Symphony"><label>Symphony</label></option>
<option id="Booty Bass"><label>Booty Bass</label></option>
<option id="Primus"><label>Primus</label></option>
<option id="Porn Groove"><label>Porn Groove</label></option>
<option id="Satire"><label>Satire</label></option>
<option id="Slow Jam"><label>Slow Jam</label></option>
<option id="Club"><label>Club</label></option>
<option id="Tango"><label>Tango</label></option>
<option id="Samba"><label>Samba</label></option>
<option id="Folklore"><label>Folklore</label></option>
<option id="Ballad"><label>Ballad</label></option>
<option id="Power Ballad"><label>Power Ballad</label></option>
<option id="Rhythmic Soul"><label>Rhythmic Soul</label></option>
<option id="Freestyle"><label>Freestyle</label></option>
<option id="Duet"><label>Duet</label></option>
<option id="Punk Rock"><label>Punk Rock</label></option>
<option id="Drum Solo"><label>Drum Solo</label></option>
<option id="A capella"><label>A capella</label></option>
<option id="Euro-House"><label>Euro-House</label></option>
<option id="Dance Hall"><label>Dance Hall</label></option>
</options>

17
3rd_party/storageServer/var/index.php vendored
View file

@ -1,17 +0,0 @@
<?php
header ("location: html/");
exit;
/*
?>
<html><head>
<title>StorageServer module</title>
</head><body>
<h3>StorageServer module</h3>
<br>
<a href="../html/" accesskey="H"><b>H</b>TML client</a><br>
<a href="../xmlrpc/" accesskey="X"><b>X</b>mlRpc test</a><br>
<a href="../tests/" accesskey="T"><b>T</b>est</a><br>
</body></html>
<?
*/
?>

102
3rd_party/storageServer/var/install/campcaster-user.php vendored
View file

@ -1,102 +0,0 @@
#!/usr/bin/php
<?php
require_once(dirname(__FILE__).'/../conf.php');
require_once(dirname(__FILE__).'/../Subjects.php');
require_once('DB.php');
require_once('Console/Getopt.php');
// Do not allow remote execution
$arr = array_diff_assoc($_SERVER, $_ENV);
if (isset($arr["DOCUMENT_ROOT"]) && ($arr["DOCUMENT_ROOT"] != "") ) {
header("HTTP/1.1 400");
header("Content-type: text/plain; charset=UTF-8");
echo "400 Not executable\r\n";
exit(1);
}
function printUsage()
{
echo "\n";
echo "campcaster-user\n";
echo "===============\n";
echo " This program allows you to manage Campcaster users.\n";
echo "\n";
echo "OPTIONS:\n";
echo " --addupdate <username> <password>\n";
echo " Add the user or update the password for the user.\n";
echo " --delete <username>\n";
echo " Remove the user.\n";
echo "\n";
}
$parsedCommandLine = Console_Getopt::getopt($argv, null, array("addupdate", "delete"));
if (PEAR::isError($parsedCommandLine)) {
printUsage();
exit(1);
}
$cmdLineOptions = $parsedCommandLine[0];
if (count($parsedCommandLine[1]) == 0) {
printUsage();
exit;
}
$action = null;
foreach ($cmdLineOptions as $tmpValue) {
$optionName = $tmpValue[0];
$optionValue = $tmpValue[1];
switch ($optionName) {
case '--addupdate':
$action = "addupdate";
break 2;
case "--delete":
$action = "delete";
break 2;
}
}
if (is_null($action)) {
printUsage();
exit;
}
if (count($parsedCommandLine) < 1) {
printUsage();
exit;
}
$username = $parsedCommandLine[1][0];
$password = $parsedCommandLine[1][1];
PEAR::setErrorHandling(PEAR_ERROR_RETURN);
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
if (PEAR::isError($CC_DBC)) {
die($CC_DBC->getMessage());
}
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
// Check if the user exists
$user = Subjects::GetSubject($username);
if ($action == "addupdate") {
if (empty($password)) {
printUsage();
exit;
}
if (empty($user)) {
// Add the user.
$r = Subjects::AddSubj($username, $password);
} else {
// Update the password
$r = Subjects::Passwd($username, NULL, $password);
}
} elseif (($action == "delete") && (is_array($user))) {
// Delete the user
$r = Subjects::RemoveSubj($username);
}
if (PEAR::isError($r)) {
die($r->getMessage());
}
exit(0);
?>

14
3rd_party/storageServer/var/install/getGname.php vendored
View file

@ -1,14 +0,0 @@
<?php
/*------------------------------------------------------------------------------
* This (web-callable) script returns group running httpd
*----------------------------------------------------------------------------*/
header("Content-type: text/plain");
$egid = posix_getegid();
$info = posix_getgrgid($egid);
if ( (isset($_SERVER["REMOTE_ADDR"]) && ($_SERVER["REMOTE_ADDR"] == "127.0.0.1"))
|| (isset($_SERVER["HTTP_HOST"]) && ($_SERVER["HTTP_HOST"] == "localhost"))
|| (isset($_SERVER["SHELL"])) ) {
echo $info['name'];
}
?>

13
3rd_party/storageServer/var/install/getPwd.php vendored
View file

@ -1,13 +0,0 @@
<?php
/*------------------------------------------------------------------------------
* This script returns real dir of php scipts for debugging purposes
*----------------------------------------------------------------------------*/
header("Content-type: text/plain");
//var_dump($_SERVER);
if ( (isset($_SERVER["REMOTE_ADDR"]) && ($_SERVER["REMOTE_ADDR"] == "127.0.0.1"))
|| (isset($_SERVER["HTTP_HOST"]) && ($_SERVER["HTTP_HOST"] == "localhost"))
|| (isset($_SERVER["SHELL"])) ) {
echo `pwd`;
}
?>

10
3rd_party/storageServer/var/install/getWwwRoot.php vendored
View file

@ -1,10 +0,0 @@
<?php
/*------------------------------------------------------------------------------
* This script returns storage root URL
*----------------------------------------------------------------------------*/
header("Content-type: text/plain");
require("../conf.php");
echo "http://{$CC_CONFIG['storageUrlHost']}:{$CC_CONFIG['storageUrlPort']}".
"{$CC_CONFIG['storageUrlPath']}";
?>

10
3rd_party/storageServer/var/install/getXrUrl.php vendored
View file

@ -1,10 +0,0 @@
<?php
/*------------------------------------------------------------------------------
* This script returns storage XMLRPC root URL
*----------------------------------------------------------------------------*/
header("Content-type: text/plain");
require("../conf.php");
echo "http://{$CC_CONFIG['storageUrlHost']}:{$CC_CONFIG['storageUrlPort']}".
"{$CC_CONFIG['storageUrlPath']}/{$CC_CONFIG['storageXMLRPC']}";
?>

4
3rd_party/storageServer/var/install/index.php vendored
View file

@ -1,4 +0,0 @@
<?php
header ("location: ../");
exit;
?>

602
3rd_party/storageServer/var/install/install.php vendored
View file

@ -1,602 +0,0 @@
<?php
/**
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*
*/
// Do not allow remote execution
$arr = array_diff_assoc($_SERVER, $_ENV);
if (isset($arr["DOCUMENT_ROOT"]) && ($arr["DOCUMENT_ROOT"] != "") ) {
header("HTTP/1.1 400");
header("Content-type: text/plain; charset=UTF-8");
echo "400 Not executable\r\n";
exit(1);
}
echo "*************************\n";
echo "* StorageServer Install *\n";
echo "*************************\n";
require_once(dirname(__FILE__).'/../conf.php');
require_once(dirname(__FILE__).'/../GreenBox.php');
require_once(dirname(__FILE__)."/installInit.php");
campcaster_db_connect(true);
$langIsInstalled = $CC_DBC->GetOne('select count(*) FROM pg_language WHERE lanname = \'plpgsql\'');
if ($langIsInstalled == '0') {
echo " * Installing Postgres scripting language\n";
$sql = "CREATE LANGUAGE 'plpgsql'";
camp_install_query($sql);
} else {
echo " * Postgres scripting language already installed\n";
}
//------------------------------------------------------------------------------
// Install database tables
//------------------------------------------------------------------------------
if (!camp_db_table_exists($CC_CONFIG['subjTable'])) {
echo " * Creating database table ".$CC_CONFIG['subjTable']."...";
$sql = "CREATE TABLE ".$CC_CONFIG['subjTable']." (
id int not null PRIMARY KEY,
login varchar(255) not null default'',
pass varchar(255) not null default'',
type char(1) not null default 'U',
realname varchar(255) not null default'',
lastlogin timestamp,
lastfail timestamp
)";
camp_install_query($sql, false);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['subjTable']."_id_idx
ON ".$CC_CONFIG['subjTable']." (id)";
camp_install_query($sql, false);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['subjTable']."_login_idx
ON ".$CC_CONFIG['subjTable']." (login)";
camp_install_query($sql, false);
$CC_DBC->createSequence($CC_CONFIG['subjSequence']);
echo "done.\n";
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['subjTable']."\n";
}
if (!camp_db_table_exists($CC_CONFIG['smembTable'])) {
echo " * Creating database table ".$CC_CONFIG['smembTable']."...";
$sql = "CREATE TABLE ".$CC_CONFIG['smembTable']." (
id int not null PRIMARY KEY,
uid int not null default 0,
gid int not null default 0,
level int not null default 0,
mid int)";
camp_install_query($sql, false);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['smembTable']."_id_idx
ON ".$CC_CONFIG['smembTable']." (id)";
camp_install_query($sql, false);
//$CC_DBC->createSequence($CC_CONFIG['smembSequence']);
echo "done.\n";
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['smembTable']."\n";
}
if (!camp_db_table_exists($CC_CONFIG['permTable'])) {
echo " * Creating database table ".$CC_CONFIG['permTable']."...";
$sql = "CREATE TABLE ".$CC_CONFIG['permTable']." (
permid int not null PRIMARY KEY,
subj int REFERENCES ".$CC_CONFIG['subjTable']." ON DELETE CASCADE,
action varchar(20),
obj int,
type char(1))";
camp_install_query($sql, false);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['permTable']."_permid_idx
ON ".$CC_CONFIG['permTable']." (permid)";
camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['permTable']."_subj_obj_idx
ON ".$CC_CONFIG['permTable']." (subj, obj)";
camp_install_query($sql, false);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['permTable']."_all_idx
ON ".$CC_CONFIG['permTable']." (subj, action, obj)";
camp_install_query($sql, false);
//$CC_DBC->createSequence($CC_CONFIG['permSequence']);
echo "done.\n";
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['permTable']."\n";
}
if (!camp_db_table_exists($CC_CONFIG['sessTable'])) {
echo " * Creating database table ".$CC_CONFIG['sessTable']."...";
$sql = "CREATE TABLE ".$CC_CONFIG['sessTable']." (
sessid char(32) not null PRIMARY KEY,
userid int REFERENCES ".$CC_CONFIG['subjTable']." ON DELETE CASCADE,
login varchar(255),
ts timestamp)";
camp_install_query($sql, false);
// $sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['sessTable']."_sessid_idx
// ON ".$CC_CONFIG['sessTable']." (sessid)";
// camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['sessTable']."_userid_idx
ON ".$CC_CONFIG['sessTable']." (userid)";
camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['sessTable']."_login_idx
ON ".$CC_CONFIG['sessTable']." (login)";
camp_install_query($sql);
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['sessTable']."\n";
}
/**
* file states:
* <ul>
* <li>empty</li>
* <li>incomplete</li>
* <li>ready</li>
* <li>edited</li>
* <li>deleted</li>
* </ul>
* file types:
* <ul>
* <li>audioclip</li>
* <li>playlist</li>
* <li>webstream</li>
* </ul>
* access types:
* <ul>
* <li>access</li>
* <li>download</li>
* </ul>
*/
if (!camp_db_table_exists($CC_CONFIG['filesTable'])) {
echo " * Creating database table ".$CC_CONFIG['filesTable']."...";
$sql =
"CREATE TABLE ".$CC_CONFIG['filesTable']."
(
id serial NOT NULL,
gunid bigint NOT NULL,
\"name\" character varying(255) NOT NULL DEFAULT ''::character varying,
mime character varying(255) NOT NULL DEFAULT ''::character varying,
ftype character varying(128) NOT NULL DEFAULT ''::character varying,
state character varying(128) NOT NULL DEFAULT 'empty'::character varying,
currentlyaccessing integer NOT NULL DEFAULT 0,
editedby integer,
mtime timestamp(6) with time zone,
md5 character(32),
track_title character varying(512),
artist_name character varying(512),
bit_rate character varying(32),
sample_rate character varying(32),
format character varying(128),
length time without time zone,
album_title character varying(512),
genre character varying(64),
comments text,
\"year\" character varying(16),
track_number integer,
channels integer,
url character varying(1024),
bpm character varying(8),
rating character varying(8),
encoded_by character varying(255),
disc_number character varying(8),
mood character varying(64),
label character varying(512),
composer character varying(512),
encoder character varying(64),
checksum character varying(256),
lyrics text,
orchestra character varying(512),
conductor character varying(512),
lyricist character varying(512),
original_lyricist character varying(512),
radio_station_name character varying(512),
info_url character varying(512),
artist_url character varying(512),
audio_source_url character varying(512),
radio_station_url character varying(512),
buy_this_url character varying(512),
isrc_number character varying(512),
catalog_number character varying(512),
original_artist character varying(512),
copyright character varying(512),
report_datetime character varying(32),
report_location character varying(512),
report_organization character varying(512),
subject character varying(512),
contributor character varying(512),
\"language\" character varying(512),
CONSTRAINT cc_files_pkey PRIMARY KEY (id),
CONSTRAINT cc_files_editedby_fkey FOREIGN KEY (editedby)
REFERENCES cc_subjs (id) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
)";
camp_install_query($sql, false);
// $sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['filesTable']."_id_idx
// ON ".$CC_CONFIG['filesTable']." (id)";
// camp_install_query($sql, false);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['filesTable']."_gunid_idx
ON ".$CC_CONFIG['filesTable']." (gunid)";
camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['filesTable']."_name_idx
ON ".$CC_CONFIG['filesTable']." (name)";
camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['filesTable']."_md5_idx
ON ".$CC_CONFIG['filesTable']." (md5)";
camp_install_query($sql);
//$CC_DBC->createSequence($CC_CONFIG['filesSequence']);
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['filesTable']."\n";
}
if (!camp_db_table_exists($CC_CONFIG['playListTable'])) {
echo " * Creating database table ".$CC_CONFIG['playListTable']."...";
$sql =
"CREATE TABLE ".$CC_CONFIG['playListTable']."
(
id serial NOT NULL,
\"name\" character varying(255) NOT NULL DEFAULT ''::character varying,
state character varying(128) NOT NULL DEFAULT 'empty'::character varying,
currentlyaccessing integer NOT NULL DEFAULT 0,
editedby integer,
mtime timestamp(6) with time zone,
creator character varying(32),
description character varying(512),
CONSTRAINT cc_playlist_pkey PRIMARY KEY (id),
CONSTRAINT cc_playlist_editedby_fkey FOREIGN KEY (editedby)
REFERENCES cc_subjs (id) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
)";
camp_install_query($sql);
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['playListTable']."\n";
}
if (!camp_db_table_exists($CC_CONFIG['playListContentsTable'])) {
echo " * Creating database table ".$CC_CONFIG['playListContentsTable']."...";
$sql =
"CREATE TABLE ".$CC_CONFIG['playListContentsTable']."
(
id serial NOT NULL,
playlist_id integer,
file_id integer,
position integer,
cliplength time without time zone DEFAULT '00:00:00.000',
cuein time without time zone DEFAULT '00:00:00.000',
cueout time without time zone DEFAULT '00:00:00.000',
fadein time without time zone DEFAULT '00:00:00.000',
fadeout time without time zone DEFAULT '00:00:00.000',
CONSTRAINT cc_playlistcontents_pkey PRIMARY KEY (id),
CONSTRAINT cc_playlistcontents_playlist_id_fkey FOREIGN KEY (playlist_id)
REFERENCES ".$CC_CONFIG['playListTable']." (id) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE CASCADE,
CONSTRAINT cc_playlistcontents_file_id_fkey FOREIGN KEY (file_id)
REFERENCES ".$CC_CONFIG['filesTable']." (id) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE CASCADE
);
CREATE OR REPLACE FUNCTION calculate_position() RETURNS trigger AS
\$calc_pos\$
BEGIN
IF(TG_OP='INSERT') THEN
UPDATE ".$CC_CONFIG['playListContentsTable']." SET position = (position + 1) WHERE (playlist_id = new.playlist_id AND position >= new.position AND id != new.id);
END IF;
IF(TG_OP='DELETE') THEN
UPDATE ".$CC_CONFIG['playListContentsTable']." SET position = (position - 1) WHERE (playlist_id = old.playlist_id AND position > old.position);
END IF;
RETURN NULL;
END;
\$calc_pos\$
LANGUAGE 'plpgsql';
CREATE TRIGGER calculate_position AFTER INSERT OR DELETE ON ".$CC_CONFIG['playListContentsTable']."
FOR EACH ROW EXECUTE PROCEDURE calculate_position();
CREATE OR REPLACE VIEW cc_playlisttimes AS (
SELECT PL.id, COALESCE(T.length, '00:00:00') AS length
from ".$CC_CONFIG['playListTable']." AS PL LEFT JOIN
(SELECT playlist_id AS id, text(SUM(cliplength)) AS length
FROM ".$CC_CONFIG['playListContentsTable']." GROUP BY playlist_id) AS T
ON PL.id = T.id
);
";
camp_install_query($sql);
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['playListContentsTable']."\n";
}
//if (!camp_db_sequence_exists($CC_CONFIG["filesSequence"])) {
// echo " * Creating database sequence for ".$CC_CONFIG['filesTable']."...\n";
// $CC_DBC->createSequence($CC_CONFIG['filesSequence']);
//// $sql = "CREATE SEQUENCE ".$CC_CONFIG["filesSequence"]
//// ." INCREMENT 1
//// MINVALUE 1
//// MAXVALUE 9223372036854775807
//// START 1000000
//// CACHE 1";
//// camp_install_query($sql);
//} else {
// echo " * Skipping: database sequence already exists: ".$CC_CONFIG['filesSequence']."\n";
//}
if (!camp_db_table_exists($CC_CONFIG['accessTable'])) {
echo " * Creating database table ".$CC_CONFIG['accessTable']."...";
$sql = "CREATE TABLE ".$CC_CONFIG['accessTable']." (
gunid bigint, -- global unique id
token bigint, -- access token
chsum char(32) not null default'', -- md5 checksum
ext varchar(128) not null default'', -- extension
type varchar(20) not null default'', -- access type
parent bigint, -- parent token
owner int REFERENCES ".$CC_CONFIG['subjTable'].", -- subject have started it
ts timestamp
)";
camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['accessTable']."_token_idx
ON ".$CC_CONFIG['accessTable']." (token)";
camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['accessTable']."_gunid_idx
ON ".$CC_CONFIG['accessTable']." (gunid)";
camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['accessTable']."_parent_idx
ON ".$CC_CONFIG['accessTable']." (parent)";
camp_install_query($sql);
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['accessTable']."\n";
}
echo " * Inserting default users...\n";
$gb = new GreenBox();
$r = $gb->initData(true);
if (PEAR::isError($r)) {
echo "\n * ERROR: ";
print_r($r);
}
//echo "done.\n";
//------------------------------------------------------------------------------
// Submodules
//------------------------------------------------------------------------------
if (!camp_db_table_exists($CC_CONFIG['transTable'])) {
echo " * Creating database table ".$CC_CONFIG['transTable']."...";
$sql = "CREATE TABLE ".$CC_CONFIG['transTable']." (
id int not null, -- primary key
trtok char(16) not null, -- transport token
direction varchar(128) not null, -- direction: up|down
state varchar(128) not null, -- state
trtype varchar(128) not null, -- transport type
lock char(1) not null default 'N',-- running lock
target varchar(255) default NULL, -- target system,
-- if NULL => predefined set
rtrtok char(16) default NULL, -- remote hub's transport token
mdtrtok char(16), -- metadata transport token
gunid bigint, -- global unique id
pdtoken bigint, -- put/download token from archive
url varchar(255), -- url on remote side
localfile varchar(255), -- pathname of local part
fname varchar(255), -- mnemonic filename
title varchar(255), -- dc:title mdata value (or filename ...)
expectedsum char(32), -- expected file checksum
realsum char(32), -- checksum of transported part
expectedsize int, -- expected filesize in bytes
realsize int, -- filesize of transported part
uid int, -- local user id of transport owner
errmsg varchar(255), -- error message string for failed tr.
jobpid int, -- pid of transport job
start timestamp, -- starttime
ts timestamp -- mtime
)";
camp_install_query($sql, false);
$CC_DBC->createSequence($CC_CONFIG['transSequence']);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['transTable']."_id_idx
ON ".$CC_CONFIG['transTable']." (id)";
camp_install_query($sql, false);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['transTable']."_trtok_idx
ON ".$CC_CONFIG['transTable']." (trtok)";
camp_install_query($sql, false);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['transTable']."_token_idx
ON ".$CC_CONFIG['transTable']." (pdtoken)";
camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['transTable']."_gunid_idx
ON ".$CC_CONFIG['transTable']." (gunid)";
camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['transTable']."_state_idx
ON ".$CC_CONFIG['transTable']." (state)";
camp_install_query($sql);
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['transTable']."\n";
}
/**
* Scheduler tables.
*/
if (!camp_db_table_exists($CC_CONFIG['scheduleTable'])) {
echo " * Creating database table ".$CC_CONFIG['scheduleTable']."...";
$sql = "CREATE TABLE ".$CC_CONFIG['scheduleTable']."("
." id bigint NOT NULL,"
." playlist_id integer NOT NULL,"
." starts timestamp without time zone NOT NULL,"
." ends timestamp without time zone NOT NULL,"
." group_id integer,"
." file_id integer,"
." clip_length time without time zone DEFAULT '00:00:00'::time without time zone,"
." fade_in time without time zone DEFAULT '00:00:00'::time without time zone,"
." fade_out time without time zone DEFAULT '00:00:00'::time without time zone,"
." cue_in time without time zone DEFAULT '00:00:00'::time without time zone,"
." cue_out time without time zone DEFAULT '00:00:00'::time without time zone,"
." CONSTRAINT cc_schedule_pkey PRIMARY KEY (id),"
." CONSTRAINT unique_id UNIQUE (id))";
camp_install_query($sql);
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['scheduleTable']."\n";
}
//if (!camp_db_table_exists($CC_CONFIG['playlogTable'])) {
// echo " * Creating database table ".$CC_CONFIG['playlogTable']."...";
// $sql = "CREATE TABLE ".$CC_CONFIG['playlogTable']."("
// ." id BIGINT NOT NULL,"
// ." audioClipId BIGINT NOT NULL,"
// ." timestamp TIMESTAMP NOT NULL,"
// ." PRIMARY KEY(id))";
// camp_install_query($sql);
//} else {
// echo " * Skipping: database table already exists: ".$CC_CONFIG['playlogTable']."\n";
//}
if (!camp_db_table_exists($CC_CONFIG['backupTable'])) {
echo " * Creating database table ".$CC_CONFIG['backupTable']."...";
$sql = "CREATE TABLE ".$CC_CONFIG['backupTable']." ("
." token VARCHAR(64) NOT NULL,"
." sessionId VARCHAR(64) NOT NULL,"
." status VARCHAR(32) NOT NULL,"
." fromTime TIMESTAMP NOT NULL,"
." toTime TIMESTAMP NOT NULL,"
." PRIMARY KEY(token))";
camp_install_query($sql);
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['backupTable']."\n";
}
if (!camp_db_table_exists($CC_CONFIG['prefTable'])) {
echo " * Creating database table ".$CC_CONFIG['prefTable']."...";
//$CC_DBC->createSequence($CC_CONFIG['prefSequence']);
$sql = "CREATE TABLE ".$CC_CONFIG['prefTable']." (
id int not null,
subjid int REFERENCES ".$CC_CONFIG['subjTable']." ON DELETE CASCADE,
keystr varchar(255),
valstr text
)";
camp_install_query($sql, false);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['prefTable']."_id_idx
ON ".$CC_CONFIG['prefTable']." (id)";
camp_install_query($sql, false);
$sql = "CREATE UNIQUE INDEX ".$CC_CONFIG['prefTable']."_subj_key_idx
ON ".$CC_CONFIG['prefTable']." (subjid, keystr)";
camp_install_query($sql, false);
$sql = "CREATE INDEX ".$CC_CONFIG['prefTable']."_subjid_idx
ON ".$CC_CONFIG['prefTable']." (subjid)";
camp_install_query($sql);
echo " * Inserting starting data into table ".$CC_CONFIG['prefTable']."...";
$stPrefGr = Subjects::GetSubjId($CC_CONFIG['StationPrefsGr']);
Prefs::Insert($CC_CONFIG["systemPrefId"], 'stationName', "Radio Station 1");
$genres = file_get_contents( dirname(__FILE__).'/../genres.xml');
Prefs::Insert($CC_CONFIG["systemPrefId"], 'genres', $genres);
echo "done.\n";
} else {
echo " * Skipping: database table already exists: ".$CC_CONFIG['prefTable']."\n";
}
//------------------------------------------------------------------------
// Install storage directories
//------------------------------------------------------------------------
foreach (array('storageDir', 'bufferDir', 'transDir', 'accessDir', 'pearPath', 'cronDir') as $d) {
$test = file_exists($CC_CONFIG[$d]);
if ( $test === FALSE ) {
@mkdir($CC_CONFIG[$d], 02775);
if (file_exists($CC_CONFIG[$d])) {
$rp = realpath($CC_CONFIG[$d]);
echo " * Directory $rp created\n";
} else {
echo " * Failed creating {$CC_CONFIG[$d]}\n";
exit(1);
}
} elseif (is_writable($CC_CONFIG[$d])) {
$rp = realpath($CC_CONFIG[$d]);
echo " * Skipping directory already exists: $rp\n";
} else {
$rp = realpath($CC_CONFIG[$d]);
echo " * WARNING: Directory already exists, but is not writable: $rp\n";
//exit(1);
}
$CC_CONFIG[$d] = $rp;
}
//------------------------------------------------------------------------
// Storage directory writability test
//------------------------------------------------------------------------
echo " * Testing writability of ".$CC_CONFIG['storageDir']."...";
if (!($fp = @fopen($CC_CONFIG['storageDir']."/_writeTest", 'w'))) {
echo "\nPlease make directory {$CC_CONFIG['storageDir']} writeable by your webserver".
"\nand run install again\n\n";
exit(1);
} else {
fclose($fp);
unlink($CC_CONFIG['storageDir']."/_writeTest");
}
echo "done.\n";
//------------------------------------------------------------------------
// Install Cron job
//------------------------------------------------------------------------
require_once(dirname(__FILE__).'/../cron/Cron.php');
$m = '*/2';
$h ='*';
$dom = '*';
$mon = '*';
$dow = '*';
$command = realpath("{$CC_CONFIG['cronDir']}/transportCron.php");
$old_regex = '/transportCron\.php/';
echo " * Install storageServer cron job...\n";
$cron = new Cron();
$access = $cron->openCrontab('write');
if ($access != 'write') {
do {
$r = $cron->forceWriteable();
} while ($r);
}
foreach ($cron->ct->getByType(CRON_CMD) as $id => $line) {
if (preg_match($old_regex, $line['command'])) {
echo " * Removing old entry: ".$line['command']."\n";
$cron->ct->delEntry($id);
}
}
echo " * Adding new entry: ".$command."\n";
$cron->ct->addCron($m, $h, $dom, $mon, $dow, $command);
$cron->closeCrontab();
echo " Done.\n";
echo "**********************************\n";
echo "* StorageServer Install Complete *\n";
echo "**********************************\n";
?>

64
3rd_party/storageServer/var/install/installInit.php vendored
View file

@ -1,64 +0,0 @@
<?php
if (!function_exists('pg_connect')) {
trigger_error("PostgreSQL PHP extension required and not found.", E_USER_ERROR);
exit(2);
}
require_once('DB.php');
require_once('File/Find.php');
function camp_db_table_exists($p_name)
{
global $CC_DBC;
$sql = "SELECT * FROM ".$p_name;
$result = $CC_DBC->GetOne($sql);
if (PEAR::isError($result)) {
return false;
}
return true;
}
function camp_db_sequence_exists($p_name)
{
global $CC_DBC;
$sql = "SELECT 1 FROM pg_class where relname = '$p_name'";
$result = $CC_DBC->GetOne($sql);
if (!PEAR::isError($result) && $result == "1") {
return true;
}
return false;
}
function camp_install_query($sql, $verbose = true)
{
global $CC_DBC;
$result = $CC_DBC->query($sql);
if (PEAR::isError($result)) {
echo "Error! ".$result->getMessage()."\n";
echo " SQL statement was:\n";
echo " ".$sql."\n\n";
} else {
if ($verbose) {
echo "done.\n";
}
}
}
function campcaster_db_connect($p_exitOnError = true) {
global $CC_DBC, $CC_CONFIG;
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
if (PEAR::isError($CC_DBC)) {
echo $CC_DBC->getMessage()."\n";
echo $CC_DBC->getUserInfo()."\n";
echo "Database connection problem.\n";
echo "Check if database '{$CC_CONFIG['dsn']['database']}' exists".
" with corresponding permissions.\n";
if ($p_exitOnError) {
exit(1);
}
} else {
echo " * Connected to database\n";
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
}
}
?>

208
3rd_party/storageServer/var/install/uninstall.php vendored
View file

@ -1,208 +0,0 @@
<?php
/**
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*/
// Do not allow remote execution.
$arr = array_diff_assoc($_SERVER, $_ENV);
if (isset($arr["DOCUMENT_ROOT"]) && ($arr["DOCUMENT_ROOT"] != "") ) {
header("HTTP/1.1 400");
header("Content-type: text/plain; charset=UTF-8");
echo "400 Not executable\r\n";
exit;
}
echo "***************************\n";
echo "* StorageServer Uninstall *\n";
echo "***************************\n";
require_once(dirname(__FILE__).'/../conf.php');
require_once(dirname(__FILE__).'/installInit.php');
campcaster_db_connect(false);
function camp_uninstall_delete_files($p_path)
{
if (!empty($p_path) && (strlen($p_path) > 4)) {
list($dirList,$fileList) = File_Find::maptree($p_path);
foreach ($fileList as $filepath) {
echo " * Removing $filepath...";
@unlink($filepath);
echo "done.\n";
}
foreach ($dirList as $dirpath) {
echo " * Removing $dirpath...";
@rmdir($dirpath);
echo "done.\n";
}
}
}
if (!PEAR::isError($CC_DBC)) {
if (camp_db_table_exists($CC_CONFIG['prefTable'])) {
echo " * Removing database table ".$CC_CONFIG['prefTable']."...";
$sql = "DROP TABLE ".$CC_CONFIG['prefTable'];
camp_install_query($sql, false);
$CC_DBC->dropSequence($CC_CONFIG['prefTable']."_id");
echo "done.\n";
} else {
echo " * Skipping: database table ".$CC_CONFIG['prefTable']."\n";
}
}
//------------------------------------------------------------------------
// Uninstall Cron job
//------------------------------------------------------------------------
require_once(dirname(__FILE__).'/../cron/Cron.php');
$old_regex = '/transportCron\.php/';
echo " * Uninstall storageServer cron job...\n";
$cron = new Cron();
$access = $cron->openCrontab('write');
if ($access != 'write') {
do {
$r = $cron->forceWriteable();
} while ($r);
}
foreach ($cron->ct->getByType(CRON_CMD) as $id => $line) {
if (preg_match($old_regex, $line['command'])) {
echo " removing cron entry\n";
$cron->ct->delEntry($id);
}
}
$cron->closeCrontab();
echo "Done.\n";
camp_uninstall_delete_files($CC_CONFIG['storageDir']);
camp_uninstall_delete_files($CC_CONFIG['transDir']);
camp_uninstall_delete_files($CC_CONFIG['accessDir']);
if (camp_db_table_exists($CC_CONFIG['transTable'])) {
echo " * Removing database table ".$CC_CONFIG['transTable']."...";
$sql = "DROP TABLE ".$CC_CONFIG['transTable'];
camp_install_query($sql, false);
$CC_DBC->dropSequence($CC_CONFIG['transTable']."_id");
echo "done.\n";
} else {
echo " * Skipping: database table ".$CC_CONFIG['transTable']."\n";
}
if (camp_db_table_exists($CC_CONFIG['filesTable'])) {
echo " * Removing database table ".$CC_CONFIG['filesTable']."...";
$sql = "DROP TABLE ".$CC_CONFIG['filesTable']." CASCADE";
camp_install_query($sql);
$CC_DBC->dropSequence($CC_CONFIG['filesTable']."_id");
} else {
echo " * Skipping: database table ".$CC_CONFIG['filesTable']."\n";
}
if (camp_db_table_exists($CC_CONFIG['playListTable'])) {
echo " * Removing database table ".$CC_CONFIG['playListTable']."...";
$sql = "DROP TABLE ".$CC_CONFIG['playListTable']." CASCADE";
camp_install_query($sql);
$CC_DBC->dropSequence($CC_CONFIG['playListTable']."_id");
} else {
echo " * Skipping: database table ".$CC_CONFIG['playListTable']."\n";
}
if (camp_db_table_exists($CC_CONFIG['playListContentsTable'])) {
echo " * Removing database table ".$CC_CONFIG['playListContentsTable']."...";
$sql = "DROP TABLE ".$CC_CONFIG['playListContentsTable'];
camp_install_query($sql);
$CC_DBC->dropSequence($CC_CONFIG['playListContentsTable']."_id");
} else {
echo " * Skipping: database table ".$CC_CONFIG['playListContentsTable']."\n";
}
//if (camp_db_sequence_exists($CC_CONFIG['filesSequence'])) {
// $sql = "DROP SEQUENCE ".$CC_CONFIG['filesSequence'];
// camp_install_query($sql);
//}
//
if (camp_db_table_exists($CC_CONFIG['accessTable'])) {
echo " * Removing database table ".$CC_CONFIG['accessTable']."...";
$sql = "DROP TABLE ".$CC_CONFIG['accessTable'];
camp_install_query($sql);
} else {
echo " * Skipping: database table ".$CC_CONFIG['accessTable']."\n";
}
if (camp_db_table_exists($CC_CONFIG['permTable'])) {
echo " * Removing database table ".$CC_CONFIG['permTable']."...";
$sql = "DROP TABLE ".$CC_CONFIG['permTable'];
camp_install_query($sql, false);
$CC_DBC->dropSequence($CC_CONFIG['permTable']."_id");
echo "done.\n";
} else {
echo " * Skipping: database table ".$CC_CONFIG['permTable']."\n";
}
if (camp_db_table_exists($CC_CONFIG['sessTable'])) {
echo " * Removing database table ".$CC_CONFIG['sessTable']."...";
$sql = "DROP TABLE ".$CC_CONFIG['sessTable'];
camp_install_query($sql);
} else {
echo " * Skipping: database table ".$CC_CONFIG['sessTable']."\n";
}
if (camp_db_table_exists($CC_CONFIG['subjTable'])) {
echo " * Removing database table ".$CC_CONFIG['subjTable']."...";
$CC_DBC->dropSequence($CC_CONFIG['subjTable']."_id");
$sql = "DROP TABLE ".$CC_CONFIG['subjTable']." CASCADE";
camp_install_query($sql, false);
echo "done.\n";
} else {
echo " * Skipping: database table ".$CC_CONFIG['subjTable']."\n";
}
if (camp_db_table_exists($CC_CONFIG['smembTable'])) {
echo " * Removing database table ".$CC_CONFIG['smembTable']."...";
$sql = "DROP TABLE ".$CC_CONFIG['smembTable'];
camp_install_query($sql, false);
$CC_DBC->dropSequence($CC_CONFIG['smembTable']."_id");
echo "done.\n";
} else {
echo " * Skipping: database table ".$CC_CONFIG['smembTable']."\n";
}
if (camp_db_table_exists($CC_CONFIG['scheduleTable'])) {
echo " * Removing database table ".$CC_CONFIG['scheduleTable']."...";
camp_install_query("DROP TABLE ".$CC_CONFIG['scheduleTable']);
} else {
echo " * Skipping: database table ".$CC_CONFIG['scheduleTable']."\n";
}
if (camp_db_table_exists($CC_CONFIG['backupTable'])) {
echo " * Removing database table ".$CC_CONFIG['backupTable']."...";
camp_install_query("DROP TABLE ".$CC_CONFIG['backupTable']);
} else {
echo " * Skipping: database table ".$CC_CONFIG['backupTable']."\n";
}
//if (camp_db_table_exists($CC_CONFIG['playlogTable'])) {
// echo " * Removing database table ".$CC_CONFIG['playlogTable']."...";
// $sql = "DROP TABLE ".$CC_CONFIG['playlogTable'];
// camp_install_query($sql);
//} else {
// echo " * Skipping: database table ".$CC_CONFIG['playlogTable']."\n";
//}
echo "************************************\n";
echo "* StorageServer Uninstall Complete *\n";
echo "************************************\n";
?>

101
3rd_party/storageServer/var/install/upgrade/upgrade-to-1.2.0.php vendored
View file

@ -1,101 +0,0 @@
<?php
/**
* @package Campcaster
* @subpackage StorageServer
* @copyright 2010 Sourcefabric O.P.S.
* @license http://www.gnu.org/licenses/gpl.txt
*
*/
// Do not allow remote execution
$arr = array_diff_assoc($_SERVER, $_ENV);
if (isset($arr["DOCUMENT_ROOT"]) && ($arr["DOCUMENT_ROOT"] != "") ) {
header("HTTP/1.1 400");
header("Content-type: text/plain; charset=UTF-8");
echo "400 Not executable\r\n";
exit(1);
}
echo "*********************************************\n";
echo "* StorageServer Upgrade from 1.1.X to 1.2.0 *\n";
echo "*********************************************\n";
require_once(dirname(__FILE__).'/../../conf.php');
require_once(dirname(__FILE__)."/../installInit.php");
campcaster_db_connect();
require_once(dirname(__FILE__)."/../../StoredFile.php");
// Check to see if upgrade has already been applied
$sql = "SELECT md5 FROM ".$CC_CONFIG['filesTable']." LIMIT 1";
$result = $CC_DBC->query($sql);
if (!PEAR::isError($result)) {
echo " * THIS UPGRADE HAS ALREADY BEEN APPLIED.\n";
exit(0);
}
echo " * Adding column 'md5' to '".$CC_CONFIG['filesTable']." table...";
$sql = "ALTER TABLE ".$CC_CONFIG['filesTable']." ADD COLUMN md5 char(32)";
camp_install_query($sql, false);
$sql = "ALTER TABLE ".$CC_CONFIG['filesTable']." ALTER COLUMN md5 SET STORAGE EXTENDED";
camp_install_query($sql);
echo " * Creating index on column 'md5'...";
$sql = "CREATE INDEX ".$CC_CONFIG['filesTable']."_md5_idx ON ".$CC_CONFIG['filesTable']." (md5)";
camp_install_query($sql);
echo " * Converting metadata values 'ls:genre' to 'dc:type'...";
$sql = "UPDATE ".$CC_CONFIG['mdataTable']." SET predns='dc', predicate='type' WHERE predns='ls' and predicate='genre'";
camp_install_query($sql);
echo " * Adding 'jobpid' to ".$CC_CONFIG['transTable']."...";
$sql = "ALTER TABLE ".$CC_CONFIG['transTable']." ADD COLUMN jobpid int";
camp_install_query($sql);
echo " * Fixing track numbers...\n";
$sql = "SELECT id, object as track_num FROM ".$CC_CONFIG['mdataTable']
." WHERE predns='ls' AND predicate='track_num'";
$rows = $CC_DBC->GetAll($sql);
foreach ($rows as $row) {
$newTrackNum = camp_parse_track_number($row["track_num"]);
if ($row["track_num"] != $newTrackNum) {
echo " * Converting '".$row["track_num"]."' --> '$newTrackNum'\n";
$sql = "UPDATE ".$CC_CONFIG["mdataTable"]
." SET object='$newTrackNum'"
." WHERE id=".$row["id"];
$CC_DBC->query($sql);
}
}
// Get MD5 values for all files
echo " * Computing MD5 sums for all files (this may take a while)...\n";
$sql = "SELECT to_hex(gunid) as gunid, name FROM ".$CC_CONFIG['filesTable'] ." WHERE ftype='audioclip'";
$rows = $CC_DBC->GetAll($sql);
$errorFiles = array();
foreach ($rows as $row) {
$gunid = StoredFile::NormalizeGunid($row['gunid']);
$storedFile = new StoredFile($gunid);
$fileName = $storedFile->getRealFileName();
$humanName = basename($row['name']);
echo " File: $humanName\n";
if (file_exists($fileName)) {
$md5 = md5_file($fileName);
$storedFile->setMd5($md5);
//echo " MD5: $md5\n";
} else {
$errorFiles[] = "$gunid -- $humanName";
echo " ERROR: file does not exist! (GUNID: $gunid)\n";
}
}
if (count($errorFiles) > 0) {
echo "\n\nWARNING\n";
echo "The following files were not found:\n";
foreach ($errorFiles as $file) {
echo $file."\n";
}
}
echo "*******************************************\n";
echo "* StorageServer Upgrade to 1.2.0 Complete *\n";
echo "*******************************************\n";
?>

1
3rd_party/storageServer/var/install/upgrade/upgrade.php vendored
View file

@ -1 +0,0 @@
upgrade-to-1.2.0.php

117
3rd_party/storageServer/var/playlistFormat.php vendored
View file

@ -1,117 +0,0 @@
<?php
/**
* @package Campcaster
* @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()),
),
*/
);
/*
?
ls:filename Text auto
*/
?>

BIN
3rd_party/storageServer/var/tests/0000000000010001 vendored
View file

Binary file not shown.

BIN
3rd_party/storageServer/var/tests/0000000000010002 vendored
View file

Binary file not shown.

19
3rd_party/storageServer/var/tests/AllTests.php vendored
View file

@ -1,19 +0,0 @@
<?php
require_once(dirname(__FILE__).'/../conf.php');
require_once('DB.php');
require_once('PHPUnit.php');
require_once 'BasicStorTests.php';
require_once 'SchedulerTests.php';
require_once 'SchedulerExportTests.php';
require_once 'PlayListTests.php';
$suite = new PHPUnit_TestSuite("BasicStorTest");
//$suite = new PHPUnit_TestSuite("SchedulerTests");
$suite->addTestSuite("SchedulerTests");
$suite->addTestSuite("SchedulerExportTests");
$suite->addTestSuite("PlayListTests");
$result = PHPUnit::run($suite);
echo $result->toString();
?>

70
3rd_party/storageServer/var/tests/BasicStorTests.php vendored
View file

@ -1,70 +0,0 @@
<?php
require_once(dirname(__FILE__).'/../StoredFile.php');
require_once(dirname(__FILE__).'/../BasicStor.php');
require_once(dirname(__FILE__).'/../GreenBox.php');
$dsn = $CC_CONFIG['dsn'];
$CC_DBC = DB::connect($dsn, TRUE);
if (PEAR::isError($CC_DBC)) {
echo "ERROR: ".$CC_DBC->getMessage()." ".$CC_DBC->getUserInfo()."\n";
exit(1);
}
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
class BasicStorTest extends PHPUnit_TestCase {
private $greenbox;
// function __construct($name) {
// parent::__construct($name);
// }
function setup() {
$this->greenbox = new GreenBox();
}
function testGetAudioMetadata() {
$filePath = dirname(__FILE__)."/ex1.mp3";
$metadata = camp_get_audio_metadata($filePath);
if (PEAR::isError($metadata)) {
$this->fail($metadata->getMessage());
return;
}
if (($metadata["dc:description"] != "Tmu sem tam videla ...")
|| ($metadata["audio"]["dataformat"] != "mp3")
|| ($metadata["dc:type"] != "Speech")) {
$str = " [dc:description] = " . $metadata["dc:description"] ."\n"
. " [audio][dataformat] = " . $metadata["audio"]["dataformat"]."\n"
. " [dc:type] = ".$metadata["dc:type"]."\n";
$this->fail("Metadata has unexpected values:\n".$str);
}
//var_dump($metadata);
//$this->assertTrue(FALSE);
}
function testDeleteAndPutFile() {
$STORAGE_SERVER_PATH = dirname(__FILE__)."/../../";
$filePath = dirname(__FILE__)."/ex1.mp3";
$md5 = md5_file($filePath);
$duplicate = StoredFile::RecallByMd5($md5);
if ($duplicate) {
$duplicate->delete();
}
$values = array("filepath" => $filePath);
$storedFile = $this->greenbox->bsPutFile($values, false);
if (PEAR::isError($storedFile)) {
$this->fail("Failed to create StoredFile: ".$storedFile->getMessage());
return;
}
$id = $storedFile->getId();
if (!is_numeric($id)) {
$this->fail("StoredFile not created correctly. id = ".$id);
return;
}
}
}
?>

138
3rd_party/storageServer/var/tests/PlayListTests.php vendored
View file

@ -1,138 +0,0 @@
<?php
require_once(dirname(__FILE__).'/../conf.php');
require_once('PHPUnit.php');
require_once('DB.php');
require_once(dirname(__FILE__).'/../GreenBox.php');
require_once(dirname(__FILE__).'/../Playlist.php');
$dsn = $CC_CONFIG['dsn'];
$CC_DBC = DB::connect($dsn, TRUE);
if (PEAR::isError($CC_DBC)) {
echo "ERROR: ".$CC_DBC->getMessage()." ".$CC_DBC->getUserInfo()."\n";
exit(1);
}
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
class PlayListTests extends PHPUnit_TestCase {
private $greenbox;
function __construct($name) {
parent::__construct($name);
}
function setup() {
global $CC_CONFIG, $CC_DBC;
$this->greenbox = new GreenBox();
}
function testGBCreatePlaylist() {
$pl = new Playlist();
$pl_id = $pl->create("create");
if (PEAR::isError($pl_id)) {
$this->fail("problems creating playlist.");
return;
}
}
function testGBLock() {
$pl = new Playlist();
$pl_id = $pl->create("lock test");
$sessid = Alib::Login('root', 'q');
$res = $this->greenbox->lockPlaylistForEdit($pl_id, $sessid);
if($res !== TRUE) {
$this->fail("problems locking playlist for editing.");
return;
}
}
function testGBUnLock() {
$pl = new Playlist();
$pl_id = $pl->create("unlock test");
$sessid = Alib::Login('root', 'q');
$this->greenbox->lockPlaylistForEdit($pl_id, $sessid);
$res = $this->greenbox->releaseLockedPlaylist($pl_id, $sessid);
if($res !== TRUE) {
$this->fail("problems unlocking playlist.");
return;
}
}
function testGBSetPLMetaData() {
$pl = new Playlist();
$pl_id = $pl->create("set meta data test");
$res = $this->greenbox->setPLMetadataValue($pl_id, "dc:title", "A Title");
if($res !== TRUE) {
$this->fail("problems setting playlist metadata.");
return;
}
}
function testGBGetPLMetaData() {
$pl = new Playlist();
$name = "Testing";
$pl_id = $pl->create($name);
$res = $this->greenbox->getPLMetadataValue($pl_id, "dc:title");
if($res !== $name) {
$this->fail("problems getting playlist metadata.");
return;
}
}
function testAddAudioClip() {
$pl = new Playlist();
$pl_id = $pl->create("Add");
$res = $this->greenbox->addAudioClipToPlaylist($pl_id, '1');
if($res !== TRUE) {
$this->fail("problems adding audioclip to playlist.");
return;
}
}
function testMoveAudioClip() {
$pl = new Playlist();
$pl_id = $pl->create("Move");
$this->greenbox->addAudioClipToPlaylist($pl_id, '1');
$this->greenbox->addAudioClipToPlaylist($pl_id, '2');
$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("Delete");
$this->greenbox->addAudioClipToPlaylist($pl_id, '1');
$res = $this->greenbox->delAudioClipFromPlaylist($pl_id, 0);
if($res !== TRUE) {
$this->fail("problems deleting audioclip from playlist.");
return;
}
}
}
?>

42
3rd_party/storageServer/var/tests/SchedulerExportTests.php vendored
View file

@ -1,42 +0,0 @@
<?php
require_once(dirname(__FILE__)."/../Schedule.php");
class SchedulerExportTests extends PHPUnit_TestCase {
function setup() {
global $CC_CONFIG, $CC_DBC;
// Clear the files table
$sql = "DELETE FROM ".$CC_CONFIG["filesTable"];
$CC_DBC->query($sql);
// Add a file
$values = array("filepath" => dirname(__FILE__)."/test10001.mp3");
$this->storedFile = StoredFile::Insert($values, false);
// Add a file
$values = array("filepath" => dirname(__FILE__)."/test10002.mp3");
$this->storedFile2 = StoredFile::Insert($values, false);
// Clear the schedule table
$sql = "DELETE FROM ".$CC_CONFIG["scheduleTable"];
$CC_DBC->query($sql);
// Create a playlist
$playlist = new Playlist();
$playlist->create("Scheduler Unit Test");
$result = $playlist->addAudioClip($this->storedFile->getId());
$result = $playlist->addAudioClip($this->storedFile2->getId());
$result = $playlist->addAudioClip($this->storedFile2->getId());
// Schedule it
$i = new ScheduleGroup();
$this->groupIdCreated = $i->add('2010-11-11 01:30:23', null, $playlist->getId());
}
public function testExport() {
echo Schedule::ExportRangeAsJson("2010-01-01 00:00:00", "2011-01-01 00:00:00");
}
}
?>

118
3rd_party/storageServer/var/tests/SchedulerTests.php vendored
View file

@ -1,118 +0,0 @@
<?php
require_once(dirname(__FILE__)."/../Schedule.php");
class SchedulerTests extends PHPUnit_TestCase {
private $groupIdCreated;
private $storedFile;
private $storedFile2;
function setup() {
global $CC_CONFIG, $CC_DBC;
// Clear the files table
$sql = "DELETE FROM ".$CC_CONFIG["filesTable"];
$CC_DBC->query($sql);
// Add a file
$values = array("filepath" => dirname(__FILE__)."/test10001.mp3");
$this->storedFile = StoredFile::Insert($values, false);
// Add a file
$values = array("filepath" => dirname(__FILE__)."/test10002.mp3");
$this->storedFile2 = StoredFile::Insert($values, false);
// Clear the schedule table
$sql = "DELETE FROM ".$CC_CONFIG["scheduleTable"];
$CC_DBC->query($sql);
}
function testDateToId() {
$dateStr = "2006-04-02 10:20:08.123456";
$id = ScheduleGroup::dateToId($dateStr);
$expected = "20060402102008123";
if ($id != $expected) {
$this->fail("Did not convert date to ID correctly #1: $id != $expected");
}
$dateStr = "2006-04-02 10:20:08";
$id = ScheduleGroup::dateToId($dateStr);
$expected = "20060402102008000";
if ($id != $expected) {
$this->fail("Did not convert date to ID correctly #2: $id != $expected");
}
}
function testAddAndRemoveAudioFile() {
$i = new ScheduleGroup();
$this->groupIdCreated = $i->add('2010-10-10 01:30:23', $this->storedFile->getId());
if (PEAR::isError($this->groupIdCreated)) {
$this->fail("Failed to create scheduled item: ". $this->groupIdCreated->getMessage());
}
$i = new ScheduleGroup($this->groupIdCreated);
$result = $i->remove();
if ($result != 1) {
$this->fail("Did not remove item.");
}
}
function testAddAndRemovePlaylist() {
// Create a playlist
$playlist = new Playlist();
$playlist->create("Scheduler Unit Test");
$result = $playlist->addAudioClip($this->storedFile->getId());
$result = $playlist->addAudioClip($this->storedFile2->getId());
$result = $playlist->addAudioClip($this->storedFile2->getId());
$i = new ScheduleGroup();
$this->groupIdCreated = $i->add('2010-11-11 01:30:23', null, $playlist->getId());
if (PEAR::isError($this->groupIdCreated)) {
$this->fail("Failed to create scheduled item: ". $this->groupIdCreated->getMessage());
}
$group = new ScheduleGroup($this->groupIdCreated);
if ($group->count() != 3) {
$this->fail("Wrong number of items added.");
}
$items = $group->getItems();
if ($items[1]["starts"] != "2010-11-11 01:30:34.231") {
$this->fail("Wrong start time for 2nd item.");
}
$result = $group->remove();
if ($result != 1) {
$this->fail("Did not remove item.");
}
Playlist::Delete($playlist->getId());
}
function testIsScheduleEmptyInRange() {
$i = new ScheduleGroup();
$this->groupIdCreated = $i->add('2011-10-10 01:30:23', $this->storedFile->getId());
if (Schedule::isScheduleEmptyInRange('2011-10-10 01:30:23', '00:00:01.432153')) {
$this->fail("Reporting empty schedule when it isnt.");
}
$i->remove();
if (!Schedule::isScheduleEmptyInRange('2011-10-10 01:30:23', '00:00:01.432153')) {
$this->fail("Reporting booked schedule when it isnt.");
}
}
function testGetItems() {
$i1 = new ScheduleGroup();
$groupId1 = $i1->add('2008-01-01 12:00:00.000', $this->storedFile->getId());
$i2 = new ScheduleGroup();
$i2->addAfter($groupId1, $this->storedFile->getId());
$items = Schedule::GetItems("2008-01-01", "2008-01-02");
if (count($items) != 2) {
$this->fail("Wrong number of items returned.");
return;
}
$i1->remove();
$i2->remove();
}
}
?>

25
3rd_party/storageServer/var/tests/analyze.php vendored
View file

@ -1,25 +0,0 @@
#!/usr/bin/php -q
<?php
header("Content-type: text/plain");
echo "TEST\n";
#$gunid = "5716b53127c3761f92fddde3412c7773";
$gunid = $argv[1];
echo "GUNID: $gunid\n";
require_once('../conf.php');
require_once('DB.php');
require_once('../GreenBox.php');
$rmd = new StoredFile($gunid, '../stor/'.substr($gunid, 0, 3));
$r = $rmd->analyzeFile();
echo "r=$r (".gettype($r).")\n";
if (PEAR::isError($r)) {
echo "ERR: ".$r->getMessage()."\n".$r->getUserInfo()."\n";
}
if (is_array($r)) {
print_r($r);
}
echo"\n";
?>

BIN
3rd_party/storageServer/var/tests/ex1.mp3 vendored
View file

Binary file not shown.

BIN
3rd_party/storageServer/var/tests/ex2.ogg vendored
View file

Binary file not shown.

BIN
3rd_party/storageServer/var/tests/ex2.wav vendored
View file

Binary file not shown.

BIN
3rd_party/storageServer/var/tests/ex3.wav vendored
View file

Binary file not shown.

BIN
3rd_party/storageServer/var/tests/exportedPl_lspl.tar vendored
View file

Binary file not shown.

4
3rd_party/storageServer/var/tests/index.php vendored
View file

@ -1,4 +0,0 @@
<?php
header ("location: ../");
exit;
?>

26
3rd_party/storageServer/var/tests/plistEmbedded.xml vendored
View file

@ -1,26 +0,0 @@
<?xml version="1.0"?>
<playlist id="0e22c20310212a51">
<playlistElement id="0000000000000103" relativeOffset="00:00:00.000000" >
<audioClip id="0000000000010003"
playlength="00:00:11.500000"
title = "three"
uri="file:var/test10003.mp3"
/>
</playlistElement>
<playlistElement id="0000000000000104" relativeOffset="00:00:11.500000">
<playlist id="0000000000000001"
playlength="01:30:00.000000"
title="My First Playlist">
</playlist>
</playlistElement>
<metadata
xmlns="http://mdlf.org/campcaster/elements/1.0/"
xmlns:ls="http://mdlf.org/campcaster/elements/1.0/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:dcterms="http://purl.org/dc/terms/"
>
<dc:title>embedded playlist</dc:title>
<dcterms:extent>01:30:11.500000</dcterms:extent>
</metadata>
</playlist>

BIN
3rd_party/storageServer/var/tests/question.wav vendored
View file

Binary file not shown.

BIN
3rd_party/storageServer/var/tests/test10001.mp3 vendored
View file

Binary file not shown.

BIN
3rd_party/storageServer/var/tests/test10002.mp3 vendored
View file

Binary file not shown.

BIN
3rd_party/storageServer/var/tests/test10003.mp3 vendored
View file

Binary file not shown.

143
3rd_party/storageServer/var/tests/transTest.php vendored
View file

@ -1,143 +0,0 @@
<?php
/*
header("Content-type: text/plain");
require_once('../conf.php');
require_once('DB.php');
require_once('../GreenBox.php');
require_once('../LocStor.php');
#PEAR::setErrorHandling(PEAR_ERROR_PRINT, "%s<hr>\n");
PEAR::setErrorHandling(PEAR_ERROR_RETURN);
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
$gb = new GreenBox();
$tr = new Transport($gb);
$ls = new LocStor();
@unlink($CC_CONFIG['transDir']."/activity.log");
@unlink($CC_CONFIG['transDir']."/debug.log");
$tr->_cleanUp();
$gunid = 'a23456789abcdefb';
$mediaFile = '../tests/ex1.mp3';
$mdataFile = '../tests/mdata1.xml';
// Test remote search
$result = $tr->remoteSearch("");
if (PEAR::isError($result)) {
echo $result->message."\n";
} else {
var_dump($result);
}
// ========== STORE ==========
echo"# Store: ";
//$parid = $gb->_getHomeDirIdFromSess($sessid);
$values = array(
"filename" => "xx1.mp3",
"filepath" => $mediaFile,
"metadata" => $mdataFile,
"gunid" => $gunid,
"filetype" => "audioclip"
);
$storedFile = $gb->bsPutFile($values);
if (PEAR::isError($storedFile)) {
if ($storedFile->getCode()!=GBERR_GUNID) {
echo "ERROR: ".$storedFile->getMessage()."\n";
exit(1);
}
}
$oid = $storedFile->getId();
$comm = "ls -l ".$CC_CONFIG['storageDir']."/a23"; echo `$comm`;
echo "$oid\n";
// ========== DELETE FROM HUB ==========
echo"# loginToArchive: ";
$r = $tr->loginToArchive();
if(PEAR::isError($r)){ echo "ERROR: ".$r->getMessage()." / ".$r->getUserInfo()."\n"; exit(1); }
echo "{$r['sessid']}\n";
$asessid = $r['sessid'];
echo"# deleteAudioClip on Hub: ";
$r = $tr->xmlrpcCall(
'archive.deleteAudioClip',
array(
'sessid' => $asessid,
'gunid' => $gunid,
'forced' => TRUE,
)
);
if(PEAR::isError($r)){ echo "ERROR: ".$r->getMessage()." / ".$r->getUserInfo()."\n"; if($r->getCode()!=800+GBERR_FILENEX) exit(1); }
else{ echo " {$r['status']}\n"; }
echo"# logoutFromArchive: ";
$r = $tr->logoutFromArchive($asessid);
if(PEAR::isError($r)){ echo "ERROR: ".$r->getMessage()." / ".$r->getUserInfo()."\n"; exit(1); }
var_export($r); echo"\n";
// ========== UPLOAD ==========
echo "# UPLOAD test:\n";
echo"# uploadAudioClip2Hub: ";
$r = $gb->upload2Hub($gunid);
if(PEAR::isError($r)){ echo "ERROR: ".$r->getMessage()."/".$r->getUserInfo()."\n"; exit(1); }
var_export($r); echo"\n";
$trtok = $r;
echo"# logout: "; $r = Alib::Logout($sessid);
if(PEAR::isError($r)){ echo "ERROR: ".$r->getMessage()."/".$r->getUserInfo()."\n"; exit(1); }
echo "$r\n";
#$trtok='280a6f1c18389620';
for($state='', $nu=1; ($state!='closed' && $state!='failed' && $nu<=12); $nu++, sleep(2)){
echo"# getTransportInfo: "; $r = $gb->getTransportInfo($trtok);
if(PEAR::isError($r)){ echo "ERROR: ".$r->getMessage()."/".$r->getUserInfo()."\n"; exit(1); }
$state = $r['state'];
echo "# state=$state, title={$r['title']}\n";
}
if($state=='failed') exit(1);
// === DELETE LOCAL ===
echo "# Login: ".($sessid = Alib::Login('root', 'q'))."\n";
echo "# Delete: "; $r = $ls->deleteAudioClip($sessid, $gunid, TRUE);
if (PEAR::isError($r)) {
echo "ERROR: ".$r->getMessage()."\n";
exit(1);
}
echo "$r\n";
echo "# logout: "; $r = Alib::Logout($sessid);
if (PEAR::isError($r)) {
echo "ERROR: ".$r->getMessage()."\n";
exit(1);
}
echo "$r\n";
$comm = "ls -l ".$CC_CONFIG['storageDir']."/a23";
echo `$comm`;
// === DOWNLOAD ===
echo "# DOWNLOAD test:\n";
echo"# Login: ".($sessid = Alib::Login('root', 'q'))."\n";
echo"# downloadAudioClipFromHub: ";
$r = $gb->downloadFromHub($sessid, $gunid);
if(PEAR::isError($r)){ echo "ERROR: ".$r->getMessage()."/".$r->getUserInfo()."\n"; exit(1); }
var_export($r); echo"\n";
$trtok = $r;
echo"# logout: "; $r = Alib::Logout($sessid);
if(PEAR::isError($r)){ echo "ERROR: ".$r->getMessage()."\n"; exit(1); }
echo "$r\n";
for($state='', $nu=1; ($state!='closed' && $state!='failed' && $nu<=12); $nu++, sleep(2)){
echo"# getTransportInfo: "; $r = $gb->getTransportInfo($trtok);
if(PEAR::isError($r)){ echo "ERROR: ".$r->getMessage()."/".$r->getUserInfo()."\n"; exit(1); }
$state = $r['state'];
echo "# state=$state, title={$r['title']}\n";
}
if($state=='failed') exit(1);
$comm = "ls -l ".$CC_CONFIG['storageDir']."/a23"; echo `$comm`;
if(file_exists("../trans/log")) echo `tail -n 25 ../trans/log`;
echo "#Transport test: OK.\n\n";
*/
?>

62
3rd_party/storageServer/var/tests/webstreamTest.php vendored
View file

@ -1,62 +0,0 @@
<?php
/*
header("Content-type: text/plain");
echo "\n#StorageServer storeWebstream test:\n";
require_once('../conf.php');
require_once('DB.php');
require_once('../GreenBox.php');
#PEAR::setErrorHandling(PEAR_ERROR_PRINT, "%s<hr>\n");
PEAR::setErrorHandling(PEAR_ERROR_RETURN);
$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
$gb = new GreenBox();
#$gunid = "123456789abcdee0";
$gunid = "";
#$mdataFileLP = '../tests/mdata1.xml';
$mdataFileLP = NULL;
echo "# Login: ".($sessid = Alib::Login('root', 'q'))."\n";
$parid = $gb->_getHomeDirId($sessid);
echo "# storeWebstream: ";
$r = $gb->storeWebstream(
$parid, 'test stream', $mdataFileLP, $sessid, $gunid, 'http://localhost/y');
if (PEAR::isError($r)) {
echo "ERROR: ".$r->getMessage()." ".$r->getUserInfo()."\n";
exit(1);
}
echo "";
var_dump($r);
//$id = BasicStor::IdFromGunid($gunid);
$id = $r;
echo "# getMdata: ";
$r = $gb->getMetadata($id, $sessid);
if (PEAR::isError($r)) {
echo "ERROR: ".$r->getMessage()." ".$r->getUserInfo()."\n";
exit(1);
}
echo "\n$r\n";
echo "# deleteFile: ";
$r = $gb->deleteFile($id, $sessid);
if (PEAR::isError($r)) {
echo "ERROR: ".$r->getMessage()." ".$r->getUserInfo()."\n";
exit(1);
}
echo "\n$r\n";
echo "# logout: ";
$r = Alib::Logout($sessid);
if (PEAR::isError($r)) {
echo "ERROR: ".$r->getMessage()."\n";
exit(1);
}
echo "$r\n";
echo "#storeWebstream test: OK.\n\n"
*/
?>

14
3rd_party/storageServer/var/tests/wstream1.xml vendored
View file

@ -1,14 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<audioClip>
<metadata
xmlns="http://mdlf.org/campcaster/elements/1.0/"
xmlns:ls="http://mdlf.org/campcaster/elements/1.0/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:xml="http://www.w3.org/XML/1998/namespace"
>
<dc:title>Webstream test 1</dc:title>
<dcterms:extent>01:30:00.000000</dcterms:extent>
<ls:url>http://localhost/y</ls:url>
</metadata>
</audioClip>

345
3rd_party/storageServer/var/webstreamFormat.php vendored
View file

@ -1,345 +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(),
),
*/
);
/*
?
ls:filename Text auto
*/
?>

3833
3rd_party/storageServer/var/xmlrpc/XR_LocStor.php vendored
View file

File diff suppressed because it is too large Load diff

4
3rd_party/storageServer/var/xmlrpc/index.php vendored
View file

@ -1,4 +0,0 @@
<?php
header ("location: xrLocStor.php");
exit;
?>

99
3rd_party/storageServer/var/xmlrpc/put.php vendored
View file

@ -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 &gt;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 Campcaster
* @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");
?>

511
3rd_party/storageServer/var/xmlrpc/schedulerPhpClient.php vendored
View file

@ -1,511 +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);
================= */
?>

128
3rd_party/storageServer/var/xmlrpc/simpleGet.php vendored
View file

@ -1,128 +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 &gt;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)");
}
?>

531
3rd_party/storageServer/var/xmlrpc/testRunner.sh vendored
View file

@ -1,531 +0,0 @@
#!/bin/bash
#-------------------------------------------------------------------------------
# Copyright (c) 2010 Sourcefabric O.P.S.
#
# This file is part of the Campcaster project.
# http://campcaster.campware.org/
#
# Campcaster 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.
#
# Campcaster 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 Campcaster; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
#-------------------------------------------------------------------------------
#DEBUG=yes
#DEBUG_I=yes
if [ "x$1" != "x" ]; then
COMM=$1
shift
GUNID=$1
fi
METADATA="<?xml version=\"1.0\"?>
<audioClip>
<metadata
xmlns=\"http://mdlf.org/campcaster/elements/1.0/\"
xmlns:ls=\"http://mdlf.org/campcaster/elements/1.0/\"
xmlns:dc=\"http://purl.org/dc/elements/1.1/\"
xmlns:dcterms=\"http://purl.org/dc/terms/\"
xmlns:xml=\"http://www.w3.org/XML/1998/namespace\"
>
<dc:title>Media title testRunner</dc:title>
<dcterms:extent>00:00:03.000000</dcterms:extent>
</metadata>
</audioClip>"
METAREGEX="(<\\?xml version=\"1\\.0\"( encoding=\"UTF-8\")?\\?> )?\
<audioClip>\
<metadata\
xmlns=\"http://mdlf\\.org/campcaster/elements/1\\.0/\"\
xmlns:dc=\"http://purl\\.org/dc/elements/1\\.1/\"\
xmlns:dcterms=\"http://purl\\.org/dc/terms/\"\
xmlns:ls=\"http://mdlf\\.org/campcaster/elements/1\\.0/\"\
xmlns:xml=\"http://www\\.w3\\.org/XML/1998/namespace\"\
>\
<dc:title>Media title testRunner</dc:title>\
<dcterms:extent>00:00:03\\.000000</dcterms:extent>\
<ls:mtime>[0-9]{4}(-[0-9]{2}){2}T[0-9]{2}(:[0-9]{2}){2}([-+][0-9]{1,2}:[0-9]{2})?</ls:mtime>\
</metadata>\
</audioClip>"
echo ""
XRDIR=`dirname $0`
XMLRPC=`cd var/install; php -q getXrUrl.php` || exit $?
echo "# storageServer XMLRPC URL: $XMLRPC"
cd $XRDIR
#XR_CLI="./xr_cli_test.py -s ${XMLRPC}"
XR_CLI="php -q xr_cli_test.php -s ${XMLRPC}"
login() {
echo -n "# login: "
SESSID=`$XR_CLI login root q` || \
{ ERN=$?; echo $SESSID; exit $ERN; }
echo "sessid: $SESSID"
}
test() {
echo "# test: "
$XR_CLI test $SESSID stringForUppercase || exit $?
}
existsAudioClip() {
echo -n "# existsAudioClip (${GUNID}): "
$XR_CLI existsAudioClip $SESSID $GUNID || exit $?
}
storeAudioClip() {
if [ "x$1" = "x" ]; then MEDIA=../tests/ex1.mp3; else MEDIA=$1; fi
if [ "x$2" = "x" ]; then GUNID=""; else GUNID=$2; fi
MD5=`md5sum $MEDIA`; for i in $MD5; do MD5=$i; break; done
if [ $DEBUG_I ]; then echo "md5=$MD5"; fi
echo -n "# storeAudioClipOpen: "
RES=`$XR_CLI storeAudioClipOpen "$SESSID" "$GUNID" "$METADATA" "stored file.mp3" "$MD5"` || \
{ ERN=$?; echo $RES; exit $ERN; }
unset URL
for i in $RES; do if [ -z $URL ] ; then URL=$i; else TOKEN=$i; fi; done
echo $TOKEN
if [ $DEBUG_I ]; then echo $URL; fi
if [ $DEBUG_I ]; then echo -n "Press enter ..."; read KEY; fi
echo -n "# curl (PUT): "
curl -C 0 -T $MEDIA $URL || { ERN=$?; echo $RGUNID; exit $ERN; }
echo "status: $?"
if [ $DEBUG_I ]; then echo -n "Press enter ..."; read KEY; fi
echo -n "# storeAudioClipClose: "
RGUNID=`$XR_CLI storeAudioClipClose "$SESSID" "$TOKEN"` || \
{ ERN=$?; echo $RGUNID; exit $ERN; }
echo $RGUNID
}
accessRawAudioData() {
echo -n "# accessRawAudioData: "
RES=`$XR_CLI accessRawAudioData $SESSID $GUNID` || \
{ ERN=$?; echo $RES; exit $ERN; }
unset URL
for i in $RES; do if [ -z $URL ] ; then URL=$i; else TOKEN=$i; fi; done
echo $TOKEN
if [ $DEBUG_I ]; then echo $URL; fi
if [ $DEBUG_I ]; then echo -n "Press enter ..."; read KEY; fi
echo -n "# releaseRawAudioData: "
$XR_CLI releaseRawAudioData $TOKEN || exit $?
}
downloadRAD() {
echo -n "# downloadRawAudioDataOpen: "
RES=`$XR_CLI downloadRawAudioDataOpen $SESSID $GUNID` || \
{ ERN=$?; echo $RES; exit $ERN; }
unset URL
for i in $RES; do if [ -z $URL ] ; then URL=$i; else TOKEN=$i; fi; done
echo $TOKEN
if [ $DEBUG_I ]; then echo $URL; fi
if [ $DEBUG_I ]; then echo -n "Press enter ..."; read KEY; fi
echo -n "# curl: "
curl -Ifs $URL > /dev/null || { ERN=$?; echo $URL; exit $ERN; }
echo "status: $?"
echo -n "# downloadRawAudioDataClose: "
$XR_CLI downloadRawAudioDataClose $SESSID $TOKEN || exit $?
}
downloadMeta() {
echo -n "# downloadMetadataOpen: "
RES=`$XR_CLI downloadMetadataOpen $SESSID $GUNID` || \
{ ERN=$?; echo $RES; exit $ERN; }
unset URL
for i in $RES; do if [ -z $URL ] ; then URL=$i; else TOKEN=$i; fi; done
echo $TOKEN
if [ $DEBUG_I ]; then echo $URL; fi
if [ $DEBUG_I ]; then echo -n "Press enter ..."; read KEY; fi
echo -n "# curl: "
METAOUT=`curl -fs $URL;` || { ERN=$?; echo $RES; exit $ERN; }
echo "OK"
if [ $DEBUG_I ]; then echo $METAOUT; echo -n "Press enter ..."; read KEY; fi
echo -n "# metadata check:"
METAOUT=`echo $METAOUT | sed -e 's/\\n/ /g'`
if [[ "x$METAOUT" =~ "x$METAREGEX" ]]; then
echo " OK"
else
echo " NOT MATCH ($?)"
echo " Expected match to regex:"; echo $METAREGEX
echo " Downloaded:"; echo ${METAOUT}
exit 1
fi
echo -n "# downloadMetadataClose: "
$XR_CLI downloadMetadataClose $SESSID $TOKEN || exit $?
}
deleteAudioClip() {
echo -n "# deleteAudioClip: "
# disabled:
# $XR_CLI deleteAudioClip $SESSID $GUNID || exit $?
$XR_CLI deleteAudioClip $SESSID $GUNID 0
}
updateAudioClipMetadata() {
echo -n "#updateAudioClipMetadata: "
$XR_CLI updateAudioClipMetadata $SESSID $GUNID "$METADATA" || exit $?
}
getAudioClip() {
echo -n "#getAudioClip: "
$XR_CLI getAudioClip $SESSID $GUNID || exit $?
}
searchMetadata() {
echo -n "# searchMetadata: "
RES=`$XR_CLI searchMetadata $SESSID 'title' 'testRunner'` || \
{ ERN=$?; echo $RES; exit $ERN; }
echo $RES
}
browseCategory() {
echo -n "# browseCategory: "
RES=`$XR_CLI browseCategory $SESSID 'title' 'title' 'testRunner'` || \
{ ERN=$?; echo $RES; exit $ERN; }
echo $RES
}
storeWebstream() {
URL="http://localhost/x"
echo -n "# storeWebstream: "
RGUNID=`$XR_CLI storeWebstream "$SESSID" '' "$METADATA" "new stream" "$URL"` || \
{ ERN=$?; echo $RGUNID; exit $ERN; }
echo $RGUNID
}
PLID="123456789abcdef8"
createPlaylist() {
echo -n "# createPlaylist: "
$XR_CLI deletePlaylist $SESSID $PLID 1
$XR_CLI createPlaylist $SESSID $PLID "newPlaylist.xml" || exit $?
}
accessPlaylist() {
echo -n "# accessPlaylist: "
RES=`$XR_CLI accessPlaylist $SESSID $PLID` || \
{ ERN=$?; echo $RES; exit $ERN; }
unset URL
for i in $RES; do if [ -z $URL ] ; then URL=$i; else TOKEN=$i; fi; done
echo $TOKEN
if [ $DEBUG_I ]; then echo $URL; fi
echo "# curl: "
CURLOUT=`curl -fs $URL;` || { ERN=$?; echo $RES; exit $ERN; }
if [ $DEBUG ]; then echo $CURLOUT; fi
# echo $CURLOUT
if [ $DEBUG_I ]; then echo -n "Press enter ..."; read KEY; fi
echo "# status: $?"
if [ $DEBUG_I ]; then echo -n "Press enter ..."; read KEY; fi
echo -n "# releasePlaylist: "
$XR_CLI releasePlaylist $TOKEN || exit $?
}
editPlaylist() {
DATE=`date '+%H:%M:%S'`
PLAYLIST="<?xml version=\"1.0\" encoding=\"utf-8\"?>
<playlist id=\"123456789abcdef8\" playlength=\"01:30:00.000000\"
title=\"My First Playlist\">
<playlistElement id=\"0000000000000101\" relativeOffset=\"0\" >
<audioClip id=\"0000000000010001\" playlength=\"01:00:00.000000\"
title=\"one\"/>
</playlistElement>
<playlistElement id=\"0000000000000102\" relativeOffset=\"01:00:00.000000\" >
<audioClip id=\"0000000000010002\" playlength=\"00:30:00.000000\"
title=\"two\"/>
</playlistElement>
<metadata
xmlns=\"http://www.streamonthefly.org/\"
xmlns:dc=\"http://purl.org/dc/elements/1.1/\"
xmlns:dcterms=\"http://purl.org/dc/terms/\"
xmlns:xbmf=\"http://www.streamonthefly.org/xbmf\"
xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
>
<dc:title>My First Playlist</dc:title>
<dc:creator>Me, myself and I</dc:creator>
<dcterms:extent>01:30:00.000000</dcterms:extent>
</metadata>
</playlist>
"
echo -n "# editPlaylist: "
RES=`$XR_CLI editPlaylist $SESSID $PLID` || \
{ ERN=$?; echo $RES; exit $ERN; }
unset URL
for i in $RES; do if [ -z $URL ] ; then URL=$i; else TOKEN=$i; fi; done
echo $TOKEN
# deletePlaylist
if [ $DEBUG_I ]; then echo $URL; fi
if [ $DEBUG_I ]; then echo -n "Press enter ..."; read KEY; fi
if [ $DEBUG_I ]; then echo " Playlist:"; echo $PLAYLIST; fi
echo -n "# savePlaylist: "
$XR_CLI savePlaylist $SESSID $TOKEN "$PLAYLIST" || exit $?
}
existsPlaylist() {
echo -n "# existsPlaylist (${PLID}): "
EXISTS=`$XR_CLI existsPlaylist $SESSID $PLID` || \
{ ERN=$?; echo $EXISTS; exit $ERN; }
echo $EXISTS
}
deletePlaylist() {
if [ "$EXISTS" != "FALSE" ]; then
echo -n "# deletePlaylist (${PLID}): "
# disabled:
# $XR_CLI deletePlaylist $SESSID $PLID || exit $?
$XR_CLI deletePlaylist $SESSID $PLID 0
echo "# status: $?"
fi
}
exportPlaylist() {
storeAudioClip ../tests/0000000000010001 0000000000010001
storeAudioClip ../tests/0000000000010002 0000000000010002
echo -n "# exportPlaylistOpen (${PLID}): "
# RES=`$XR_CLI exportPlaylistOpen $SESSID $PLID smil` || \
RES=`$XR_CLI exportPlaylistOpen $SESSID $PLID lspl` || \
{ ERN=$?; echo $RES; exit $ERN; }
unset URL
for i in $RES; do if [ -z $URL ] ; then URL=$i; else TOKEN=$i; fi; done
echo $TOKEN
echo -n "# curl: "
curl -Ifs $URL > /dev/null || { ERN=$?; echo $URL; exit $ERN; }
echo "status: $?"
echo -n "# exportPlaylistClose (${TOKEN}): "
RES=`$XR_CLI exportPlaylistClose $TOKEN` || \
{ ERN=$?; echo $RES; exit $ERN; }
echo $RES
}
importPlaylist() {
echo -n "# importPlaylistOpen: "
ARCHIVE=../tests/exportedPl_lspl.tar
# ARCHIVE=../tests/exportedPl_smil.tar
$XR_CLI deletePlaylist $SESSID 0000000000000001 1
$XR_CLI deletePlaylist $SESSID 0000000000000003 1
$XR_CLI deleteAudioClip $SESSID 0000000000010001 1
$XR_CLI deleteAudioClip $SESSID 0000000000010002 1
$XR_CLI deleteAudioClip $SESSID 0000000000010003 1
CHSUM=`md5sum $ARCHIVE | cut -d ' ' -f 1 `
RES=`$XR_CLI importPlaylistOpen $SESSID $CHSUM` || \
{ ERN=$?; echo $RES; exit $ERN; }
unset URL
for i in $RES; do if [ -z $URL ] ; then URL=$i; else TOKEN=$i; fi; done
echo $TOKEN
echo -n "# curl (PUT $URL): "
curl -C 0 -T $ARCHIVE $URL || { ERN=$?; echo "curl error"; exit $ERN; }
echo "status: $?"
echo -n "# importPlaylistClose (${TOKEN}): "
RES=`$XR_CLI importPlaylistClose $TOKEN` || \
{ ERN=$?; echo $RES; exit $ERN; }
echo $RES
GUNID=0000000000010001; existsAudioClip;
GUNID=0000000000010002; existsAudioClip;
GUNID=0000000000010003; existsAudioClip;
PLID=0000000000000001; existsPlaylist;
PLID=0000000000000003; existsPlaylist;
}
prefTest() {
PREFKEY="testKey"
PREFVAL="test preference value"
echo -n "# savePref ($PREFKEY): "
$XR_CLI savePref $SESSID "$PREFKEY" "$PREFVAL"|| exit $?
echo -n "# loadPref ($PREFKEY): "
VAL=`$XR_CLI loadPref $SESSID "$PREFKEY"` || \
{ ERN=$?; echo $VAL; exit $ERN; }
echo "$VAL "
if [ "x$VAL" != "x$PREFVAL" ] ; then
echo " NOT MATCH"
echo " Expected:"; echo $PREFVAL
echo " Returned:"; echo $VAL
exit 1
else
echo "# pref value check: OK"
fi
echo -n "# delPref: "
$XR_CLI delPref $SESSID "$PREFKEY"|| exit $?
if [ $DEBUG ]; then
echo -n "# loadPref: "
VAL=`$XR_CLI loadPref $SESSID "$PREFKEY"` || echo $?
else
echo $VAL
fi
}
groupPrefTest() {
PREFKEY="Station frequency"
PREFVAL="89.5 FM"
GR="StationPrefs"
echo -n "# saveGroupPref ($PREFKEY): "
$XR_CLI saveGroupPref $SESSID "$GR" "$PREFKEY" "$PREFVAL"|| exit $?
echo -n "# loadGroupPref ($PREFKEY): "
VAL=`$XR_CLI loadGroupPref $SESSID "$GR" "$PREFKEY"` || \
{ ERN=$?; echo $VAL; exit $ERN; }
echo "$VAL "
if [ "x$VAL" != "x$PREFVAL" ] ; then
echo " NOT MATCH"
echo " Expected:"; echo $PREFVAL
echo " Returned:"; echo $VAL
exit 1
else
echo "# pref value check: OK"
fi
echo -n "# saveGroupPref (clear it): "
$XR_CLI saveGroupPref $SESSID "$GR" "$PREFKEY" ""|| exit $?
}
logout() {
echo -n "# logout: "
$XR_CLI logout $SESSID || exit $?
}
searchTest() {
echo "#XMLRPC search test"
login
storeAudioClip
GUNID=$RGUNID
searchMetadata
OK="AC(1): $GUNID | PL(0): "
if [ "$RES" == "$OK" ]; then
echo "match: OK"
else
echo "results doesn't match ($OK)"; deleteAudioClip; exit 1;
fi
browseCategory
OK="RES(1): Media title testRunner"
if [ "$RES" == "$OK" ]; then
echo "match: OK"
else
echo "results doesn't match ($OK)"; deleteAudioClip; exit 1;
fi
deleteAudioClip
logout
echo "#XMLRPC: search: OK."
echo ""
}
preferenceTest(){
echo "#XMLRPC preference test"
login
prefTest
groupPrefTest
logout
echo "#XMLRPC: preference: OK."
echo ""
}
playlistTest(){
echo "#XMLRPC playlists test"
login
existsPlaylist
deletePlaylist
createPlaylist
existsPlaylist
accessPlaylist
editPlaylist
accessPlaylist
exportPlaylist
importPlaylist
deletePlaylist
existsPlaylist
logout
echo "#XMLRPC: playlists: OK."
echo ""
}
webstreamTest(){
echo "#XMLRPC webstream test"
login
storeWebstream; GUNID=$RGUNID
# GUNID="4e58a66cf6e9f539"
# downloadMeta
getAudioClip
deleteAudioClip
logout
echo "#XMLRPC: webstream: OK."
echo ""
}
storageTest(){
echo "#XMLRPC: storage test"
login
storeAudioClip
GUNID=$RGUNID
existsAudioClip
accessRawAudioData
downloadRAD
downloadMeta
deleteAudioClip
existsAudioClip
logout
echo "#XMLRPC: storage: OK."
echo ""
}
usage(){
echo "Usage: $0 [<command>] [args]"
echo -e "commands:\n test\n existsAudioClip\n accessRawAudioData"
echo -e " storeAudioClip\n deleteAudioClip\n updateAudioClipMetadata"
echo -e " getAudioClip\n searchMetadata\n"
echo -e " preferences\n playlists\n storage\n"
}
if [ "$COMM" = "test" ]; then
login
test
logout
elif [ "$COMM" = "existsAudioClip" ]; then
login
existsAudioClip
logout
elif [ "$COMM" = "accessRawAudioData" ]; then
login
accessRawAudioData
logout
elif [ "$COMM" = "storeAudioClip" ]; then
login
storeAudioClip
logout
elif [ "$COMM" = "deleteAudioClip" ]; then
login
deleteAudioClip
logout
elif [ "$COMM" = "updateAudioClipMetadata" ]; then
login
updateAudioClipMetadata
logout
elif [ "$COMM" = "getAudioClip" ]; then
login
getAudioClip
logout
elif [ "$COMM" = "searchMetadata" ]; then
searchTest
elif [ "$COMM" = "preferences" ]; then
preferenceTest
elif [ "$COMM" = "playlists" ]; then
playlistTest
elif [ "$COMM" = "webstream" ]; then
webstreamTest
elif [ "$COMM" = "storage" ]; then
storageTest
elif [ "x$COMM" = "x" ]; then
storageTest
playlistTest
preferenceTest
searchTest
elif [ "$COMM" = "help" ]; then
usage
else
echo "Unknown command"
usage
fi

7
3rd_party/storageServer/var/xmlrpc/urldecode vendored
View file

@ -1,7 +0,0 @@
#!/usr/bin/php -q
<?
$fp = fopen("/dev/stdin", "r");
$data = '';
while($part = fgets($fp, 1024)) $data .= $part;
echo urldecode($data);
?>

172
3rd_party/storageServer/var/xmlrpc/xrLocStor.php vendored
View file

@ -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 Campcaster.',
// '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);
?>

368
3rd_party/storageServer/var/xmlrpc/xr_cli_test.php vendored
View file

@ -1,368 +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";
}
}
?>

373
3rd_party/storageServer/var/xmlrpc/xr_web_test.php vendored
View file

@ -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>