public static function initialize($logger)
{
if (!is_null(self::$logger)) {
throw new \RuntimeException(__METHOD__ . ' can be called only once per script execution');
}
self::$logger = $logger;
}
/**
* Logs data to the shibboleth debug log
*
* @param string $msg the message to log
* @param string|object $data additional data to log
* @return void
**/
private static function log($msg, $data = '')
{
static $params;
if (!isset($params)) {
$params = Plugin::params('authentication', 'shibboleth');
}
if ($params->get('debug_enabled', true)) {
if (!\Log::has('shib')) {
$location = $params->get('debug_location', '/var/log/apache2/php/shibboleth.log');
$location = explode(DS, $location);
$file = array_pop($location);
\Log::register('shib', ['path' => implode(DS, $location), 'file' => $file, 'level' => 'info', 'format' => "%datetime% %message%\n"]);
}
// Create a token to identify related log entries
if (!($cookie = Cookie::eat('shib-dbg-token'))) {
$token = base64_encode(uniqid());
Cookie::bake('shib-dbg-token', time() + 60 * 60 * 24, ['shib-dbg-token' => $token]);
} else {
$token = $cookie->{'shib-dbg-token'};
}
$toBeLogged = "{$token} - {$msg}";
if (!empty($data)) {
$toBeLogged .= ":\t" . (is_string($data) ? $data : json_encode($data));
}
\Log::logger('shib')->info("{$toBeLogged}");
}
}
/**
* Run the credential importer
*
* @param string $json_file The JSON file that contains a list of the APIs and their credentials
*/
public static function run($json_file = null)
{
if (empty($json_file) || file_exists($json_file) === false) {
exit('You must specify a valid JSON file that contains your credentials.' . PHP_EOL);
}
if (($json = json_decode(file_get_contents($json_file), true)) === null) {
exit('The JSON file does not contain valid JSON text.' . PHP_EOL);
}
// Find the API version to use for importing the keys
$version = 'V1';
if (!empty($json[0]['version'])) {
if (is_int($json[0]['version']) && \Module::exists('V' . $json[0]['version'])) {
\Module::load('V' . $json[0]['version']);
$version = 'V' . $json[0]['version'];
} else {
\Module::load($version);
}
array_shift($json);
} else {
\Module::load($version);
}
$error = false;
foreach ($json as $entry) {
// We need these keys for each entry.
if (!array_key_exists('api', $entry) || !array_key_exists('credentials', $entry)) {
echo \Cli::color('The JSON data is in the wrong format. Skipping.' . PHP_EOL, 'yellow');
$error = true;
continue;
}
if (!is_string($entry['api'])) {
echo \Cli::color('The API name must be a string. Skipping.' . PHP_EOL, 'yellow');
$error = true;
continue;
}
// Make sure that we have credentials to add to the DB.
if (empty($entry['credentials']) || !is_array($entry['credentials'])) {
echo \Cli::color('The array of credentials for ' . $entry['api'] . ' is empty. Skipping.' . PHP_EOL, 'yellow');
$error = true;
continue;
}
$response = call_user_func('\\' . $version . '\\Keyring::set_credentials', $entry['credentials'], $entry['api']);
// Show and log the result
if ($response === true) {
$success_text = 'Successfully imported the credentials for API: ' . $entry['api'];
echo \Cli::color($success_text . PHP_EOL, 'green');
\Log::logger('INFO', 'CLI:ADD_CREDENTIALS', $success_text, __METHOD__, array('api' => $entry['api']));
} else {
$error_text = 'Failed to import the credentials for API: ' . $entry['api'];
echo \Cli::color('Warning: ' . $error_text . PHP_EOL, 'red');
$error = true;
\Log::logger('ERROR', 'CLI:ADD_CREDENTIALS', $error_text, __METHOD__, array('api' => $entry['api']));
}
}
// Display the summary.
if ($error === true) {
echo \Cli::color(PHP_EOL . 'Some credentials were not added to the database. See the error log for more details.' . PHP_EOL, 'red');
} else {
echo \Cli::color(PHP_EOL . 'All credentials were successfully added to the database.' . PHP_EOL, 'green');
}
}
/**
* Выполняет обработку запроса
*
* @param WS_Environment $env
*
* @return mixed
*/
public function run(WS_Environment $env)
{
$handler = Log_FirePHP::Handler();
$handler->where('level', '>=', $this->log_level);
Log::logger()->handler($handler);
$response = $this->application->run($env);
$handler->dump($response);
return $response;
}
/**
* Logs a message and adds <br /> html tag.
* @param string $level Log level
* @param string $message Log message
*/
public static function log($level, $message)
{
// check if to create new logger instance
if (Log::$logger == null) {
Logger::configure(realpath(dirname(__FILE__)) . '/log.xml');
Log::$logger = Logger::getLogger('main');
}
// call log function in logger instance
call_user_func(array(Log::$logger, $level), $message);
}
public static function salvarLog($modulo, $acao, $mensagem)
{
$log = new Log();
$log->modulo = $modulo;
$log->acao = $acao;
$log->mensagem = $mensagem;
if (!empty($_SESSION['auth']['id'])) {
$log->fkUsuario = $_SESSION['auth']['id'];
}
$log->logger($log);
}
/**
* Logging wrapper for off site requests (Allows for desired log formatting)
*
* @param string $uri The URL to execute
* @param string $options The type of request
* @param string $method The HTTP method to use for the request
*/
public static function forge($uri = NULL, $options = true, $method = NULL)
{
/*
* If someone uses this for internal calls, we'll still allow it to function, but we don't log it since it
* isn't a remote request.
*/
if (is_string($options)) {
// We only grab the URL and method, not params or headers since the latter two could contain sensitive data.
$tokens = array('url' => $uri, 'method' => $method);
// Log the request
\Log::logger('INFO', 'REMOTE:' . $options, 'Started execution of an off-site request', __METHOD__, $tokens);
}
return parent::forge($uri, $options, $method);
}
/**
* Validate the request to make sure we have trusted and sufficient data.
*
* @return mixed True on success, or an array of error data on fail
*/
public static function run()
{
/**
* Verify that we have at least an "api" or "data-call" token.
*/
if (\V1\APIRequest::get('api', false) === false && \V1\APIRequest::get('data-call', false) === false) {
return \Utility::format_error(400, \V1\Err::BAD_BODY, \Lang::get('v1::errors.bad_body'));
}
/**
* Easter egg processing plant
*/
if (\V1\APIRequest::get('api') === 'I\'m a teapot') {
return \Utility::format_error(418, \V1\Err::IM_A_TEAPOT, str_replace("\t", '', \Lang::get('v1::errors.im_a_teapot')));
}
/**
* AUTHORIZATION
*/
// Once we've authenticated to start running calls from one Data Call, we don't authenticate again.
if (\Session::get('data_call', false) === false) {
// If they failed to authenticate, then issue a 401 unauthorized error.
if (\V1\Account::authenticate() === false) {
// Log the failure.
\Log::logger('INFO', 'AUTHORIZE:FAIL', \Lang::get('log.authorize_fail'), __METHOD__, array('consumer_key' => \Session::get('consumer_key', 'NOT SET'), 'public_mode' => \Session::get('public', 'NOT SET')));
return \Utility::format_error(401);
}
// Log the success.
\Log::logger('INFO', 'AUTHORIZE:SUCCESS', \Lang::get('log.authorize_success'), __METHOD__, array('consumer_key' => \Session::get('consumer_key', 'NOT SET'), 'public_mode' => \Session::get('public', 'NOT SET')));
/**
* DOWNGRADE PROCESSING
*/
\V1\Account::downgrade();
}
/**
* GLOBAL LIMITS
*/
if (static::check_global_limits() === false) {
return \Utility::format_error(429, \V1\Err::MAXED_OUT_LIMITS, \Lang::get('v1::errors.maxed_out_limits'));
}
return true;
}
protected function _processTask()
{
try {
if ($this->isAtom) {
foreach ($this->tasks as $task) {
if (is_array($task)) {
$task = AbstractTask::createTask($task);
}
$task->run();
}
} else {
foreach ($this->tasks as $task) {
if (is_array($task)) {
$task = AbstractTask::createTask($task);
}
$task->push();
}
}
} catch (Exception $e) {
Log::logger()->addError($e->getMessage);
}
}
protected static function _writeTo($stringData)
{
if (!file_exists(INIT::$LOG_REPOSITORY) || !is_dir(INIT::$LOG_REPOSITORY)) {
mkdir(INIT::$LOG_REPOSITORY);
}
if (!empty(self::$fileName)) {
self::$fileNamePath = LOG_REPOSITORY . "/" . self::$fileName;
} else {
self::$fileNamePath = LOG_REPOSITORY . "/" . LOG_FILENAME;
}
if (self::$useMonolog) {
try {
if (empty(self::$logger)) {
$matecatRedisHandler = new \RedisHandler();
// Init a RedisHandler with a LogstashFormatter.
// The parameters may differ depending on your configuration of Redis.
// Important: The parameter 'logs' must be equal to the key you defined
// in your logstash configuration.
$redisHandler = new RedisHandler($matecatRedisHandler->getConnection(), 'phplogs');
$logStashFormatter = new LogstashFormatter('MateCat', gethostname());
$redisHandler->setFormatter($logStashFormatter);
//Log on file
$fileHandler = new StreamHandler(self::$fileNamePath);
$fileFormatter = new LineFormatter(null, null, true, true);
$fileHandler->setFormatter($fileFormatter);
// Create a Logger instance with the RedisHandler
self::$logger = new Logger('MateCat', array($redisHandler, $fileHandler));
}
self::$logger->debug($stringData);
} catch (Exception $e) {
file_put_contents(self::$fileNamePath, $stringData, FILE_APPEND);
}
} else {
file_put_contents(self::$fileNamePath, $stringData, FILE_APPEND);
}
}
public static function set_logger($value)
{
self::$logger = $value;
}
/**
* Завершает выполнение
*
* @param int $status
*/
protected function finalize($status)
{
$this->shutdown();
Log::logger()->close();
return $this->exit_wrapper($status);
}
/**
* Ugly workaround to reset the logger, so the method _writeTo re-initialize the logger configuration
*
*/
public static function resetLogger()
{
self::$logger = null;
}
protected function load_childs_by($rows, $input)
{
$child_count = 0;
$result_child = $child = $this->extract_parent_ids(array_keys($input));
$i = 0;
while (count($child) > 0) {
$child = $this->extract_parent_ids(array_keys($child));
$result_child += $child;
$i++;
}
Log::logger()->debug('depth', $i);
$rows += $result_child;
return array($rows, $result_child);
}
public function test_logger()
{
$tokens = array('test token 1' => 'value', 'testtoken2' => 'value', '`~!@#$%^&*()_+-=[]{}\\|;:\'",<.>/?' => 'value');
\Log::logger('INFO', 'PHPUNIT:LOGGER', 'The PHPUnit test for \\Log::logger() was successful.', __METHOD__, $tokens);
// If we don't get errors, then we're good to go.
}