PHP Application\Logger类代码示例

 /**
  * Apply permissions, restrictions and roles to the given user
  *
  * @param   User    $user
  */
 public function applyRoles(User $user)
 {
     $username = $user->getUsername();
     try {
         $roles = Config::app('roles');
     } catch (NotReadableError $e) {
         Logger::error('Can\'t get permissions and restrictions for user \'%s\'. An exception was thrown:', $username, $e);
         return;
     }
     $userGroups = $user->getGroups();
     $permissions = array();
     $restrictions = array();
     $roleObjs = array();
     foreach ($roles as $roleName => $role) {
         if ($this->match($username, $userGroups, $role)) {
             $permissionsFromRole = StringHelper::trimSplit($role->permissions);
             $permissions = array_merge($permissions, array_diff($permissionsFromRole, $permissions));
             $restrictionsFromRole = $role->toArray();
             unset($restrictionsFromRole['users']);
             unset($restrictionsFromRole['groups']);
             unset($restrictionsFromRole['permissions']);
             foreach ($restrictionsFromRole as $name => $restriction) {
                 if (!isset($restrictions[$name])) {
                     $restrictions[$name] = array();
                 }
                 $restrictions[$name][] = $restriction;
             }
             $roleObj = new Role();
             $roleObjs[] = $roleObj->setName($roleName)->setPermissions($permissionsFromRole)->setRestrictions($restrictionsFromRole);
         }
     }
     $user->setPermissions($permissions);
     $user->setRestrictions($restrictions);
     $user->setRoles($roleObjs);
 }

 /**
  * Set the hook as failed w/ the given message
  *
  * @param   string  $message    Error message or error format string
  * @param   mixed   ...$arg     Format string argument
  */
 private function fail($message)
 {
     $args = array_slice(func_get_args(), 1);
     $lastError = vsprintf($message, $args);
     Logger::debug($lastError);
     $this->lastError = $lastError;
 }

 /**
  * Set the filter and render it internally.
  *
  * @param  Filter $filter
  *
  * @return $this
  *
  * @throws ProgrammingError
  */
 public function setFilter(Filter $filter)
 {
     $this->filter = $filter;
     $this->query = $this->renderFilter($this->filter);
     Logger::debug('Rendered elasticsearch filter: %s', json_encode($this->query));
     return $this;
 }

 /**
  * Append the given log entry and fail this inspection with the given error
  *
  * @param   $entry  string|Inspection   A log entry or nested inspection
  *
  * @throws  ProgrammingError            When called multiple times
  *
  * @return  this                        fluent interface
  */
 public function error($entry)
 {
     if (isset($this->error)) {
         throw new ProgrammingError('Inspection object used after error');
     }
     Logger::error($entry);
     $this->log[] = $entry;
     $this->error = $entry;
     return $this;
 }

 /**
  * Display exception
  */
 public function errorAction()
 {
     $error = $this->_getParam('error_handler');
     $exception = $error->exception;
     /** @var \Exception $exception */
     Logger::error($exception);
     Logger::error('Stacktrace: %s', $exception->getTraceAsString());
     switch ($error->type) {
         case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
         case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
         case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
             $modules = Icinga::app()->getModuleManager();
             $path = ltrim($this->_request->get('PATH_INFO'), '/');
             $path = preg_split('~/~', $path);
             $path = array_shift($path);
             $this->getResponse()->setHttpResponseCode(404);
             $this->view->message = $this->translate('Page not found.');
             if ($this->Auth()->isAuthenticated() && $modules->hasInstalled($path) && !$modules->hasEnabled($path)) {
                 $this->view->message .= ' ' . sprintf($this->translate('Enabling the "%s" module might help!'), $path);
             }
             break;
         default:
             switch (true) {
                 case $exception instanceof HttpMethodNotAllowedException:
                     $this->getResponse()->setHttpResponseCode(405);
                     $this->getResponse()->setHeader('Allow', $exception->getAllowedMethods());
                     break;
                 case $exception instanceof HttpNotFoundException:
                     $this->getResponse()->setHttpResponseCode(404);
                     break;
                 case $exception instanceof MissingParameterException:
                     $this->getResponse()->setHttpResponseCode(400);
                     $this->getResponse()->setHeader('X-Status-Reason', 'Missing parameter ' . $exception->getParameter());
                     break;
                 case $exception instanceof HttpBadRequestException:
                     $this->getResponse()->setHttpResponseCode(400);
                     break;
                 case $exception instanceof SecurityException:
                     $this->getResponse()->setHttpResponseCode(403);
                     break;
                 default:
                     $this->getResponse()->setHttpResponseCode(500);
                     break;
             }
             $this->view->message = $exception->getMessage();
             if ($this->getInvokeArg('displayExceptions')) {
                 $this->view->stackTrace = $exception->getTraceAsString();
             }
             break;
     }
     if ($this->getRequest()->isApiRequest()) {
         $this->getResponse()->json()->setErrorMessage($this->view->message)->sendResponse();
     }
     $this->view->request = $error->request;
 }

 /**
  * Display the application log
  */
 public function applicationlogAction()
 {
     if (!Logger::writesToFile()) {
         $this->httpNotFound('Page not found');
     }
     $this->addTitleTab('application log');
     $resource = new FileReader(new ConfigObject(array('filename' => Config::app()->get('logging', 'file'), 'fields' => '/(?<!.)(?<datetime>[0-9]{4}(?:-[0-9]{2}){2}' . 'T[0-9]{2}(?::[0-9]{2}){2}(?:[\\+\\-][0-9]{2}:[0-9]{2})?)' . ' - (?<loglevel>[A-Za-z]+) - (?<message>.*)(?!.)/msS')));
     $this->view->logData = $resource->select()->order('DESC');
     $this->setupLimitControl();
     $this->setupPaginationControl($this->view->logData);
 }

 /**
  * Parse the given query text and returns the json as expected by the semantic search box
  *
  * @param  String $text     The query to parse
  * @return array            The result structure to be returned in json format
  */
 private function parse($text, $target)
 {
     try {
         $queryTree = $this->registry->createQueryTreeForFilter($text);
         $registry = $this->moduleRegistry;
         return array('state' => 'success', 'proposals' => $this->registry->getProposalsForQuery($text), 'urlParam' => $registry::getUrlForTarget($target, $queryTree), 'valid' => count($this->registry->getIgnoredQueryParts()) === 0);
     } catch (\Exception $exc) {
         Logger::error($exc);
         $this->getResponse()->setHttpResponseCode(500);
         return array('state' => 'error', 'message' => 'Search service is currently not available');
     }
 }

 /**
  * Resolve a macro based on the given object
  *
  * @param   string                      $macro      The macro to resolve
  * @param   MonitoredObject|stdClass    $object     The object used to resolve the macro
  *
  * @return  string                                  The new value or the macro if it cannot be resolved
  */
 public static function resolveMacro($macro, $object)
 {
     if (isset(self::$icingaMacros[$macro]) && isset($object->{self::$icingaMacros[$macro]})) {
         return $object->{self::$icingaMacros[$macro]};
     }
     try {
         $value = $object->{$macro};
     } catch (Exception $e) {
         $value = null;
         Logger::debug('Unable to resolve macro "%s". An error occured: %s', $macro, $e);
     }
     return $value !== null ? $value : $macro;
 }

 public function setAuthenticated(User $user, $persist = true)
 {
     $username = $user->getUsername();
     try {
         $config = Config::app();
     } catch (NotReadableError $e) {
         Logger::error(new IcingaException('Cannot load preferences for user "%s". An exception was thrown: %s', $username, $e));
         $config = new Config();
     }
     if ($config->get('preferences', 'store', 'ini') !== 'none') {
         $preferencesConfig = $config->getSection('preferences');
         try {
             $preferencesStore = PreferencesStore::create($preferencesConfig, $user);
             $preferences = new Preferences($preferencesStore->load());
         } catch (Exception $e) {
             Logger::error(new IcingaException('Cannot load preferences for user "%s". An exception was thrown: %s', $username, $e));
             $preferences = new Preferences();
         }
     } else {
         $preferences = new Preferences();
     }
     $user->setPreferences($preferences);
     $groups = $user->getGroups();
     foreach (Config::app('groups') as $name => $config) {
         try {
             $groupBackend = UserGroupBackend::create($name, $config);
             $groupsFromBackend = $groupBackend->getMemberships($user);
         } catch (Exception $e) {
             Logger::error('Can\'t get group memberships for user \'%s\' from backend \'%s\'. An exception was thrown: %s', $username, $name, $e);
             continue;
         }
         if (empty($groupsFromBackend)) {
             continue;
         }
         $groupsFromBackend = array_values($groupsFromBackend);
         $groups = array_merge($groups, array_combine($groupsFromBackend, $groupsFromBackend));
     }
     $user->setGroups($groups);
     $admissionLoader = new AdmissionLoader();
     list($permissions, $restrictions) = $admissionLoader->getPermissionsAndRestrictions($user);
     $user->setPermissions($permissions);
     $user->setRestrictions($restrictions);
     $this->user = $user;
     if ($persist) {
         $this->persistCurrentUser();
     }
 }

 /**
  * {@inheritdoc}
  */
 protected function setupLogger()
 {
     $config = new ConfigObject();
     $config->log = $this->params->shift('log', 'stderr');
     if ($config->log === 'file') {
         $config->file = $this->params->shiftRequired('log-path');
     } elseif ($config->log === 'syslog') {
         $config->application = 'icingacli';
     }
     if ($this->params->get('verbose', false)) {
         $config->level = Logger::INFO;
     } elseif ($this->params->get('debug', false)) {
         $config->level = Logger::DEBUG;
     } else {
         $config->level = Logger::WARNING;
     }
     Logger::create($config);
     return $this;
 }

 /**
  * Register all custom user backends from all loaded modules
  */
 protected static function registerCustomUserBackends()
 {
     if (static::$customBackends !== null) {
         return;
     }
     static::$customBackends = array();
     $providedBy = array();
     foreach (Icinga::app()->getModuleManager()->getLoadedModules() as $module) {
         foreach ($module->getUserBackends() as $identifier => $className) {
             if (array_key_exists($identifier, $providedBy)) {
                 Logger::warning('Cannot register user backend of type "%s" provided by module "%s".' . ' The type is already provided by module "%s"', $identifier, $module->getName(), $providedBy[$identifier]);
             } elseif (in_array($identifier, static::$defaultBackends)) {
                 Logger::warning('Cannot register user backend of type "%s" provided by module "%s".' . ' The type is a default type provided by Icinga Web 2', $identifier, $module->getName());
             } else {
                 $providedBy[$identifier] = $module->getName();
                 static::$customBackends[$identifier] = $className;
             }
         }
     }
 }

 protected function addMessage($message, $type = 'info')
 {
     if (!in_array($type, array('info', 'error', 'warning', 'success'))) {
         throw new ProgrammingError('"%s" is not a valid notification type', $type);
     }
     if ($this->isCli) {
         $msg = sprintf('[%s] %s', $type, $message);
         switch ($type) {
             case 'info':
             case 'success':
                 Logger::info($msg);
                 break;
             case 'warning':
                 Logger::warn($msg);
                 break;
             case 'error':
                 Logger::error($msg);
                 break;
         }
         return;
     }
     $this->messages[] = (object) array('type' => $type, 'message' => $message);
 }

 /**
  * Parse the given value based on the ASN.1 standard (GeneralizedTime) and return its timestamp representation
  *
  * @param   string|null     $value
  *
  * @return  int
  */
 protected function retrieveGeneralizedTime($value)
 {
     if ($value === null) {
         return $value;
     }
     if (($dateTime = DateTime::createFromFormat('YmdHis.uO', $value)) !== false || ($dateTime = DateTime::createFromFormat('YmdHis.uZ', $value)) !== false || ($dateTime = DateTime::createFromFormat('YmdHis.u', $value)) !== false || ($dateTime = DateTime::createFromFormat('YmdHis', $value)) !== false || ($dateTime = DateTime::createFromFormat('YmdHi', $value)) !== false || ($dateTime = DateTime::createFromFormat('YmdH', $value)) !== false) {
         return $dateTime->getTimeStamp();
     } else {
         Logger::debug(sprintf('Failed to parse "%s" based on the ASN.1 standard (GeneralizedTime) in repository "%s".', $value, $this->getName()));
     }
 }

 /**
  * Fetch and return all users from all user backends
  *
  * @return  ArrayDatasource
  */
 protected function fetchUsers()
 {
     $users = array();
     foreach ($this->loadUserBackends('Icinga\\Data\\Selectable') as $backend) {
         try {
             foreach ($backend->select(array('user_name')) as $row) {
                 $users[] = $row;
             }
         } catch (Exception $e) {
             Logger::error($e);
             Notification::warning(sprintf($this->translate('Failed to fetch any users from backend %s. Please check your log'), $backend->getName()));
         }
     }
     return new ArrayDatasource($users);
 }

 /**
  * Create webserver configuration
  *
  * USAGE:
  *
  *  icingacli setup config webserver <apache|nginx> [options]
  *
  * OPTIONS:
  *
  *  --path=<urlpath>                    The URL path to Icinga Web 2 [/icingaweb2]
  *
  *  --root|--document-root=<directory>  The directory from which the webserver will serve files [/path/to/icingaweb2/public]
  *
  *  --config=<directory>                Path to Icinga Web 2's configuration files [/etc/icingaweb2]
  *
  *  --file=<filename>                   Write configuration to file [stdout]
  *
  * EXAMPLES:
  *
  *  icingacli setup config webserver apache
  *
  *  icingacli setup config webserver apache --path=/icingaweb2 --document-root=/usr/share/icingaweb2/public --config=/etc/icingaweb2
  *
  *  icingacli setup config webserver apache --file=/etc/apache2/conf.d/icingaweb2.conf
  *
  *  icingacli setup config webserver nginx
  */
 public function webserverAction()
 {
     if (($type = $this->params->getStandalone()) === null) {
         $this->fail($this->translate('Argument type is mandatory.'));
     }
     try {
         $webserver = Webserver::createInstance($type);
     } catch (ProgrammingError $e) {
         $this->fail($this->translate('Unknown type') . ': ' . $type);
     }
     $urlPath = trim($this->params->get('path', $webserver->getUrlPath()));
     if (strlen($urlPath) === 0) {
         $this->fail($this->translate('The argument --path expects a URL path'));
     }
     $documentRoot = trim($this->params->get('root', $this->params->get('document-root', $webserver->getDocumentRoot())));
     if (strlen($documentRoot) === 0) {
         $this->fail($this->translate('The argument --root/--document-root expects a directory from which the webserver will serve files'));
     }
     $configDir = trim($this->params->get('config', $webserver->getConfigDir()));
     if (strlen($configDir) === 0) {
         $this->fail($this->translate('The argument --config expects a path to Icinga Web 2\'s configuration files'));
     }
     $webserver->setDocumentRoot($documentRoot)->setConfigDir($configDir)->setUrlPath($urlPath);
     $config = $webserver->generate() . "\n";
     if (($file = $this->params->get('file')) !== null) {
         if (file_exists($file) === true) {
             $this->fail(sprintf($this->translate('File %s already exists. Please delete it first.'), $file));
         }
         Logger::info($this->translate('Write %s configuration to file: %s'), $type, $file);
         $re = file_put_contents($file, $config);
         if ($re === false) {
             $this->fail($this->translate('Could not write to file') . ': ' . $file);
         }
         Logger::info($this->translate('Successfully written %d bytes to file'), $re);
         return true;
     }
     echo $config;
     return true;
 }