PHP OutputInterface::getVerbosity方法代码示例

 /**
  * Execute command
  *
  * @param InputInterface $input
  * @param OutputInterface $output
  *
  * @return bool
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $quiet = $output->getVerbosity() == OutputInterface::VERBOSITY_QUIET;
     $verbose = $output->getVerbosity() == OutputInterface::VERBOSITY_VERBOSE;
     if (!$quiet) {
         $output->write('<info>' . $this->getApplication()->getName() . '</info>');
         $output->write(' version <comment>' . $this->getApplication()->getVersion() . '</comment> ');
         $output->writeln("by J.Ginés Hernández G. <jgines@gmail.com>\n");
     }
     $sourcePath = $input->getArgument('source');
     $destPath = $input->getArgument('dest');
     $formatType = $input->getOption('format');
     $sortImg = new PhotoSort($verbose);
     $items = $sortImg->copy($sourcePath, $destPath, $formatType);
     if ($verbose) {
         if (count($items)) {
             $table = new Table($output);
             $table->setHeaders(array('Old File', 'New File'));
             $table->setRows($items);
             $table->render();
         }
         $output->writeln("\nCheers!\n");
     }
     return true;
 }

 /**
  * Executes the application.
  *
  * Available options:
  *
  *  * interactive:               Sets the input interactive flag
  *  * decorated:                 Sets the output decorated flag
  *  * verbosity:                 Sets the output verbosity flag
  *  * capture_stderr_separately: Make output of stdOut and stdErr separately available
  *
  * @param array $input   An array of arguments and options
  * @param array $options An array of options
  *
  * @return int The command exit code
  */
 public function run(array $input, $options = array())
 {
     $this->input = new ArrayInput($input);
     if (isset($options['interactive'])) {
         $this->input->setInteractive($options['interactive']);
     }
     $this->captureStreamsIndependently = array_key_exists('capture_stderr_separately', $options) && $options['capture_stderr_separately'];
     if (!$this->captureStreamsIndependently) {
         $this->output = new StreamOutput(fopen('php://memory', 'w', false));
         if (isset($options['decorated'])) {
             $this->output->setDecorated($options['decorated']);
         }
         if (isset($options['verbosity'])) {
             $this->output->setVerbosity($options['verbosity']);
         }
     } else {
         $this->output = new ConsoleOutput(isset($options['verbosity']) ? $options['verbosity'] : ConsoleOutput::VERBOSITY_NORMAL, isset($options['decorated']) ? $options['decorated'] : null);
         $errorOutput = new StreamOutput(fopen('php://memory', 'w', false));
         $errorOutput->setFormatter($this->output->getFormatter());
         $errorOutput->setVerbosity($this->output->getVerbosity());
         $errorOutput->setDecorated($this->output->isDecorated());
         $reflectedOutput = new \ReflectionObject($this->output);
         $strErrProperty = $reflectedOutput->getProperty('stderr');
         $strErrProperty->setAccessible(true);
         $strErrProperty->setValue($this->output, $errorOutput);
         $reflectedParent = $reflectedOutput->getParentClass();
         $streamProperty = $reflectedParent->getProperty('stream');
         $streamProperty->setAccessible(true);
         $streamProperty->setValue($this->output, fopen('php://memory', 'w', false));
     }
     return $this->statusCode = $this->application->run($this->input, $this->output);
 }

 protected function initHandlers(OutputInterface $output)
 {
     $this->output = $output;
     $this->formatter = $this->getHelperSet()->get('formatter');
     $this->is_verbose = $this->output->getVerbosity() >= OutputInterface::VERBOSITY_NORMAL;
     $this->logger = $this->getContainer()->get('logger');
 }

 /**
  * Execute the console command
  *
  * @param  InputInterface  $input
  * @param  OutputInterface $output
  */
 public function execute(InputInterface $input, OutputInterface $output)
 {
     $this->input = $input;
     $this->output = $output;
     $logger = $this->logger;
     Resque_Event::listen('onFailure', function ($exception, $job) use($logger) {
         $logger->error('Error processing job', ['exception' => $exception]);
     });
     if ($input->getOption('shutdown')) {
         $this->shutdownWorkers();
         return;
     }
     $queues = $input->getArgument('queue');
     if (!count($queues)) {
         throw new RuntimeException('Not enough arguments.');
     }
     $count = $input->getOption('count');
     $interval = $input->getOption('interval');
     if ($output->getVerbosity() === OutputInterface::VERBOSITY_VERBOSE) {
         $logLevel = Resque_Worker::LOG_NORMAL;
     } elseif ($output->getVerbosity() >= OutputInterface::VERBOSITY_VERY_VERBOSE) {
         $logLevel = Resque_Worker::LOG_VERBOSE;
     } else {
         $logLevel = Resque_Worker::LOG_NONE;
     }
     $this->startWorkers($queues, $count, $logLevel, $interval);
 }

 /**
  * @param array $input
  * @throws \Exception
  */
 protected function handleError(array $input)
 {
     if (OutputInterface::VERBOSITY_VERBOSE <= $this->output->getVerbosity()) {
         $this->output->writeln(print_r($input, true));
     }
     throw new \Exception($input['message']);
 }

 protected function logVerbose($msg)
 {
     if ($this->output->getVerbosity() < OutputInterface::VERBOSITY_VERBOSE) {
         return;
     }
     $this->output->writeln($msg);
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $confirm = $input->getOption('confirm');
     $perms = \Perms::get();
     if (!$perms->admin_file_galleries) {
         throw new \Exception('Tracker Clear: Admin permission required');
     }
     if ($confirm) {
         if ($output->getVerbosity() > OutputInterface::VERBOSITY_NORMAL) {
             $output->writeln('<info>Deleting old filegal files...</info>');
         }
         \TikiLib::lib('filegal')->deleteOldFiles();
         if ($output->getVerbosity() > OutputInterface::VERBOSITY_NORMAL) {
             $output->writeln('<info>Deleting old filegal files done</info>');
         }
     } else {
         $query = 'select * from `tiki_files` where `deleteAfter` < ? - `lastModif` and `deleteAfter` is not NULL and `deleteAfter` != \'\' order by galleryId asc';
         $now = time();
         $files = \TikiDb::get()->query($query, array($now));
         if ($output->getVerbosity() > OutputInterface::VERBOSITY_NORMAL) {
             if ($files->numrows) {
                 $output->writeln("<comment>Files to delete:</comment>");
                 foreach ($files->result as $file) {
                     $old = ceil(abs($now - $file['lastModif']) / 86400);
                     $days = $old > 1 ? 'days' : 'day';
                     $deleteAfter = \TikiLib::lib('tiki')->get_short_datetime($file['deleteAfter']);
                     $output->writeln("<info>    \"{$file['name']}\" is {$old} {$days} old in gallery #{$file['galleryId']} (id #{$file['fileId']} deleteAfter {$deleteAfter})</info>");
                 }
             } else {
                 $output->writeln("<comment>No files to delete</comment>");
             }
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     /* @var $listener \Hearsay\SuperfeedrBundle\Listening\ListenerInterface */
     $listener = $this->getContainer()->get('hearsay_superfeedr.listener');
     $listener->addNotificationHandler(new NotificationPrinter($output));
     if ($output->getVerbosity() >= OutputInterface::VERBOSITY_NORMAL) {
         $output->writeln('');
         $output->writeln('<info>Listening for messages...</info>');
         $output->writeln('');
     }
     try {
         $listener->listen();
     } catch (\Exception $exception) {
         if ($input->getOption('die')) {
             // @codeCoverageIgnoreStart
             die($exception->getMessage() . "\n");
             // @codeCoverageIgnoreEnd
         } else {
             throw $exception;
         }
     }
     if ($output->getVerbosity() >= OutputInterface::VERBOSITY_NORMAL) {
         $output->writeln('<info>Finished listening.</info>');
     }
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $sshUrl = $this->getSelectedEnvironment()->getSshUrl($this->selectApp($input));
     if ($input->getOption('pipe')) {
         $output->write($sshUrl);
         return 0;
     }
     $remoteCommand = $input->getArgument('cmd');
     if (!$remoteCommand && $this->runningViaMulti) {
         throw new \InvalidArgumentException('The cmd argument is required when running via "multi"');
     }
     $sshOptions = 't';
     // Pass through the verbosity options to SSH.
     if ($output->getVerbosity() >= OutputInterface::VERBOSITY_DEBUG) {
         $sshOptions .= 'vv';
     } elseif ($output->getVerbosity() >= OutputInterface::VERBOSITY_VERY_VERBOSE) {
         $sshOptions .= 'v';
     } elseif ($output->getVerbosity() <= OutputInterface::VERBOSITY_QUIET) {
         $sshOptions .= 'q';
     }
     $command = "ssh -{$sshOptions} " . escapeshellarg($sshUrl);
     if ($remoteCommand) {
         $command .= ' ' . escapeshellarg($remoteCommand);
     }
     return $this->getHelper('shell')->executeSimple($command);
 }

 /**
  * Run a command through the ProcessBuilder.
  *
  * @param string|array $command
  * @param bool         $allowFailures
  * @param \Closure     $callback           Callback for Process (e.g. for logging output in realtime)
  * @param bool         $cacheMultipleCalls Call multiple calls with this command (to speed-up execution)
  *
  * @throws \RuntimeException
  * @throws \InvalidArgumentException
  *
  * @return string
  */
 public function runCommand($command, $allowFailures = false, $callback = null, $cacheMultipleCalls = false)
 {
     if (is_string($command)) {
         $command = $this->parseProcessArguments($command);
     }
     $cacheKey = getcwd() . implode(' ', $command);
     if ($cacheMultipleCalls && isset($this->cache[$cacheKey])) {
         return $this->cache[$cacheKey];
     }
     $builder = new ProcessBuilder($command);
     $builder->setWorkingDirectory(getcwd())->setTimeout(3600);
     $process = $builder->getProcess();
     $remover = function ($untrimmed) {
         return ltrim(rtrim($untrimmed, "'"), "'");
     };
     if ($this->output instanceof OutputInterface) {
         if ($this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
             $commandLine = implode(' ', array_map($remover, explode(' ', $process->getCommandLine())));
             $this->output->writeln('<question>CMD</question> ' . $commandLine);
         }
     }
     $process->run($callback);
     if (!$process->isSuccessful() && !$allowFailures) {
         throw new \RuntimeException($process->getErrorOutput());
     }
     $result = trim($process->getOutput());
     if ($cacheMultipleCalls) {
         $this->cache[$cacheKey] = $result;
     }
     return $result;
 }

 /**
  * @param Process     $process
  * @param bool        $mustRun
  * @param bool        $quiet
  *
  * @return int|string
  * @throws \Exception
  */
 protected function runProcess(Process $process, $mustRun = false, $quiet = true)
 {
     if ($this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
         $this->output->writeln("Running command: <info>" . $process->getCommandLine() . "</info>");
     }
     try {
         $process->mustRun($quiet ? null : function ($type, $buffer) {
             $this->output->write(preg_replace('/^/m', '  ', $buffer));
         });
     } catch (ProcessFailedException $e) {
         if (!$mustRun) {
             return $process->getExitCode();
         }
         // The default for ProcessFailedException is to print the entire
         // STDOUT and STDERR. But if $quiet is disabled, then the user will
         // have already seen the command's output.  So we need to re-throw
         // the exception with a much shorter message.
         $message = "The command failed with the exit code: " . $process->getExitCode();
         $message .= "\n\nFull command: " . $process->getCommandLine();
         if ($quiet) {
             $message .= "\n\nError output:\n" . $process->getErrorOutput();
         }
         throw new \Exception($message);
     }
     $output = $process->getOutput();
     return $output ? rtrim($output) : true;
 }

 public function verbose($log)
 {
     if ($this->output->getVerbosity() > OutputInterface::VERBOSITY_NORMAL) {
         $log = preg_replace('/^/m', "\t", $log);
         $this->output->writeln($log);
     }
 }

 function it_should_not_handle_log_when_verbosity_set_to_quiet(OutputInterface $output)
 {
     $output->getVerbosity()->shouldBeCalled()->willReturn(OutputInterface::VERBOSITY_QUIET);
     $this->isHandling(array('level' => Logger::NOTICE))->shouldReturn(false);
     $output->getVerbosity()->shouldBeCalled()->willReturn(OutputInterface::VERBOSITY_DEBUG);
     $this->isHandling(array('level' => Logger::NOTICE))->shouldReturn(true);
 }

 /**
  * @param Throwable $exception
  */
 protected function outputExceptionTrace(Throwable $exception)
 {
     if ($this->output->getVerbosity() >= $this->options['minTraceVerbosity']) {
         $this->output->writeln(sprintf($this->options['traceTemplate'], $exception->getTraceAsString()));
     }
     return $this;
 }

 /**
  * {@inheritdoc}
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $output->writeln('Start up application with supplied config...');
     $config = $input->getArgument('applicationConfig');
     $path = stream_resolve_include_path($config);
     if (!is_readable($path)) {
         throw new \InvalidArgumentException("Invalid loader path: {$config}");
     }
     // Init the application once using given config
     // This way the late static binding on the AspectKernel
     // will be on the goaop-zf2-module kernel
     \Zend\Mvc\Application::init(include $path);
     if (!class_exists(AspectKernel::class, false)) {
         $message = "Kernel was not initialized yet. Maybe missing module Go\\ZF2\\GoAopModule in config {$path}";
         throw new \InvalidArgumentException($message);
     }
     $kernel = AspectKernel::getInstance();
     $options = $kernel->getOptions();
     if (empty($options['cacheDir'])) {
         throw new \InvalidArgumentException('Cache warmer require the `cacheDir` options to be configured');
     }
     $enumerator = new Enumerator($options['appDir'], $options['includePaths'], $options['excludePaths']);
     $iterator = $enumerator->enumerate();
     $totalFiles = iterator_count($iterator);
     $output->writeln("Total <info>{$totalFiles}</info> files to process.");
     $iterator->rewind();
     set_error_handler(function ($errno, $errstr, $errfile, $errline) {
         throw new \ErrorException($errstr, $errno, 0, $errfile, $errline);
     });
     $index = 0;
     $errors = [];
     foreach ($iterator as $file) {
         if ($output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
             $output->writeln("Processing file <info>{$file->getRealPath()}</info>");
         }
         $isSuccess = null;
         try {
             // This will trigger creation of cache
             file_get_contents(FilterInjectorTransformer::PHP_FILTER_READ . SourceTransformingLoader::FILTER_IDENTIFIER . '/resource=' . $file->getRealPath());
             $isSuccess = true;
         } catch (\Exception $e) {
             $isSuccess = false;
             $errors[$file->getRealPath()] = $e;
         }
         if ($output->getVerbosity() == OutputInterface::VERBOSITY_NORMAL) {
             $output->write($isSuccess ? '.' : '<error>E</error>');
             if (++$index % 50 == 0) {
                 $output->writeln("({$index}/{$totalFiles})");
             }
         }
     }
     restore_error_handler();
     if ($output->getVerbosity() >= OutputInterface::VERBOSITY_VERY_VERBOSE) {
         foreach ($errors as $file => $error) {
             $message = "File {$file} is not processed correctly due to exception: {$error->getMessage()}";
             $output->writeln($message);
         }
     }
     $output->writeln('<info>Done</info>');
 }