/** * Returns an array containing information on an API. * * @return array info on an API */ public function execute() { $_apiNamePieces = explode('.', $this->apiName); $_apiNamespace = $_apiNamePieces[0]; $_apiPkg = $_apiNamePieces[1]; $_apiShortName = $_apiNamePieces[2]; $_apiClassFile = ucfirst($_apiPkg) . ucfirst($_apiShortName) . '.php'; // we need to scan the rest locations so we can get the full path info $_restLocations = M3_Util_Settings::getRestLocations(); $_deployedApiLocations = M3_Util_Settings::getDeployedApiLocations(); $_foundPathname = null; foreach ($_restLocations as $_restLocation) { foreach ($_deployedApiLocations as $_deployedApiLocation) { $_dir = M3_Util_File::buildPathName($_restLocation, $_deployedApiLocation); $_pathname = M3_Util_File::buildPathName($_dir, $_apiClassFile); if (file_exists($_pathname)) { $_foundPathname = $_pathname; break; } } if (!is_null($_foundPathname)) { break; } } $_info = array(); if (!is_null($_foundPathname)) { $_info['api_name'] = $this->apiName; $_info['pathname'] = $_foundPathname; } return array('api' => $_info); }
public function validateRequest() { if (!M3_Util_Settings::getAllowOperationEvaluatePhpCode()) { throw new OpenFBAPIException("Evaluation of PHP code is disallowed"); } $this->phpCode = $this->getRequiredApiParam("phpCode"); }
function echo_errorlog() { $_errorLogPath = M3_Util_Settings::getPhpErrorLogPathName(); if ($_errorLogPath) { if (get_request_param("clearerrorlog")) { if (!M3_Util_File::truncateFile($_errorLogPath)) { echo "<i>Count not truncate error log [{$_errorLogPath}]</i>"; } } echo <<<EOL1 <h2 align="center">{$_errorLogPath}</h2> <table align="center"><tr><td> <form action="index.php"> <input type="hidden" name="show" value="errorlog"/> <input type="hidden" name="clearerrorlog" value="true"/> <input type="submit" value="Clear"/> </form> </td></tr></table> EOL1; echo "<pre>"; echo htmlentities(file_get_contents($_errorLogPath)); echo "</pre>"; } else { echo "Cannot determine where the error log is"; } }
/** * Returns an associative, multi-dimensional array containing version * information about different software components in the server. * * @return array all version information */ public function execute() { $_ringside = array('version' => $this->getRingsideServerVersion(), 'build_number' => $this->getRingsideServerBuildNumber(), 'build_date' => $this->getRingsideServerBuildDate(), 'svn_revision' => $this->getRingsideServerSvnRevision(), 'install_dir' => M3_Util_Settings::getRingsideServerInstallDir()); $_php = array('version' => $this->getPhpVersionReal(), 'doctrine_version' => Doctrine::VERSION, 'php_ini_file' => M3_Util_Settings::getPhpIniFileLocation()); // get all loaded extension versions $_extensions = array(); $_loadedExtensions = get_loaded_extensions(); foreach ($_loadedExtensions as $_loadedExtension) { $_extensions[strtolower($_loadedExtension)] = $this->getPhpVersionForExtension($_loadedExtension); } // There are some extensions we know we need, so force ourselves to get // their information. This is so we can show unloaded extensions in the list // to let the caller know something is missing that we expect to be loaded. $_extensions['tidy'] = $this->getPhpVersionForExtension('tidy'); $_extensions['curl'] = $this->getPhpVersionForExtension('curl'); $_extensions['xsl'] = $this->getPhpVersionForExtension('xsl'); $_extensions['mcrypt'] = $this->getPhpVersionForExtension('mcrypt'); $_extensions['pdo'] = $this->getPhpVersionForExtension('pdo'); ksort($_extensions); $_extList = array(); foreach ($_extensions as $_name => $_version) { $_extList[] = array('name' => $_name, 'version' => $_version); } return array('ringside' => $_ringside, 'php' => $_php, 'extensions' => array('extension' => $_extList)); }
/** * Returns an associative array of all php.ini configuration settings. * The list returned is an array of name/value pair arrays. * * @return array php.ini configuration settings, or false on error */ public function execute() { $_settings = M3_Util_Settings::getPhpIniSettings(); if ($_settings) { $_nameValues = array(); foreach ($_settings as $_name => $_value) { $_nameValues[] = array('name' => $_name, 'value' => $_value); } return array('php_ini_setting' => $_nameValues); } else { return false; } }
public function validateRequest() { $this->pathname = $this->getRequiredApiParam("pathname"); $this->useIncludePath = $this->getApiParam("useIncludePath"); // not allowed to look for files in parent directories if (preg_match("/\\.\\./", $this->pathname)) { throw new OpenFBAPIException("Illegal pathname has been rejected"); } if (isset($this->useIncludePath) && $this->useIncludePath == "true") { $this->pathname = M3_Util_File::findFileInIncludePath($this->pathname); } else { $_installDir = M3_Util_Settings::getRingsideServerInstallDir(); $this->pathname = M3_Util_File::buildPathName($_installDir, $this->pathname); } if (!file_exists($this->pathname)) { throw new OpenFBAPIException("File [{$this->pathname}] does not exist"); } // don't process request for any content larger than 1MB $_size = filesize($this->pathname); if ($_size >= M3_Util_Settings::getMaxSizeAllowedOperationGetFileContent()) { throw new OpenFBAPIException("File [{$this->pathname}] is too large [{$_size}]"); } return; }
/** * Returns the APIs that are currently deployed in the given rest directory name. * The returned names will be the full REST API name that REST clients can use * to invoke the APIs. This includes the three-parts to the REST API: * <namespace>.<package>.<class>; e.g. "m3.inventory.getApis" * * @param $apiNamespace the namespace of the APIs found in the given directory * @param $restDir the directory name where the API classes can be found * * @return array names of all APIs deployed in the server in the given directory * the array is associative, where the key is the API name and the value * is the php file that implements that API */ private function getApiNamesInDirectory($apiNamespace, $restDir) { $_rootDirs = M3_Util_Settings::getRestLocations(); $_names = array(); foreach ($_rootDirs as $_dir) { $_fullApiDirectory = $_dir . $restDir; if (file_exists($_fullApiDirectory)) { $_files = scandir($_fullApiDirectory); foreach ($_files as $_file) { if (!is_dir($_file)) { $_apiName = $this->determineApiName($_file); if (!empty($_apiName)) { $_name = $apiNamespace . '.' . $_apiName; if (!$this->isIgnoredName($_name)) { $_names[$_name] = $_fullApiDirectory . '/' . $_file; } } } } } } return $_names; }
public function testGetErrorLogs() { $_phpErrorLog = M3_Util_Settings::getPhpErrorLogPathName(); $_webInstallDir = M3_Util_Settings::getWebServerInstallationDirectory(); $_webErrorLog = M3_Util_Settings::getWebServerErrorLogPathName(); }
public function testPhpIniFile() { $_phpLocation = M3_Util_Settings::getPhpIniFileLocation(); $this->assertTrue(!empty($_phpLocation)); $_php = new M3_Util_IniSettings($_phpLocation, false); $_php->readIniFile($_phpSettings, true); $this->assertArrayHasKey('PHP', $_phpSettings); $this->assertArrayHasKey('engine', $_phpSettings['PHP']); $this->assertEquals('on', strtolower($_phpSettings['PHP']['engine'])); }
// Set up validation FIXME: this really breaks out stuff, not good //$manager->setAttribute(Doctrine::ATTR_VALIDATE, Doctrine::VALIDATE_ALL); // Set up caching if (isset($useDbCache) && $useDbCache === true) { $sqlite_conn = Doctrine_Manager::connection(new PDO('sqlite:memory')); $cacheDriver = new Doctrine_Cache_Db(array('connection' => $sqlite_conn, 'tableName' => 'ringside_api')); try { $cacheDriver->createTable(); } catch (Doctrine_Connection_Exception $e) { if ($e->getPortableCode() !== Doctrine::ERR_ALREADY_EXISTS) { $cacheDriver = null; } } if (null !== $cacheDriver) { $manager->setAttribute(Doctrine::ATTR_QUERY_CACHE, $cacheDriver); $manager->setAttribute(Doctrine::ATTR_RESULT_CACHE, $cacheDriver); // Result cache set for 5 minutes - FIXME: this causes php to crash. Riddle me that! //$manager->setAttribute(Doctrine::ATTR_RESULT_CACHE_LIFESPAN, 300); //Doctrine::ATTR_RESULT_CACHE_LIFESPAN; //Doctrine::ATTR_QUERY_CACHE_LIFESPAN } } $conn = Doctrine_Manager::connection($dsn); require_once 'ringside/m3/util/Settings.php'; if (M3_Util_Settings::getDbProfilerEnable()) { require_once 'ringside/m3/metric/DoctrineProfiler.php'; $profiler = new M3_Metric_DoctrineProfiler(); $conn->setListener($profiler); } $conn->setAttribute('portability', Doctrine::PORTABILITY_ALL); spl_autoload_register(array('RingsideApiServer', 'autoload'));
/** * Creates a new listener that can listen for events when API invocations occur. * The returned listener object also provides methods that can be used to retrieve * aggregated information about the API invocations that have occurred. * * @return M3_Metric_IApiInvocationListener the listener created */ public static function createApiInvocationListener() { $_ds = M3_Util_Settings::getDatastore(); if ($_ds->isDB()) { $_listener = new M3_Db_ApiInvocationListener(); } return $_listener; }
/** * Validate the M3 request by ensuring the request was properly signed * with the M3 secret key. The verification algorithm is as follows: * <ol> * <li>Ensure the request has a signature string (found in the context)</li> * <li>Sort all request parameters via PHP ksort() method</li> * <li>Build a single string with request parameter "name=value" pairs</li> * <li>Append to the string the M3 secret key that is configured in the server</li> * <li>Calculate an MD5 hashcode for the string</li> * <li>Verify that the MD5 hashcode matches the signature string passed in with the request</li> * </ol> */ public function validateSig() { $_sig = $this->getContext()->getSig(); $_request = $this->getContext()->getInitialRequest(); $_secret = M3_Util_Settings::getM3SecretKey(); if (!isset($_sig) || empty($_sig)) { throw new Exception('M3 request rejected - it is missing a signature'); } ksort($_request); $_str = ''; foreach ($_request as $_k => $_v) { if ($_k != 'sig') { $_str .= "{$_k}={$_v}"; } } $_str .= $_secret; $_md5sig = md5($_str); if ($_md5sig != $_sig) { $_emsg = 'M3 request rejected - incorrect signature'; error_log("{$_emsg}: _str=[{$_str}], _md5sig=[{$_md5sig}], _sig=[{$_sig}]"); throw new Exception($_emsg); } return; }
/** * Return array of locations where REST APIs can be located. * * These are directories that deployed API locations can be rooted at. * In other words, get these rest locations first, then under these directories, * you should be able to find deployed REST APIs in the subdirectories * specified by {@link getDeployedApiLocations()}. * * @return array of directory locations where REST APIs can be found */ public static function getRestLocations() { if (!empty(self::$restLocations)) { return self::$restLocations; } $_restLocations = array(); $_includePaths = explode(PATH_SEPARATOR, get_include_path()); foreach ($_includePaths as $_includePath) { $_includePath = realpath(rtrim($_includePath, '\\/')); if ($_includePath) { $_restLocations[] = $_includePath; } } self::$restLocations = array_unique($_restLocations); // if include_path has any dups, remove them return self::$restLocations; }
protected static function getCacheFileName() { $dataDir = M3_Util_Settings::getDataDirectory(); $fname = $dataDir . DIRECTORY_SEPARATOR . 'Social_Dsl_TagRegistry.config'; return $fname; }
protected function initClient() { unset($this->client); $this->client = new M3_Client_RestClient(M3_Util_Settings::getRestServerUrl(), M3_Util_Settings::getM3SecretKey(), null); $this->assertTrue(isset($this->client)); }
/** * Creates a doctrine profiler. */ public function __construct() { parent::__construct(); $this->dataDirectory = M3_Util_Settings::getDataDirectory() . '/doctrine-profiler'; $this->md5FilesCreated = array(); }