PHP ProgressBar::setMessage方法代码示例

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $io = new SymfonyStyle($input, $output);
     $io->title('Exporting databases');
     $io->section('Exporting all databases');
     $strategies = $this->collectorDbStrategy->collectDatabasesStrategies();
     $totalStrategies = count($strategies);
     $io->writeln($totalStrategies . ' strategie(s) found.');
     $progressBar = new ProgressBar($output, $totalStrategies);
     $progressBar->setFormat(self::PROGRESS_BAR_FORMAT);
     $progressBar->setMessage('Beginning backuping');
     $this->eventDispatcher->dispatch(Events::BACKUP_BEGINS, new BackupBeginsEvent($output));
     $progressBar->start();
     $reportContent = new \ArrayObject();
     foreach ($strategies as $strategy) {
         $strategyIdentifier = $strategy->getIdentifier();
         $setProgressBarMessage = function ($message) use($progressBar, $strategyIdentifier) {
             $message = "[{$strategyIdentifier}] {$message}";
             $progressBar->setMessage($message);
             $progressBar->display();
         };
         $exportedFiles = $this->processorDatabaseDumper->dump($strategy, $setProgressBarMessage);
         $reportContent->append("Backuping of the database: {$strategyIdentifier}");
         foreach ($exportedFiles as $file) {
             $filename = $file->getPath();
             $reportContent->append("\t→ {$filename}");
         }
         $progressBar->advance();
     }
     $progressBar->finish();
     $io->newLine(2);
     $io->section('Report');
     $io->text($reportContent->getArrayCopy());
     $this->eventDispatcher->dispatch(Events::BACKUP_ENDS, new BackupEndsEvent($output));
 }

 /**
  * Set progress bar. Once a progress bar has been set on an invoker, it
  * cannot be undone. Instantiate a new invoker if needed. Sub sequent calls
  * to `Invoker::execute()` will reuse the progress bar object.
  *
  * @param ProgressBar $bar
  * @return Invoker
  */
 public function setProgressBar(ProgressBar $bar)
 {
     // start progress bar
     $this->dispatcher->addListener(Events::INVOKER_START, function (InvokerEvent $event) use($bar) {
         $bar->start($event->getSteps()->getUnits());
     });
     // finish progress bar
     $this->dispatcher->addListener(Events::INVOKER_FINISH, function (InvokerEvent $event) use($bar) {
         $bar->setMessage('Finished: ' . $event->getSteps()->getName());
         $bar->finish();
     });
     // step start
     $this->dispatcher->addListener(Events::STEP_BEFORE_EXECUTE, function (StepEvent $event) use($bar) {
         $bar->setMessage($event->getStep()->getDescription() . '...');
         $bar->display();
     });
     // step finish
     $this->dispatcher->addListener(Events::STEP_AFTER_EXECUTE, function (StepEvent $event) use($bar) {
         $bar->advance($event->getStep()->getTicksRemaining());
     });
     // step tick
     $this->dispatcher->addListener(Events::STEP_TICK, function (StepEvent $event) use($bar) {
         $bar->advance($event->getStep()->getTick());
     });
     return $this;
 }

 /**
  * @param OutputInterface $output
  * @param Repository $source
  * @param WritableRepository $destination
  */
 private function setupProgressBar(OutputInterface $output, Repository $source, WritableRepository $destination)
 {
     $this->progress = new ProgressBar($output, count($source));
     $this->progress->setMessage('Generating database...');
     $this->progress->start();
     $destination->attach($this);
 }

 /**
  * @param $total
  * @param OutputInterface $output
  * @param callable        $callback
  */
 public function mainProgressBarAction($total, $output, callable $callback)
 {
     // Перенос строки
     $output->writeln("\n");
     // Инициализируем прогресс бар
     $progress = new ProgressBar($output, $total);
     $progress->setFormat("<info>%message%\n Фильм %current% из %max% [%bar%] %percent:3s%% %elapsed:6s%/%estimated:-6s% %memory:6s%</info>");
     $progress->setMessage('Процесс запущен');
     $progress->start();
     // Инициализируем цикл и выполняем
     $progress->setMessage('В процессе...');
     for ($i = 0; $i < $total; $i++) {
         // Задержка
         sleep(Config::DELAY_BETWEEN_REQUESTS);
         // Выполняем колбэк
         $callback();
         // Передвигаем прогресс бар
         $progress->advance();
     }
     // Завершаем прогресс бар
     $progress->setMessage('Процесс завершен');
     $progress->finish();
     // Перенос строки
     $output->writeln("\n");
 }

 /**
  * @param TaskEvent $event
  */
 public function advanceProgress(TaskEvent $event)
 {
     $taskReflection = new ReflectionClass($event->getTask());
     $taskName = $taskReflection->getShortName();
     $this->progressBar->setFormat($this->progressFormat);
     $this->progressBar->setMessage($taskName);
     $this->progressBar->advance();
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $config = $this->get('config');
     $client = $this->get('client');
     $type = $input->getOption('type');
     if (empty($type)) {
         $type = $config->get('default_type');
     }
     $filter = sprintf('%s is null', self::UNSUBSCRIBE_ATTRIBUTE);
     if (!empty($input->getArgument('filter'))) {
         $filter .= ' AND (' . $input->getArgument('filter') . ')';
     }
     // Total count records with unsubscribe attribute value empty / null.
     $total_count = $this->getEntityCount($type, $filter);
     $output->writeln(sprintf('<info>Found %d records where "%s"</info>', $total_count, $filter));
     // Confirm update.
     $question = new ConfirmationQuestion(sprintf('Update these %d records? [y/n] ', $total_count), false);
     $helper = $this->getHelper('question');
     if (!$helper->ask($input, $output, $question)) {
         exit(0);
     }
     $progress = new ProgressBar($output, $total_count);
     $progress->setFormat(" %current%/%max% [%bar%] %percent:3s%% \n%message%");
     $updateParams = array('type_name' => $type, 'attributes' => array(self::UNSUBSCRIBE_ATTRIBUTE => ''));
     $succeed = 0;
     $failed = 0;
     $offset = 0;
     $records = $this->retrieveRecords($this->getQueryParams($offset, $type, $filter));
     if (empty($records)) {
         $output->write('No records to update.');
         exit(0);
     }
     $progress->setMessage('Retrieving records...');
     $progress->start();
     while (!empty($records)) {
         foreach ($records as $record) {
             $updateParams['attributes'][self::UNSUBSCRIBE_ATTRIBUTE] = sha1($record['uuid'] . $record['created']);
             $progress->setMessage(sprintf('Update record with id %s', $record['id']));
             $result = $client->api('entity')->updateById($record['id'], $updateParams);
             if ('ok' === strtolower($result['stat'])) {
                 $succeed++;
             } else {
                 $failed++;
             }
             $progress->advance();
         }
         $offset += sizeof($records);
         $progress->setMessage('Retrieving records...');
         $records = $this->retrieveRecords($this->getQueryParams($offset, $type, $filter));
     }
     if ($failed > 0) {
         $progress->setMessage(sprintf('<info>%d</info> records are successfully updated, but<error>%d</error> records are failed to update. Please try run this command again.', $succeed, $failed));
     } else {
         $progress->setMessage(sprintf('<info>%d</info> records are successfully updated.', $succeed));
     }
     $progress->finish();
     exit($failed > 0 ? 1 : 0);
 }

 /**
  * @param RunnerEvent $runnerEvent
  */
 public function finishProgress(RunnerEvent $runnerEvent)
 {
     if ($this->progressBar->getProgress() != $this->progressBar->getMaxSteps()) {
         $this->progressBar->setFormat('<fg=red>%message%</fg=red>');
         $this->progressBar->setMessage('Aborted ...');
     }
     $this->progressBar->finish();
     $this->output->writeln('');
 }

 /**
  * Log
  *
  * @param string $message
  */
 public function log($message)
 {
     if ($this->progress) {
         $this->progress->setMessage($message);
         $this->logs[] = $message;
     } else {
         $this->output->writeLn($message);
     }
 }

 /**
  * Executes the current command.
  *
  * This method is not abstract because you can use this class
  * as a concrete class. In this case, instead of defining the
  * execute() method, you set the code to execute by passing
  * a Closure to the setCode() method.
  *
  * @param InputInterface $input An InputInterface instance
  * @param OutputInterface $output An OutputInterface instance
  *
  * @return null|int null or 0 if everything went fine, or an error code
  *
  * @see setCode()
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $entity = $input->getArgument('entity');
     /** @var EntityManager $entityManager */
     $entityManager = $this->getContainer()->get('doctrine.orm.entity_manager');
     if ($entity === 'article') {
         $output->writeln('<comment>This might take a while.</comment>');
         $journals = $entityManager->getRepository('OjsJournalBundle:Journal')->findAll();
         $totalProgress = new ProgressBar($output, count($journals));
         $totalProgress->setFormat('%current%/%max% [%bar%] %message%');
         if ($totalProgress->getMaxSteps() > 0) {
             $totalProgress->setMessage('Numerating...');
             $totalProgress->start();
         }
         /** @var Journal $journal */
         foreach ($journals as $journal) {
             $articles = $entityManager->getRepository('OjsJournalBundle:Article')->findBy(['journal' => $journal]);
             $totalProgress->setMessage('Numerating articles of "' . $journal->getTitle() . '"');
             foreach ($articles as $article) {
                 NumeratorHelper::numerateArticle($article, $entityManager);
             }
             $totalProgress->advance();
         }
         $totalProgress->finish();
         $output->writeln('');
         // Necessary, unfortunately.
         $output->writeln('<info>Done.</info>');
     } else {
         if ($entity === 'issue') {
             $output->writeln('<comment>This might take a while.</comment>');
             $journals = $entityManager->getRepository('OjsJournalBundle:Journal')->findAll();
             $totalProgress = new ProgressBar($output, count($journals));
             $totalProgress->setFormat('%current%/%max% [%bar%] %message%');
             if ($totalProgress->getMaxSteps() > 0) {
                 $totalProgress->setMessage('Numerating...');
                 $totalProgress->start();
             }
             /** @var Journal $journal */
             foreach ($journals as $journal) {
                 $issues = $entityManager->getRepository('OjsJournalBundle:Issue')->findBy(['journal' => $journal]);
                 $totalProgress->setMessage('Numerating issues of "' . $journal->getTitle() . '"');
                 foreach ($issues as $issue) {
                     NumeratorHelper::numerateIssue($issue, $entityManager);
                 }
                 $totalProgress->advance();
             }
             $totalProgress->finish();
             $output->writeln('');
             // Necessary, unfortunately.
             $output->writeln('<info>Done.</info>');
         } else {
             $output->writeln('<error>This entity is not yet supported.</error>');
         }
     }
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $defaultEntityManager = $this->getContainer()->get('doctrine.orm.default_entity_manager');
     $legacyEntityManager = $this->getContainer()->get('doctrine.orm.legacy_entity_manager');
     $legacyCommentsRepository = $legacyEntityManager->getRepository('LegacyBundle:Comment');
     $legacyParameterRepository = $legacyEntityManager->getRepository('LegacyBundle:Parameter');
     $authorRepository = $defaultEntityManager->getRepository('AppBundle:Author');
     $mentionRepository = $defaultEntityManager->getRepository('AppBundle:Mention');
     $legacyComments = $legacyCommentsRepository->findAll();
     $progress = new ProgressBar($output, count($legacyComments));
     $progress->start();
     $progress->setFormat(' %current%/%max% [%bar%] %percent:3s%% %message%');
     $progress->setMessage('Copying legacy data');
     foreach ($legacyComments as $legacyComment) {
         $userId = $legacyComment->getUser()->getId();
         $author = $authorRepository->findOneBy(['userId' => $userId]);
         if (null === $author) {
             $author = new Author();
             $author->setUserId($legacyComment->getUser()->getId());
             $author->setUsername($legacyComment->getUser()->getUsername());
             $avatarParameter = $legacyParameterRepository->findOneBy(['userId' => $legacyComment->getUser()->getId(), 'parameterId' => 4]);
             if (null !== $avatarParameter) {
                 $author->setAvatarFilename($avatarParameter->getValue());
             }
             $defaultEntityManager->persist($author);
             $defaultEntityManager->flush($author);
         }
         $comment = new Comment();
         $comment->setId($legacyComment->getId());
         $comment->setPostId($legacyComment->getPostId());
         $comment->setContent($legacyComment->getContent());
         $comment->setCreatedAt($legacyComment->getCreatedAt());
         $comment->setActive($legacyComment->getActive());
         $comment->setAuthor($author);
         foreach ($legacyComment->getMentions() as $legacyMention) {
             $mention = $mentionRepository->findOneBy(['userId' => $legacyMention->getUser()->getId()]);
             if (null === $mention) {
                 $mention = new Mention();
                 $mention->setUserId($legacyMention->getUser()->getId());
                 $mention->setUsername($legacyMention->getUser()->getUsername());
                 $defaultEntityManager->persist($mention);
                 $defaultEntityManager->flush($mention);
             }
             $comment->addMention($mention);
         }
         $defaultEntityManager->persist($comment);
         $progress->advance();
     }
     $defaultEntityManager->flush();
     $progress->setMessage('Data has been copied');
     $progress->finish();
     $output->writeln('');
 }

 /**
  * @param array $data
  */
 protected function onStatus(array $data)
 {
     if (isset($data['current'])) {
         $this->progress->setCurrent((int) $data['current']);
         unset($data['current']);
     } else {
         $this->progress->advance();
     }
     foreach ($data as $key => $value) {
         $this->progress->setMessage($value, $key);
     }
 }

 /**
  * Run a terminal command
  * @param  [array]         $command  [description]
  * @param  [path]          $directory [description]
  * @param  OutputInterface $output    [description]
  * @return [void]                     [description]
  */
 private function runProcess($command, $directory, $output, $alias)
 {
     $output->writeln('');
     if (is_array($command['line'])) {
         $commandLine = implode(' && ', $command['line']);
     } else {
         $commandLine = $command['line'];
     }
     $process = new Process($commandLine, $directory);
     $process->setTimeout(7600);
     $process->start();
     if ($output->isVerbose()) {
         $process->wait(function ($type, $buffer) {
             echo $buffer;
         });
     } else {
         $progress = new ProgressBar($output);
         $progress->setFormat("<comment>%message%</comment> [%bar%]");
         $progress->setMessage($command['title']);
         $progress->start();
         $progress->setRedrawFrequency(10000);
         while ($process->isRunning()) {
             $progress->advance();
         }
         $progress->finish();
         $progress->clear();
     }
     $output->writeln('');
     $output->write('<comment>' . $command['title'] . ' </comment><info>√ done</info>');
 }

 /**
  * Shoot the create dojo command into the command bus
  *
  * @param $externalDojo
  */
 private function createDojo($externalDojo)
 {
     $this->progressBar->setMessage('Creating new dojo');
     $this->commandBus->handle($externalDojo);
     $this->progressBar->advance();
     $this->countNew++;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $desde = (int) $input->getArgument('desde');
     $cantidad = 100;
     $progress = null;
     $importador = new ImportadorAgentes($this->getContainer(), $this->getContainer()->get('doctrine')->getManager());
     $importador->Inicializar();
     $progress = new ProgressBar($output, $importador->ObtenerCantidadTotal());
     $progress->setRedrawFrequency(1);
     $progress->setMessage('Importando agentes...');
     $progress->start();
     $ResultadoFinal = new ResultadoImportacion($importador);
     while (true) {
         $resultado = $importador->Importar($desde, $cantidad);
         $ResultadoFinal->AgregarContadoresLote($resultado);
         if (!$resultado->HayMasRegistros()) {
             break;
         }
         $desde += $cantidad;
         $progress->advance($cantidad);
     }
     $progress->finish();
     $output->writeln('');
     $output->writeln(' Se importaron   ' . $ResultadoFinal->RegistrosNuevos . ' registros nuevos.');
     $output->writeln(' Se actualizaron ' . $ResultadoFinal->RegistrosActualizados . ' registros.');
     $output->writeln(' Se ignoraron    ' . $ResultadoFinal->RegistrosIgnorados . ' registros.');
     $output->writeln('Importación finalizada, se procesaron ' . $ResultadoFinal->TotalRegistrosProcesados() . ' registros.');
 }

 /**
  * Get all available regions.
  * @return mixed|null
  */
 protected function getRegions()
 {
     $this->progress->setMessage("Fetching regions...");
     $this->progress->advance();
     $ec2client = new Ec2Client(['version' => 'latest', 'region' => getenv('AWS_DEFAULT_REGION')]);
     return $ec2client->describeRegions()->search('Regions[].RegionName');
 }